开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 压缩解压 > 查看源码
wizmain.c
资源名称：zipsrc.zip　[点击查看]
上传用户：jlteech
上传日期：2007-01-06
资源大小：349k
文件大小：25k
源码类别：

压缩解压

开发平台：

Visual C++

wizmain.c：源码内容
  1. /****************************************************************************
  3.     PURPOSE:  Windows Info-ZIP
  4.     FUNCTIONS:
  6.         WinMain() - calls initialization function, processes message loop
  7.         WiZInit() - initializes window data and registers window
  8.         WiZMainWndProc() - processes messages
  9.         About() - processes messages for "About" dialog box
  11.     AUTHOR: Robert A. Heath,  157 Chartwell Rd. Columbia, SC 29210
  12.     I place this source module, WizUnZip.c, in the public domain.  Use it as
  13.     you will.
  15.  Modifications: M. White - 1995, 1996
  16. - Ported to Borland C
  17. - Ported to WinNT and Win95
  18. - Added dll functionality
  19. - Added zip functionality
  20. - renamed to wizmain.c
  21. - extensively modified for WiZ
  22. ****************************************************************************/
  24. #include <sys/types.h>
  25. #include <sys/stat.h>
  26. #include <time.h>
  27. #include <string.h>
  28. #include "wiz.h"
  29. #include "wizver.h"
  30. #ifdef WIN32
  31. #include <winver.h>
  32. #else
  33. #include <dir.h>
  34. #include <ver.h>
  35. #endif
  37. #ifdef WIN32
  38. #define UNZ_DLL_NAME "UNZIP32.DLL"
  39. #define ZIP_DLL_NAME "ZIP32.DLL"
  40. #else
  41. #define UNZ_DLL_NAME "UNZIP16.DLL"
  42. #define ZIP_DLL_NAME "ZIP16.DLL"
  44. #  ifndef TEXT
  45. #    define TEXT(x) x
  46. #  endif
  47. #endif
  49. static char __based(__segname("STRINGS_TEXT")) szFirstUse[] = "FirstUse"; /* first use keyword in WiZ.INI */
  50. char __based(__segname("STRINGS_TEXT")) szDefaultUnzipToDir[] = "DefaultUnzipToDir";
  51. char __based(__segname("STRINGS_TEXT")) szDefaultUnzipFromDir[] = "DefaultUnzipFromDir";
  52. char __based(__segname("STRINGS_TEXT")) szLBSelectionKey[] = "LBSelection"; /* LBSelection keyword in WiZ.INI */
  53. char __based(__segname("STRINGS_TEXT")) szHideStatus[] = "HideStatusWindow";
  54. char __based(__segname("STRINGS_TEXT")) szWiZIniFile[] = "WIZ.INI";
  55. char __based(__segname("STRINGS_TEXT")) szZipOptionKey[] = "ZipOptions";
  56. char __based(__segname("STRINGS_TEXT")) szZipToDirKey[] = "ZipToDir";
  58. /* File and Path Name variables */
  59. char __based(__segname("STRINGS_TEXT")) szAppName[] = "WiZ";       /* application title        */
  60. char __based(__segname("STRINGS_TEXT")) szStatusClass[] = "MsgWndw";/* status window class  */
  61. char __based(__segname("STRINGS_TEXT")) szUnzipToDirName[PATH_MAX];    /* extraction ("windll_unzip to") directory name in ANSI */
  63. /* Note that szHelpFileName will be expanded to a fully qualified path
  64.    and file name when we go search for the help file.
  65.  */
  66. #ifdef WIN32
  67. char szHelpFileName[PATH_MAX] = "WIZ32.HLP";
  68. #else
  69. char szHelpFileName[PATH_MAX] = "WIZ16.HLP";
  70. #endif
  72. #define DLL_WARNING "Cannot find %s."
  73.             " The Dll must be in the application directory, the path, "
  74.             "the Windows directory or the Windows System directory."
  75. #define DLL_VERSION_WARNING "%s has the wrong version number."
  76.             " Insure that you have the correct dll's installed, and that "
  77.             "an older dll is not in your path or Windows System directory."
  79. #ifdef WIN32
  80. extern HWND hSplashScreen;
  81. void ShowSplashScreen(void);
  82. #endif
  83. HANDLE hInst;               /* current instance */
  84. HMENU  hMenu;               /* main menu handle */
  85. HANDLE hAccTable;
  87. HANDLE hHourGlass;          /* handle to hourglass cursor */
  88. HANDLE hSaveCursor;         /* current cursor handle */
  89. HANDLE hHelpCursor;         /* help cursor */
  90. HANDLE hFixedFont;          /* handle to fixed font */
  91. HANDLE hOldFont;            /* handle to old font */
  93. int hFile;              /* file handle */
  94. HWND hWndMain;          /* the main window handle. */
  95. HWND hWndList;          /* list box handle */
  96. HWND hWndEdit;        /* status   (a.k.a. Messages) window */
  97. HWND hWndStatic;
  98. HWND hExtract;          /* extract button */
  99. HWND hDisplay;          /*display button */
  100. HWND hTest;             /* test button */
  101. HWND hZipInfo;          /* Zip Info button */
  102. HWND hShowComment;      /* show comment button */
  103. HWND hHelp;   /* help button */
  104. HWND hOpen;   /* open button */
  105. HWND hArchive; /* create archive button */
  106. HWND hDeleteArchive; /* delete button */
  107. HWND hCopyArchive;   /* copy archive button */
  108. HWND hMoveArchive;   /* move archive button */
  109. HWND hRenameArchive; /* rename archive button */
  110. HWND hExit;
  111. HWND hMakeDir;
  112. HWND hSelectAll;
  113. HWND hDeselectAll;
  114. HWND hSelectPattern;
  115. HWND hClearStatus;
  116. HWND hUnzipToDir;
  117. HWND hStatusButton;
  118. HWND hListBoxButton;
  119. int fLB_Selection;
  121. UF  uf;
  123. WPARAM wLBSelection = IDM_LB_DISPLAY; /* default listbox selection action */
  125. HBRUSH hBrush ;         /* brush for  standard window backgrounds  */
  126. LPUMB lpumb;
  128. LPUSERFUNCTIONS lpUserFunctions;
  129. LPZIPUSERFUNCTIONS lpZipUserFunctions;
  130. HANDLE hUF       = (HANDLE)NULL;
  131. LPDCL lpDCL      = NULL;
  132. HANDLE hZUF      = (HANDLE)NULL;
  133. HANDLE hDCL      = (HANDLE)NULL;
  134. ZCL ZpZCL;
  135. ZPOPT ZpOpt;
  136. #ifdef WIN32
  137. HWND       hRTF;
  138. HANDLE  hRTFLib  = (HANDLE)NULL;
  139. DWORD dwPlatformId = 0xFFFFFFFF;
  140. #endif
  141. HINSTANCE hZipDll;
  142. HINSTANCE hUnzipDll;
  145. HANDLE  hStrings = (HANDLE)NULL;
  146. HANDLE  hEditor = (HANDLE)NULL;
  148. int ofretval;       /* return value from initial open if filename given */
  150. WORD cZippedFiles;      /* total personal records in file   */
  151. WORD cListBoxLines; /* max list box lines showing on screen */
  152. WORD cLinesMessageWin; /* max visible lines on message window  */
  154. /* Forward References */
  155. #ifndef USE_UNZIP_LIB
  156. _DLL_UNZVAL Unz_Validate;
  157. _DLL_UNZIP Unz_SingleEntryPoint;
  158. _USER_FUNCTIONS UzInit;
  159. #endif
  160. #ifndef USE_ZIP_LIB
  161. _ZIP_USER_FUNCTIONS ZipInit;
  162. _DLL_ZIP ZipArchive;
  163. ZIPSETOPTIONS ZipSetOptions;
  164. ZIPGETOPTIONS ZipGetOptions;
  165. #endif
  167. void FreeUpMemory(void);
  168. #ifdef WIN32
  169. BOOL IsNT(VOID);
  170. #endif
  171. int WINAPI WinMain(HANDLE, HANDLE, LPSTR, int);
  172. long WINAPI WiZMainWndProc(HWND, WORD, WPARAM, LPARAM);
  174. /****************************************************************************
  176.     FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
  178.     PURPOSE: calls initialization function, processes message loop
  180.     COMMENTS:
  182.         This will initialize the window class if it is the first time this
  183.         application is run.  It then creates the window, and processes the
  184.         message loop until a WM_QUIT message is received.  It exits the
  185.         application by returning the value passed by the PostQuitMessage.
  187. ****************************************************************************/
  188. #ifdef __BORLANDC__
  189. #  ifdef WIN32
  190. #pragma argsused
  191. #  endif
  192. #endif
  193. int WINAPI WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
  194. HANDLE hInstance;         /* current instance             */
  195. HANDLE hPrevInstance;     /* previous instance            */
  196. LPSTR lpCmdLine;          /* command line                 */
  197. int nCmdShow;             /* show-window type (open/icon) */
  198. {
  199. #ifdef WIN32
  200. char *ptr;
  201. DWORD second;   /* Used for timing the splash screen */
  202. #if (!defined(USE_UNZIP_LIB) && !defined(USE_ZIP_LIB))
  203. DWORD dwVerInfoSize;
  204. DWORD dwVerHnd;
  205. HANDLE  hMem;         /* handle to mem alloc'ed */
  206. #endif
  207. #else
  208. HFILE hfile;
  209. OFSTRUCT ofs;
  210. #endif
  211. char szFullPath[PATH_MAX];
  212. int i;
  213. BOOL fFirstUse;           /* first use if TRUE         */
  215. #ifndef WIN32
  216. if (!hPrevInstance)       /* Has application been initialized? */
  217. #endif
  218.    if (!WiZInit(hInstance))
  219.       return 0;           /* Exits if unable to initialize     */
  221. #ifdef WIN32
  222.       InitCommonControls();
  223. if (!hRTFLib)
  224.    hRTFLib = LoadLibrary("RICHED32.DLL");
  226. if (!hRTFLib)
  227.     {
  228.     char szErr[255];
  229.     wsprintf(szErr, "LoadLibrary Failed. Error Code %ld", GetLastError());
  230.     MessageBox(NULL, szErr, szAppName, MB_OK );
  231.     return 0;
  232.     }
  233. IsNT(); /* Are we running on NT? */
  234. #endif
  235. hStrings = GlobalAlloc( GPTR, (DWORD)sizeof(UMB));
  236. if ( !hStrings )
  237.    {
  238. #ifdef WIN32
  239.    FreeLibrary(hRTFLib);
  240. #endif
  241.    return 0;
  242.    }
  244. lpumb = (LPUMB)GlobalLock( hStrings );
  245. if ( !lpumb )
  246.    {
  247.    GlobalFree( hStrings );
  248. #ifdef WIN32
  249.    FreeLibrary(hRTFLib);
  250. #endif
  251.    return 0;
  252.    }
  254. hDCL = GlobalAlloc( GPTR, (DWORD)sizeof(DCL));
  255. if (!hDCL)
  256.    {
  257.    FreeUpMemory();
  258. #ifdef WIN32
  259.    FreeLibrary(hRTFLib);
  260. #endif
  261.    return 0;
  262.    }
  263. lpDCL = (LPDCL)GlobalLock(hDCL);
  264. if (!lpDCL)
  265.    {
  266.    FreeUpMemory();
  267. #ifdef WIN32
  268.    FreeLibrary(hRTFLib);
  269. #endif
  270.    return 0;
  271.    }
  273. hUF = GlobalAlloc( GPTR, (DWORD)sizeof(USERFUNCTIONS));
  274. if (!hUF)
  275.    {
  276.    FreeUpMemory();
  277. #ifdef WIN32
  278.    FreeLibrary(hRTFLib);
  279. #endif
  280.    return 0;
  281.    }
  282. lpUserFunctions = (LPUSERFUNCTIONS)GlobalLock(hUF);
  284. if (!lpUserFunctions)
  285.    {
  286.    FreeUpMemory();
  287. #ifdef WIN32
  288.    FreeLibrary(hRTFLib);
  289. #endif
  290.    return 0;
  291.    }
  293. hZUF = GlobalAlloc( GPTR, (DWORD)sizeof(ZIPUSERFUNCTIONS));
  294. if (!hZUF)
  295.    {
  296.    FreeUpMemory();
  297. #ifdef WIN32
  298.    FreeLibrary(hRTFLib);
  299. #endif
  300.    return 0;
  301.    }
  302. lpZipUserFunctions = (LPZIPUSERFUNCTIONS)GlobalLock(hZUF);
  304. if (!lpZipUserFunctions)
  305.    {
  306.    FreeUpMemory();
  307. #ifdef WIN32
  308.    FreeLibrary(hRTFLib);
  309. #endif
  310.    return 0;
  311.    }
  313. uf.fCanDragDrop = FALSE;
  314. #ifndef WIN32
  315. if ((hHourGlass = GetModuleHandle("SHELL"))!=0)
  316.    {
  317.    if (GetProcAddress(hHourGlass, "DragAcceptFiles" ))
  318.       uf.fCanDragDrop = TRUE;
  319.    }
  320. #else
  321. uf.fCanDragDrop = TRUE;
  322. #endif
  324. lpUserFunctions->password = password;
  325. lpUserFunctions->print = DisplayBuf;
  326. lpUserFunctions->sound = SoundDuring;
  327. lpUserFunctions->replace = GetReplaceDlgRetVal;
  328. lpUserFunctions->SendApplicationMessage = ReceiveDllMessage;
  330. lpZipUserFunctions->print = lpUserFunctions->print;//DisplayBuf;
  331. lpZipUserFunctions->password = password;
  332. lpZipUserFunctions->comment = comment;
  334. hWndMain = CreateWindow(szAppName,      /* window class     */
  335.         szAppName,                      /* window name      */
  336.         WS_OVERLAPPEDWINDOW,            /* window style     */
  337.         0, 0, 0, 0,
  338.         (HWND)0,                        /* parent handle    */
  339.         (HWND)0,                        /* menu or child ID */
  340.         hInstance,                      /* instance         */
  341.         NULL);                          /* additional info  */
  343. if ( !hWndMain )
  344.    {
  345.    FreeUpMemory();
  346. #ifdef WIN32
  347.    FreeLibrary(hRTFLib);
  348. #endif
  349.    return 0;
  350.    }
  352. #ifdef WIN32
  353. ShowSplashScreen();
  354. #endif
  356. /* Let's try to find the help file first */
  357. #ifdef WIN32
  358. if (SearchPath(
  359.     NULL,               /* address of search path               */
  360.     szHelpFileName,     /* address of filename                  */
  361.     NULL,               /* address of extension                 */
  362.     PATH_MAX,           /* size, in characters, of buffer       */
  363.     szFullPath,         /* address of buffer for found filename */
  364.     &ptr                /* address of pointer to file component */
  365.    ) != 0)
  366.    {
  367.    lstrcpy(szHelpFileName, szFullPath);
  368.    }
  369. #else
  370. hfile = OpenFile(szHelpFileName,  &ofs, OF_SEARCH);
  371. if (hfile != HFILE_ERROR)
  372.    {
  373.    lstrcpy(szHelpFileName, ofs.szPathName);
  374.    }
  375. #endif
  377. #ifndef WIN32
  378. _lclose(hfile);
  379. #endif
  380. #ifndef USE_UNZIP_LIB
  381. #ifdef WIN32
  382. if (SearchPath(
  383.     NULL,               /* address of search path               */
  384.     UNZ_DLL_NAME,       /* address of filename                  */
  385.     NULL,               /* address of extension                 */
  386.     PATH_MAX,           /* size, in characters, of buffer       */
  387.     szFullPath,         /* address of buffer for found filename */
  388.     &ptr                /* address of pointer to file component */
  389.    ) == 0)
  390. #else
  391. hfile = OpenFile(UNZ_DLL_NAME,  &ofs, OF_SEARCH);
  392. if (hfile == HFILE_ERROR)
  393. #endif
  394.    {
  395.    char str[256];
  396.    wsprintf (str, DLL_WARNING, UNZ_DLL_NAME);
  397.    MessageBox ((HWND)NULL, str, szAppName, MB_ICONHAND | MB_SYSTEMMODAL | MB_OK);
  398.    FreeUpMemory();
  399. #ifdef WIN32
  400.    DestroyWindow(hSplashScreen);
  401.    FreeLibrary(hRTFLib);
  402. #endif
  403.    return 0;
  404.    }
  405. #ifndef WIN32
  406. else
  407.    lstrcpy(szFullPath, ofs.szPathName);
  408. _lclose(hfile);
  409. #endif
  411. #ifdef WIN32
  412. /* First we'll check the unzip dll version information */
  413. dwVerInfoSize =
  414.     GetFileVersionInfoSize(szFullPath, &dwVerHnd);
  416. if (dwVerInfoSize)
  417.    {
  418.    BOOL  fRet, fRetName;
  419.    char str[256];
  420.    LPSTR   lpstrVffInfo; /* Pointer to block to hold info */
  421.    LPSTR lszVer = NULL;
  422.    LPSTR lszVerName = NULL;
  423.    UINT  cchVer = 0;
  425.    /* Get a block big enough to hold the version information */
  426.    hMem          = GlobalAlloc(GMEM_MOVEABLE, dwVerInfoSize);
  427.    lpstrVffInfo  = GlobalLock(hMem);
  429.    /* Get the version information */
  430.    if (GetFileVersionInfo(szFullPath, 0L, dwVerInfoSize, lpstrVffInfo))
  431.       {
  432.       fRet = VerQueryValue(lpstrVffInfo,
  433.                TEXT("\StringFileInfo\040904E4\FileVersion"),
  434.               (LPVOID)&lszVer,
  435.               &cchVer);
  436.       fRetName = VerQueryValue(lpstrVffInfo,
  437.                TEXT("\StringFileInfo\040904E4\CompanyName"),
  438.                (LPVOID)&lszVerName,
  439.                &cchVer);
  440.       if (!fRet || !fRetName ||
  441.          (lstrcmpi(lszVer, UNZ_DLL_VERSION) != 0) ||
  442.          (lstrcmpi(lszVerName, COMPANY_NAME) != 0))
  443.          {
  444.          wsprintf (str, DLL_VERSION_WARNING, UNZ_DLL_NAME);
  445.          MessageBox((HWND)NULL, str, szAppName, MB_ICONSTOP | MB_OK);
  446.          FreeUpMemory();
  447.          GlobalUnlock(hMem);
  448.          GlobalFree(hMem);
  449.          DestroyWindow(hSplashScreen);
  450.          FreeLibrary(hRTFLib);
  451.          return 0;
  452.          }
  453.       }
  454.       /* free memory */
  455.    GlobalUnlock(hMem);
  456.    GlobalFree(hMem);
  457.    }
  458. else
  459.    {
  460.    char str[256];
  461.    wsprintf (str, DLL_VERSION_WARNING, UNZ_DLL_NAME);
  462.    MessageBox (hWndMain, str, szAppName, MB_ICONSTOP | MB_OK);
  463.    FreeUpMemory();
  464.    DestroyWindow(hSplashScreen);
  465.    FreeLibrary(hRTFLib);
  466.    return 0;
  467.    }
  468. #endif
  469. #endif
  471. #ifndef USE_ZIP_LIB
  472. #ifdef WIN32
  473. if (SearchPath(
  474.     NULL,               /* address of search path               */
  475.     ZIP_DLL_NAME,       /* address of filename                  */
  476.     NULL,               /* address of extension                 */
  477.     PATH_MAX,           /* size, in characters, of buffer       */
  478.     szFullPath,         /* address of buffer for found filename */
  479.     &ptr                /* address of pointer to file component */
  480.    ) == 0)
  481. #else
  482. hfile = OpenFile(ZIP_DLL_NAME,  &ofs, OF_SEARCH);
  483. if (hfile == HFILE_ERROR)
  484. #endif
  485.    {
  486.    char str[256];
  487.    wsprintf (str, DLL_WARNING, ZIP_DLL_NAME);
  488.    MessageBox((HWND)NULL, str, szAppName, MB_ICONSTOP | MB_OK);
  489.    FreeUpMemory();
  490. #ifdef WIN32
  491.    DestroyWindow(hSplashScreen);
  492.    FreeLibrary(hRTFLib);
  493. #endif
  494.    return 0;
  495.    }
  496. #ifndef WIN32
  497. else
  498.    lstrcpy(szFullPath, ofs.szPathName);
  499. _lclose(hfile);
  500. #endif
  502. #ifdef WIN32
  503. /* Now we'll check the zip dll version information */
  504. dwVerInfoSize =
  505.     GetFileVersionInfoSize(szFullPath, &dwVerHnd);
  507. if (dwVerInfoSize)
  508.    {
  509.    BOOL  fRet, fRetName;
  510.    char str[256];
  511.    LPSTR   lpstrVffInfo; /* Pointer to block to hold info */
  512.    LPSTR lszVer = NULL;
  513.    LPSTR lszVerName = NULL;
  514.    UINT  cchVer = 0;
  516.    /* Get a block big enough to hold the version information */
  517.    hMem          = GlobalAlloc(GMEM_MOVEABLE, dwVerInfoSize);
  518.    lpstrVffInfo  = GlobalLock(hMem);
  520.    /* Get the version information */
  521.    GetFileVersionInfo(szFullPath, 0L, dwVerInfoSize, lpstrVffInfo);
  522.    fRet = VerQueryValue(lpstrVffInfo,
  523.               TEXT("\StringFileInfo\040904E4\FileVersion"),
  524.                (LPVOID)&lszVer,
  525.                &cchVer);
  526.    fRetName = VerQueryValue(lpstrVffInfo,
  527.                TEXT("\StringFileInfo\040904E4\CompanyName"),
  528.               (LPVOID)&lszVerName,
  529.               &cchVer);
  530.    if (!fRet || !fRetName ||
  531.       (lstrcmpi(lszVer, ZIP_DLL_VERSION) != 0) ||
  532.       (lstrcmpi(lszVerName, COMPANY_NAME) != 0))
  533.       {
  534.       wsprintf (str, DLL_VERSION_WARNING, ZIP_DLL_NAME);
  535.       MessageBox((HWND)NULL, str, szAppName, MB_ICONSTOP | MB_OK);
  536.       FreeUpMemory();
  537.       GlobalUnlock(hMem);
  538.       GlobalFree(hMem);
  539.       DestroyWindow(hSplashScreen);
  540.       FreeLibrary(hRTFLib);
  541.       return 0;
  542.       }
  543.    /* free memory */
  544.    GlobalUnlock(hMem);
  545.    GlobalFree(hMem);
  546.    }
  547. else
  548.    {
  549.    char str[256];
  550.    wsprintf (str, DLL_VERSION_WARNING, ZIP_DLL_NAME);
  551.    MessageBox((HWND)NULL, str, szAppName, MB_ICONSTOP | MB_OK);
  552.    FreeUpMemory();
  553.    GlobalUnlock(hMem);
  554.    GlobalFree(hMem);
  555.    DestroyWindow(hSplashScreen);
  556.    FreeLibrary(hRTFLib);
  557.    return 0;
  558.    }
  559. #endif /* WIN32? */
  560. #endif
  562. /* Okay, now we know that the dll's exist, and have the proper version
  563.  * information in them. We can go ahead and load them.
  564.  */
  565. #ifndef USE_UNZIP_LIB
  566. hUnzipDll = LoadLibrary(UNZ_DLL_NAME);
  567. #ifndef WIN32
  568. if (hUnzipDll > HINSTANCE_ERROR)
  569. #else
  570. if (hUnzipDll != NULL)
  571. #endif
  572.    {
  573.    (_DLL_UNZIP)Unz_SingleEntryPoint = (_DLL_UNZIP)GetProcAddress(hUnzipDll, "windll_unzip");
  574.    (_DLL_UNZVAL)Unz_Validate =
  575.       (_DLL_UNZVAL)GetProcAddress(hUnzipDll, "UzpValidate");
  576.    if (!Unz_SingleEntryPoint || !Unz_Validate)
  577.       {
  578.       char str[256];
  579.       wsprintf (str, "Could not get entry point to %s", UNZ_DLL_NAME);
  580.       MessageBox((HWND)NULL, str, szAppName, MB_ICONSTOP | MB_OK);
  581.       FreeUpMemory();
  582. #ifdef WIN32
  583.       DestroyWindow(hSplashScreen);
  584.       FreeLibrary(hRTFLib);
  585. #endif
  586.       return 0;
  587.       }
  588.    }
  589. else
  590.    {
  591.    char str[256];
  592.    wsprintf (str, "Could not load %s", UNZ_DLL_NAME);
  593.    MessageBox((HWND)NULL, str, szAppName, MB_ICONSTOP | MB_OK);
  594.    FreeUpMemory();
  595. #ifdef WIN32
  596.    DestroyWindow(hSplashScreen);
  597.    FreeLibrary(hRTFLib);
  598. #endif
  599.    return 0;
  600.    }
  601. #endif
  603. #ifndef USE_ZIP_LIB
  604. hZipDll = LoadLibrary(ZIP_DLL_NAME);
  605. #ifndef WIN32
  606. if (hZipDll > HINSTANCE_ERROR)
  607. #else
  608. if (hZipDll != NULL)
  609. #endif
  610.    {
  611.    (_DLL_ZIP)ZipArchive = (_DLL_ZIP)GetProcAddress(hZipDll, "ZpArchive");
  612.    (ZIPSETOPTIONS)ZipSetOptions = (ZIPSETOPTIONS)GetProcAddress(hZipDll, "ZpSetOptions");
  613.    (ZIPGETOPTIONS)ZipGetOptions = (ZIPGETOPTIONS)GetProcAddress(hZipDll, "ZpGetOptions");
  614.    if (!ZipArchive || !ZipSetOptions || !ZipGetOptions)
  615.       {
  616.       char str[256];
  617.       wsprintf (str, "Could not get entry point to %s", ZIP_DLL_NAME);
  618.       MessageBox((HWND)NULL, str, szAppName, MB_ICONSTOP | MB_OK);
  619.       FreeUpMemory();
  620. #ifdef WIN32
  621.       DestroyWindow(hSplashScreen);
  622.       FreeLibrary(hRTFLib);
  623. #endif
  624.       return 0;
  625.       }
  626.    }
  627. else
  628.    {
  629.    char str[256];
  630.    wsprintf (str, "Could not load %s", ZIP_DLL_NAME);
  631.    MessageBox((HWND)NULL, str, szAppName, MB_ICONSTOP | MB_OK);
  632. #ifndef USE_UNZIP_LIB
  633.    FreeLibrary(hUnzipDll);
  634. #endif
  635.    FreeUpMemory();
  636. #ifdef WIN32
  637.    DestroyWindow(hSplashScreen);
  638.    FreeLibrary(hRTFLib);
  639. #endif
  640.    return 0;
  641.    }
  642. #endif
  644. GetPrivateProfileString(szAppName, szFirstUse, "Yes", lpumb->szBuffer, 256, szWiZIniFile);
  645. if ((fFirstUse = !lstrcmpi(lpumb->szBuffer, "Yes"))!=0) /* first time used as WiZ 4.0   */
  646.    {
  647. /* Flag that this is no longer the first time.                              */
  648.    WritePrivateProfileString(szAppName, szFirstUse, "No", szWiZIniFile);
  649. /* After first use, all options come out of WIZ.INI file                  */
  650.    }
  652. InitSoundOptions();               /* initialize sound options         */
  653. wLBSelection = IDM_LB_DISPLAY;      /* assume default is to display     */
  655. hEditor = GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT, (DWORD)EDIT_BUF_SIZE);
  656. if (!hEditor)
  657.    {
  658.    MessageBox((HWND)NULL, "Could not allocate memory", szAppName, MB_ICONSTOP | MB_OK);
  659. #ifndef USE_UNZIP_LIB
  660.    FreeLibrary(hUnzipDll);
  661. #endif
  662. #ifndef USE_ZIP_LIB
  663.    FreeLibrary(hZipDll);
  664. #endif
  665.    FreeUpMemory();
  666. #ifdef WIN32
  667.    DestroyWindow(hSplashScreen);
  668.    FreeLibrary(hRTFLib);
  669. #endif
  670.    return 0;
  671.    }
  672. pszBuffer = (LPSTR)GlobalLock(hEditor);
  673. CreateButtonBar(hWndMain);
  675. #ifndef USE_ZIP_LIB
  676. (_ZIP_USER_FUNCTIONS)ZipInit = (_ZIP_USER_FUNCTIONS)GetProcAddress(hZipDll, "ZpInit");
  677. if (ZipInit == NULL)
  678.    {
  679.    MessageBox((HWND)NULL, "Cannot get address of ZpInit in Zip dll. Terminating...",
  680.       szAppName, MB_ICONSTOP | MB_OK);
  681. #ifndef USE_UNZIP_LIB
  682.    FreeLibrary(hUnzipDll);
  683. #endif
  684.    FreeLibrary(hZipDll);
  685.    FreeUpMemory();
  686. #ifdef WIN32
  687.    DestroyWindow(hSplashScreen);
  688.    FreeLibrary(hRTFLib);
  689. #endif
  690.    return 0;
  691.    }
  692. #endif   
  693. if (!(*ZipInit)(lpZipUserFunctions))
  694.    {
  695.    MessageBox((HWND)NULL, "Application functions not set up properly. Terminating...",
  696.       szAppName, MB_ICONSTOP | MB_OK);
  697. #ifndef USE_UNZIP_LIB
  698.    FreeLibrary(hUnzipDll);
  699. #endif
  700. #ifndef USE_UNZIP_LIB
  701.    FreeLibrary(hZipDll);
  702. #endif
  703.    FreeUpMemory();
  704. #ifdef WIN32
  705.    DestroyWindow(hSplashScreen);
  706.    FreeLibrary(hRTFLib);
  707. #endif
  708.    return 0;
  709.    }
  710. #ifndef WIN32
  711. if (_fstrlen(lpCmdLine))            /* if filename passed on start-up   */
  712. #else
  713. if (strlen(lpCmdLine))            /* if filename passed on start-up   */
  714. #endif
  715.    {
  716.    if ((lstrcmpi(&lpCmdLine[lstrlen(lpCmdLine) - 4],
  717.       ".zip") != 0) &&
  718.       (lstrcmpi(&lpCmdLine[lstrlen(lpCmdLine) - 4],
  719.       ".exe") != 0))
  720.       {
  721.       lstrcat(lpCmdLine, ".zip");
  722.       }
  723.    if (lstrcmpi(&lpCmdLine[lstrlen(lpCmdLine) - 8],
  724.       ".zip.zip") == 0)
  725.       lpCmdLine[lstrlen(lpCmdLine) - 4] = '';
  726.    if ((ofretval = OpenFile(lpCmdLine, &lpumb->of, OF_EXIST)) >= 0)
  727.       {
  728.       lstrcpy(lpumb->szFileName, lpumb->of.szPathName); /* save file name */
  731.       /* If valid filename change dir to where it lives */
  732.       GetArchiveDir(lpumb->szDirName); /* get archive dir. in ANSI char set */
  733.       if (uf.fUnzipToZipDir || /* unzipping to same directory as archive */
  734.           szUnzipToDirName[0] == '') /* or no default */
  735.           {
  736.           /* take only path portion */
  737.           lstrcpy(szUnzipToDirName, lpumb->szDirName);
  738.           }
  739.       lstrcpy(lpumb->szBuffer, lpumb->szDirName);
  740.       DlgDirList(hWndMain, lpumb->szBuffer, 0, 0, 0); /* go to where archive lives */
  741.       }
  742.    else /* bad file name */
  743.       {
  744.       wsprintf (lpumb->szBuffer, "Cannot open %s", lpCmdLine);
  745.       MessageBox (NULL, lpumb->szBuffer, szAppName, MB_ICONINFORMATION | MB_OK);
  746.       lpumb->szFileName[0] = ''; /* pretend filename doesn't exist  */
  747.       lpumb->szDirName[0] = ''; /* pretend archive dir. doesn't exist  */
  748.       }
  749.    }
  751. if (uf.fUnzipToZipDir || /* unzipping to same directory as archive */
  752.     szUnzipToDirName[0] == '') /* or no default */
  753.     {
  754.     char szLaunchPath[PATH_MAX];
  755. #ifdef WIN32
  756.     GetCurrentDirectory(PATH_MAX, (LPTSTR)szLaunchPath);
  757. #else
  758.  getcwd(szLaunchPath, PATH_MAX); /* get current drive and directory */
  759. #endif
  760.  lstrcpy(lpumb->szDirName, szLaunchPath);
  761.  lstrcpy(szUnzipToDirName, lpumb->szDirName);
  762.  }
  763. UpdateListBox();
  764. UpdateButtons();
  765. /* Enable/Disable buttons */
  766. WinAssert(hSelectAll);
  767. EnableWindow( hSelectAll, FALSE);
  768. WinAssert(hDeselectAll);
  769. EnableWindow( hDeselectAll, FALSE);
  770. WinAssert(hSelectPattern);
  771. EnableWindow( hSelectPattern, FALSE);
  773. /* Throw up splash screen */
  774. #ifdef WIN32
  775. second = (GetTickCount()/1000) + 5;
  776. while ((GetTickCount()/1000) <= second);
  777. DestroyWindow(hSplashScreen);
  778. #endif
  779. SizeWindow();
  781. WinAssert(hWndMain);
  782. ShowWindow(hWndMain, nCmdShow);
  783. ShowWindow(hWndList, SW_SHOW);
  784. ShowWindow(hWndStatic, SW_SHOW);
  785. ShowWindow(hWndEdit, SW_SHOW);
  787. /* On first use, throw up About box, saying what WiZ is, etc. */
  788. if (fFirstUse)
  789.    {
  790.    PostMessage(hWndMain, WM_COMMAND, IDM_ABOUT, 0L);
  791.    }
  792. hHelpCursor = LoadCursor(hInstance, "HelpCursor");
  794. while ( GetMessage(&lpumb->msg, 0, 0, 0) )
  795.    {
  796.    if (hPatternSelectDlg == 0 || /* Pattern select dialog is non-modal */
  797.       !IsDialogMessage(hPatternSelectDlg, &lpumb->msg))
  798.       {
  799.       /* What we are doing here is to intercept the right mouse button up
  800.          command if it is being sent to Wiz's main window, or any of it's
  801.          child windows - such as the list box or edit box. We then process
  802.          the WM_RBUTTONUP message for either the listbox or the editbox
  803.          as though it were sent to the main window. Another way to do this
  804.          would be to subclass both those windows, but this seems a lot
  805.          easier, with less code involved.
  807.          This would also be much easier if we were only dealing with 32
  808.          bit windows, but we also have to deal with the 16 bit version.
  809.        */
  810.       if ((lpumb->msg.message == WM_RBUTTONUP) &&
  811.          ((lpumb->msg.hwnd == hWndStatic) ||
  812.          (lpumb->msg.hwnd == hWndEdit) ||
  813.          (lpumb->msg.hwnd == hWndList)))
  814.          {
  815.          lpumb->msg.hwnd = hWndMain;
  816.          DispatchMessage(&lpumb->msg);
  817.          }
  818.       else
  819.            if ( !TranslateAccelerator(hWndMain, hAccTable, &lpumb->msg) )
  820.               {
  821.               TranslateMessage(&lpumb->msg);
  822.               DispatchMessage(&lpumb->msg);
  823.               }
  824.       }
  825.    }
  826. /* Don't turn on compiler aliasing or C7 will move */
  827. /* the following assignment after the GlobalFree() */
  828. /* which contains the memory for pumb! */
  829. i = (int)lpumb->msg.wParam;
  831. FreeUpMemory();
  832. #ifndef USE_UNZIP_LIB
  833. FreeLibrary(hZipDll);
  834. #endif
  835. #ifndef USE_ZIP_LIB
  836. FreeLibrary(hUnzipDll);
  837. #endif
  838. #ifdef WIN32
  839. FreeLibrary(hRTFLib);
  840. #endif
  841. return i;
  842. }
  844. int WINAPI GetReplaceDlgRetVal(char *filename)
  845. {
  846. FARPROC lpfnprocReplace;
  847. int ReplaceDlgRetVal;   /* replace dialog return value */
  849. ShowCursor(FALSE);      /* turn off cursor */
  850. SetCursor(hSaveCursor); /* restore the cursor */
  851. lpfnprocReplace = MakeProcInstance(ReplaceProc, hInst);
  852. ReplaceDlgRetVal = DialogBoxParam(hInst, "Replace",
  853.    hWndMain, lpfnprocReplace, (DWORD)(LPSTR)filename);
  854. #ifndef WIN32
  855. FreeProcInstance(lpfnprocReplace);
  856. #endif
  857. hSaveCursor = SetCursor(hHourGlass);
  858. ShowCursor(TRUE);
  859. return ReplaceDlgRetVal;
  860. }
  862. void FreeUpMemory(void)
  863. {
  864. if (hStrings)
  865.    {
  866.    GlobalUnlock(hStrings);
  867.    GlobalFree(hStrings);
  868.    }
  869. if (hDCL)
  870.    {
  871.    GlobalUnlock(hDCL);
  872.    GlobalFree(hDCL);
  873.    }
  874. if (hEditor)
  875.    {
  876.    GlobalUnlock(hEditor);
  877.    GlobalFree(hEditor);
  878.    }
  879. if (hUF)
  880.    {
  881.    GlobalUnlock(hUF);
  882.    GlobalFree(hUF);
  883.    }
  884. if (hZUF)
  885.    {
  886.    GlobalUnlock(hZUF);
  887.    GlobalFree(hZUF);
  888.    }
  889. }
  890. #ifdef WIN32
  891. BOOL IsNT(VOID)
  892. {
  893. if(dwPlatformId != 0xFFFFFFFF)
  894.    return dwPlatformId;
  895. else
  896. /* note: GetVersionEx() doesn't exist on WinNT 3.1 */
  897.    {
  898.    if(GetVersion() < 0x80000000)
  899.       {
  900.       (BOOL)dwPlatformId = TRUE;
  901.       }
  902.    else
  903.       {
  904.       (BOOL)dwPlatformId = FALSE;
  905.       }
  906.     }
  907. return dwPlatformId;
  908. }
  909. #endif