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

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

压缩解压

开发平台：

Visual C++

wizwproc.c：源码内容
  1. /*
  2.  Copyright (C) 1996 Mike White
  3.  Permission is granted to any individual or institution to use, copy, or
  4.  redistribute this software so long as all of the original files are included,
  5.  that it is not sold for profit, and that this copyright notice is retained.
  7. */
  9. #include <windows.h>
  10. #include <stdio.h>
  11. #include "wiz.h"
  12. #include "helpids.h"
  13. #ifdef ZE_MEM
  14. #undef ZE_MEM
  15. #define ZE_MEM 4
  16. #endif
  17. #include "ziperr.h"
  20. RECT MainRc;  /* Used solely to remember WiZ window position/size */
  22. int ZipRetCode;
  23. BOOL fSaveZipToDir;
  24. BOOL fSaveUnZipFromDir;
  26. char szFilesToAdd[80];
  27. HWND hGetFilesDlg;
  29. /* Forward references */
  30. void WriteZipOptionsProfile(void);
  31. void ReadZipOptionsProfile(void);
  33. void GetWizOptions()
  34. {
  35. ReadZipOptionsProfile();
  36. }
  38. void ReadZipOptionsProfile()
  39. {
  40. int width, height, top;
  41. RECT rectT, re;
  42. HWND hWndDesktop;
  43. char szZipOptions[80];
  44. /* NOTE: ZpOpt.fLevel defaults to 6 unless specified otherwise */
  45. char szZipOptionsDefault[] = "6000000000000000000010100110111001001";
  46. int i=0;
  47. BOOL flag = FALSE;
  49. GetPrivateProfileString(szAppName, szZipOptionKey, szZipOptionsDefault,
  50.    szZipOptions, 80, szWiZIniFile);
  52. if (lstrlen(szZipOptions) != lstrlen(szZipOptionsDefault))
  53.    {
  54.    lstrcpy(szZipOptions, szZipOptionsDefault);
  55.    flag = TRUE;
  56.    }
  58. ZpOpt.fLevel         = szZipOptions[i++];
  59. ZpOpt.fSuffix        = szZipOptions[i++]-'0';
  60. ZpOpt.fEncrypt       = szZipOptions[i++]-'0';
  61. ZpOpt.fSystem        = szZipOptions[i++]-'0';
  62. ZpOpt.fVolume        = szZipOptions[i++]-'0';
  63. ZpOpt.fExtra         = szZipOptions[i++]-'0';
  64. ZpOpt.fNoDirEntries  = szZipOptions[i++]-'0';
  65. ZpOpt.fVerbose       = szZipOptions[i++]-'0';
  66. ZpOpt.fQuiet         = szZipOptions[i++]-'0';
  67. ZpOpt.fCRLF_LF       = szZipOptions[i++]-'0';
  68. ZpOpt.fLF_CRLF       = szZipOptions[i++]-'0';
  69. ZpOpt.fJunkDir       = szZipOptions[i++]-'0';
  70. ZpOpt.fRecurse       = szZipOptions[i++]-'0';
  71. ZpOpt.fGrow          = szZipOptions[i++]-'0';
  72. ZpOpt.fForce         = szZipOptions[i++]-'0';
  73. ZpOpt.fMove          = szZipOptions[i++]-'0';
  74. ZpOpt.fUpdate        = szZipOptions[i++]-'0';
  75. ZpOpt.fFreshen       = szZipOptions[i++]-'0';
  76. ZpOpt.fLatestTime    = szZipOptions[i++]-'0';
  77. ZpOpt.fComment       = szZipOptions[i++]-'0';
  78. fSaveZipToDir      = szZipOptions[i++]-'0';
  79. lpDCL->noflag      = szZipOptions[i++]-'0';
  80. lpDCL->PromptToOverwrite = szZipOptions[i++]-'0';
  81. lpDCL->ExtractOnlyNewer = szZipOptions[i++]-'0';
  82. lpDCL->SpaceToUnderscore = szZipOptions[i++]-'0';
  83. uf.fSaveUnZipToDir     = szZipOptions[i++]-'0';
  84. uf.fSaveUnZipFromDir   = szZipOptions[i++]-'0';
  85. uf.fTranslate          = szZipOptions[i++]-'0';
  86. uf.fRecreateDirs       = szZipOptions[i++]-'0';
  87. uf.fFormatLong         = szZipOptions[i++]-'0';
  88. uf.fShowBubbleHelp     = szZipOptions[i++]-'0';
  89. uf.fUnzipToZipDir      = szZipOptions[i++]-'0';
  90. fMakeSFX               = szZipOptions[i++]-'0';
  91. fLB_Selection          = szZipOptions[i++]-'0';
  92. lpDCL->fPrivilege      = szZipOptions[i++]-'0';
  93. ZpOpt.fPrivilege      = szZipOptions[i++]-'0';
  94. fMakeDosSFX            = szZipOptions[i]  -'0';
  96. /* If this is a 16 bit version, or if we are not running on NT, force
  97.    disabling of privilege/acl stuff
  98.  */
  99. #ifdef WIN32
  100. if (!dwPlatformId)
  101. #endif
  102.    {
  103.    lpDCL->fPrivilege = FALSE;
  104.    ZpOpt.fPrivilege = FALSE;
  105.    }
  106. /* Verify that all entries are valid */
  107. if ((ZpOpt.fLevel < '0') || (ZpOpt.fLevel > '9'))
  108.    {
  109.    ZpOpt.fLevel = '6'; /* Set compression level to default */
  110.    flag = TRUE;
  111.    }
  112. if ((ZpOpt.fPrivilege < 0) || (ZpOpt.fPrivilege > 3))
  113.    {
  114.    ZpOpt.fPrivilege = 0; /* Turn off privilege */
  115.    flag = TRUE;
  116.    }
  117. if ((lpDCL->fPrivilege < 0) || (lpDCL->fPrivilege > 3))
  118.    {
  119.    lpDCL->fPrivilege = 0; /* Turn off privilege */
  120.    flag = TRUE;
  121.    }
  122. if ((ZpOpt.fSuffix != 0) && (ZpOpt.fSuffix != 1))
  123.    {
  124.    ZpOpt.fSuffix = 0;
  125.    flag = TRUE;
  126.    }
  127. if ((ZpOpt.fEncrypt!= 0) && (ZpOpt.fEncrypt!= 1))
  128.    {
  129.    ZpOpt.fEncrypt= 0;
  130.    flag = TRUE;
  131.    }
  132. if ((ZpOpt.fSystem!= 0) && (ZpOpt.fSystem!= 1))
  133.    {
  134.    ZpOpt.fSystem= 0;
  135.    flag = TRUE;
  136.    }
  137. if ((ZpOpt.fVolume!= 0) && (ZpOpt.fVolume!= 1))
  138.    {
  139.    ZpOpt.fVolume= 0;
  140.    flag = TRUE;
  141.    }
  142. if ((ZpOpt.fExtra!= 0) && (ZpOpt.fExtra!= 1))
  143.    {
  144.    ZpOpt.fExtra= 0;
  145.    flag = TRUE;
  146.    }
  147. if ((ZpOpt.fNoDirEntries!= 0) && (ZpOpt.fNoDirEntries!= 1))
  148.    {
  149.    ZpOpt.fNoDirEntries= 0;
  150.    flag = TRUE;
  151.    }
  152. if ((ZpOpt.fVerbose!= 0) && (ZpOpt.fVerbose!= 1))
  153.    {
  154.    ZpOpt.fVerbose= 0;
  155.    flag = TRUE;
  156.    }
  157. if ((ZpOpt.fQuiet!= 0) && (ZpOpt.fQuiet!= 1))
  158.    {
  159.    ZpOpt.fQuiet= 0;
  160.    flag = TRUE;
  161.    }
  162. if ((ZpOpt.fCRLF_LF!= 0) && (ZpOpt.fCRLF_LF!= 1))
  163.    {
  164.    ZpOpt.fCRLF_LF= 0;
  165.    flag = TRUE;
  166.    }
  167. if ((ZpOpt.fLF_CRLF!= 0) && (ZpOpt.fLF_CRLF!= 1))
  168.    {
  169.    ZpOpt.fLF_CRLF= 0;
  170.    flag = TRUE;
  171.    }
  172. if ((ZpOpt.fJunkDir!= 0) && (ZpOpt.fJunkDir!= 1))
  173.    {
  174.    ZpOpt.fJunkDir= 0;
  175.    flag = TRUE;
  176.    }
  177. if ((ZpOpt.fRecurse!= 0) && (ZpOpt.fRecurse!= 1))
  178.    {
  179.    ZpOpt.fRecurse= 0;
  180.    flag = TRUE;
  181.    }
  182. if ((ZpOpt.fGrow!= 0) && (ZpOpt.fGrow!= 1))
  183.    {
  184.    ZpOpt.fGrow= 0;
  185.    flag = TRUE;
  186.    }
  187. if ((ZpOpt.fForce!= 0) && (ZpOpt.fForce!= 1))
  188.    {
  189.    ZpOpt.fForce= 0;
  190.    flag = TRUE;
  191.    }
  192. if ((ZpOpt.fMove!= 0) && (ZpOpt.fMove!= 1))
  193.    {
  194.    ZpOpt.fMove= 0;
  195.    flag = TRUE;
  196.    }
  197. if ((ZpOpt.fUpdate!= 0) && (ZpOpt.fUpdate!= 1))
  198.    {
  199.    ZpOpt.fUpdate= 0;
  200.    flag = TRUE;
  201.    }
  202. if ((ZpOpt.fFreshen!= 0) && (ZpOpt.fFreshen!= 1))
  203.    {
  204.    ZpOpt.fFreshen= 0;
  205.    flag = TRUE;
  206.    }
  207. ZpOpt.fJunkSFX = 0;
  208. if ((ZpOpt.fLatestTime != 0) && (ZpOpt.fLatestTime != 1))
  209.    {
  210.    ZpOpt.fLatestTime = 0;
  211.    flag = TRUE;
  212.    }
  213. if ((ZpOpt.fComment != 0) && (ZpOpt.fComment != 1))
  214.    {
  215.    ZpOpt.fComment = 0;
  216.    flag = TRUE;
  217.    }
  218. if ((fSaveZipToDir != 0) && (fSaveZipToDir != 1))
  219.    {
  220.    fSaveZipToDir = 0;
  221.    flag = TRUE;
  222.    }
  223. if ((lpDCL->noflag != 0) && (lpDCL->noflag != 1))
  224.    {
  225.    lpDCL->noflag = 0;
  226.    flag = TRUE;
  227.    }
  228. if ((lpDCL->PromptToOverwrite != 0) && (lpDCL->PromptToOverwrite != 1))
  229.    {
  230.    lpDCL->PromptToOverwrite = 0;
  231.    flag = TRUE;
  232.    }
  233. if ((lpDCL->ExtractOnlyNewer != 0) && (lpDCL->ExtractOnlyNewer != 1))
  234.    {
  235.    lpDCL->ExtractOnlyNewer = 0;
  236.    flag = TRUE;
  237.    }
  238. if ((lpDCL->SpaceToUnderscore != 0) && (lpDCL->SpaceToUnderscore != 1))
  239.    {
  240.    lpDCL->SpaceToUnderscore = 0;
  241.    flag = TRUE;
  242.    }
  243. if ((uf.fSaveUnZipToDir != 0) && (uf.fSaveUnZipToDir != 1))
  244.    {
  245.    uf.fSaveUnZipToDir = 0;
  246.    flag = TRUE;
  247.    }
  248. if ((uf.fSaveUnZipFromDir != 0) && (uf.fSaveUnZipFromDir != 1))
  249.    {
  250.    uf.fSaveUnZipFromDir = 0;
  251.    flag = TRUE;
  252.    }
  253. if ((uf.fTranslate != 0) && (uf.fTranslate != 1))
  254.    {
  255.    uf.fTranslate = 0;
  256.    flag = TRUE;
  257.    }
  258. if ((uf.fRecreateDirs != 0) && (uf.fRecreateDirs != 1))
  259.    {
  260.    uf.fRecreateDirs = 0;
  261.    flag = TRUE;
  262.    }
  263. if ((uf.fFormatLong != 0) && (uf.fFormatLong != 1))
  264.    {
  265.    uf.fFormatLong = 0;
  266.    flag = TRUE;
  267.    }
  268. if ((uf.fShowBubbleHelp != 0) && (uf.fShowBubbleHelp != 1))
  269.    {
  270.    uf.fShowBubbleHelp = 0;
  271.    flag = TRUE;
  272.    }
  273. if ((uf.fUnzipToZipDir != 0) && (uf.fUnzipToZipDir != 1))
  274.    {
  275.    uf.fUnzipToZipDir = 0;
  276.    flag = TRUE;
  277.    }
  278. if ((fMakeSFX != 0) && (fMakeSFX != 1))
  279.    {
  280.    fMakeSFX = 0;
  281.    flag = TRUE;
  282.    }
  283. /* If 16 bit version, then this will always be true */
  284. #ifdef WIN32
  285. if ((fMakeDosSFX != 0) && (fMakeDosSFX != 1))
  286.    {
  287.    fMakeDosSFX = 1;
  288.    flag = TRUE;
  289.    }
  290. #endif
  291. if ((fLB_Selection < 0) || (fLB_Selection > 2))
  292.    {
  293.    fLB_Selection = 1;
  294.    wLBSelection = IDM_LB_DISPLAY; /* default listbox selection action */
  295.    flag = TRUE;
  296.    }
  297. else
  298.    {
  299.    switch (fLB_Selection)
  300.       {
  301.       case 0:
  302.               wLBSelection = IDM_LB_EXTRACT;
  303.               break;
  304.       case 1:
  305.               wLBSelection = IDM_LB_DISPLAY;
  306.               break;
  307.       case 2:
  308.               wLBSelection = IDM_LB_TEST;
  309.               break;
  310.       }
  311.    }
  313.    /* We never want these options to be saved, or restored */
  314. ZpOpt.fExcludeDate = FALSE;     /* Date option */
  315. ZpOpt.fIncludeDate = FALSE;
  316. ZpOpt.fOffsets = FALSE; /* Adjust offsets option */
  317. ZpOpt.fRepair = FALSE;  /* Fix archive options */
  319. /* Under WIN32 only long format is supported */
  320. #ifdef WIN32
  321. uf.fFormatLong = TRUE;
  322. #endif
  324. /* All entries have now been validated. */
  325. CheckMenuItem(hMenu, IDM_SHOW_BUBBLE_HELP, MF_BYCOMMAND|
  326.    (WORD)(uf.fShowBubbleHelp ? MF_CHECKED : MF_UNCHECKED));
  327. CheckMenuItem(hMenu, IDM_SHORT, MF_BYCOMMAND|
  328.    (WORD)(uf.fFormatLong ? MF_UNCHECKED : MF_CHECKED));
  329. CheckMenuItem(hMenu, IDM_LONG, MF_BYCOMMAND|
  330.    (WORD)(uf.fFormatLong ? MF_CHECKED : MF_UNCHECKED));
  331. CheckMenuItem(hMenu, IDM_RECR_DIR_STRUCT, MF_BYCOMMAND |
  332.              (uf.fRecreateDirs ? MF_CHECKED : MF_UNCHECKED));
  334. CheckMenuItem(hMenu, IDM_SAVE_UNZIP_TO_DIR, MF_BYCOMMAND |
  335.              (uf.fSaveUnZipToDir ? MF_CHECKED : MF_UNCHECKED));
  336. CheckMenuItem(hMenu, IDM_SAVE_UNZIP_FROM_DIR, MF_BYCOMMAND |
  337.              (uf.fSaveUnZipFromDir ? MF_CHECKED : MF_UNCHECKED));
  338. CheckMenuItem(hMenu, wLBSelection, MF_BYCOMMAND | MF_CHECKED);
  339. CheckMenuItem(hMenu, IDM_UNZIP_TO_ZIP_DIR, MF_BYCOMMAND |
  340.              (uf.fUnzipToZipDir ? MF_CHECKED : MF_UNCHECKED));
  341. EnableMenuItem(hMenu, IDM_CHDIR, MF_BYCOMMAND |
  342.              (uf.fUnzipToZipDir ? MF_GRAYED : MF_ENABLED));
  343. CheckMenuItem(hMenu, IDM_SAVE_ZIP_TO_DIR, MF_BYCOMMAND |
  344.    (fSaveZipToDir ? MF_CHECKED : MF_UNCHECKED));
  346. /* Get default "Zip To" directory */
  347. GetPrivateProfileString(szAppName, szZipToDirKey, "", szTargetZipDir,
  348.    PATH_MAX, szWiZIniFile);
  349. /* Get default "unzip-to" directory */
  350. GetPrivateProfileString(szAppName, szDefaultUnzipToDir, "",
  351.    szUnzipToDirName, PATH_MAX, szWiZIniFile);
  352. /* Get default "unzip-from" directory */
  353. GetPrivateProfileString(szAppName, szDefaultUnzipFromDir, "",
  354.    lpumb->szUnzipFromDirName, PATH_MAX, szWiZIniFile);
  356. /* Set up default values for position and size */
  357. hWndDesktop = GetDesktopWindow();
  358. GetClientRect(hWndDesktop, &rectT);
  359. rectT.top =  2 * dyChar;
  360. /*
  361.  * Adjust for 640 x 480 displays
  362.  */
  363. width = GetSystemMetrics(SM_CXSCREEN);
  364. height = GetSystemMetrics(SM_CYSCREEN);
  365. if ((width == 640) || (height == 480))
  366.    {
  367.    /* If we are on a 640 x 480 display, take up two thirds of the
  368.       real estate top to bottom, and three fourths of the screen
  369.       display left to right.
  370.     */
  371.    rectT.bottom = ((rectT.bottom/3) * 2) +
  372.       (2 * GetSystemMetrics(SM_CYDLGFRAME));
  373.    rectT.right =  ((rectT.right/4) * 3) +
  374.       (4 * GetSystemMetrics(SM_CXFRAME) +
  375.       (2 * GetSystemMetrics(SM_CXVSCROLL)));
  376.    }
  377. else
  378.    {
  379.    /* If we are not on a 640 x 480 display, take up one half of the
  380.       real estate top to bottom, and one half of the screen display
  381.       from left to right.
  382.     */
  383.    rectT.bottom = (rectT.bottom/2) +
  384.       (2 * GetSystemMetrics(SM_CYDLGFRAME));
  385.    rectT.right =  (rectT.right/2) +
  386.       (4 * GetSystemMetrics(SM_CXFRAME) +
  387.       (2 * GetSystemMetrics(SM_CXVSCROLL)));
  388.    }
  389. rectT.left = 0;
  391. MainRc.left =   GetPrivateProfileInt(szAppName, "left",
  392.                                      rectT.left,   szWiZIniFile);
  393. MainRc.right =  GetPrivateProfileInt(szAppName, "right",
  394.                                      rectT.right,  szWiZIniFile);
  395. MainRc.top =    GetPrivateProfileInt(szAppName, "top",
  396.                                      rectT.top,    szWiZIniFile);
  397. MainRc.bottom = GetPrivateProfileInt(szAppName, "bottom",
  398.                                      rectT.bottom, szWiZIniFile);
  399. MoveWindow(hWndMain,
  400.            MainRc.left,
  401.            MainRc.top,
  402.            MainRc.right,
  403.            MainRc.bottom,
  404.            TRUE);
  406. /* Pre-position the status/edit window to the default */
  408. /* Make the Edit/Status Window 1/3 the size of the client area of
  409.  * hWndMain.
  410.  */
  412. GetWindowRect(hWndMain, &rectT);
  413. top = rectT.bottom;
  414. rectT.bottom = (rectT.bottom - rectT.top)/3;
  415. rectT.top = top;
  416. rectT.right = rectT.right - rectT.left;
  418. WinAssert(hWndStatic);
  419. /* Now get the saved values, if any */
  420. re.left =   GetPrivateProfileInt(szAppName, "Edit left",
  421.                                      rectT.left,   szWiZIniFile);
  422. re.right =  GetPrivateProfileInt(szAppName, "Edit right",
  423.                                      rectT.right,  szWiZIniFile);
  424. re.top =    GetPrivateProfileInt(szAppName, "Edit top",
  425.                                      rectT.top,    szWiZIniFile);
  426. re.bottom = GetPrivateProfileInt(szAppName, "Edit bottom",
  427.                                      rectT.bottom, szWiZIniFile);
  428. MoveWindow(hWndStatic,
  429.            re.left,
  430.            re.top,
  431.            re.right,
  432.            re.bottom,
  433.            TRUE);
  434. GetClientRect(hWndStatic, &re);
  435. MoveWindow(hWndEdit,
  436.            re.left, re.top,
  437.            re.right, re.bottom,
  438.            FALSE);
  439. if (flag) /* Something was wrong with the options string, re-write it */
  440.    WriteZipOptionsProfile();
  441. }
  443. /* WriteZipOptionsProfile simply writes the WiZ options out to one string,
  444.    rather than having an entire series of profile strings in the .ini file
  445. */
  446. void WriteZipOptionsProfile()
  447. {
  448. POINT pt;
  449. char szZipOptions[80];
  450. sprintf(szZipOptions,
  451.    "%c%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u",
  452.    ZpOpt.fLevel,
  453.    ZpOpt.fSuffix,
  454.    ZpOpt.fEncrypt,
  455.    ZpOpt.fSystem,
  456.    ZpOpt.fVolume,
  457.    ZpOpt.fExtra,
  458.    ZpOpt.fNoDirEntries,
  459.    ZpOpt.fVerbose,
  460.    ZpOpt.fQuiet,
  461.    ZpOpt.fCRLF_LF,
  462.    ZpOpt.fLF_CRLF,
  463.    ZpOpt.fJunkDir,
  464.    ZpOpt.fRecurse,
  465.    ZpOpt.fGrow,
  466.    ZpOpt.fForce,
  467.    ZpOpt.fMove,
  468.    ZpOpt.fUpdate,
  469.    ZpOpt.fFreshen,
  470.    ZpOpt.fLatestTime,
  471.    ZpOpt.fComment,
  472.    fSaveZipToDir,
  473.    lpDCL->noflag,
  474.    lpDCL->PromptToOverwrite,
  475.    lpDCL->ExtractOnlyNewer,
  476.    lpDCL->SpaceToUnderscore,
  477.    uf.fSaveUnZipToDir,
  478.    uf.fSaveUnZipFromDir,
  479.    uf.fTranslate,
  480.    uf.fRecreateDirs,
  481.    uf.fFormatLong,
  482.    uf.fShowBubbleHelp,
  483.    uf.fUnzipToZipDir,
  484.    fMakeSFX,
  485.    fLB_Selection,
  486.    lpDCL->fPrivilege,
  487.    ZpOpt.fPrivilege,
  488.    fMakeDosSFX);
  491. WritePrivateProfileString(szAppName, szZipOptionKey,
  492.    szZipOptions, szWiZIniFile);
  494. if (fSaveZipToDir)
  495.    WritePrivateProfileString(szAppName, szZipToDirKey, szTargetZipDir,
  496.       szWiZIniFile);
  497. else
  498.    WritePrivateProfileString(szAppName, szZipToDirKey, "",
  499.       szWiZIniFile);
  501. GetWindowRect(hWndMain, &MainRc);
  502. pt.x = MainRc.left;
  503. pt.y = MainRc.top;
  504. ScreenToClient(GetDesktopWindow(), &pt);
  505. MainRc.left = pt.x;
  506. MainRc.top = pt.y;
  508. pt.x = MainRc.right;
  509. pt.y = MainRc.bottom;
  510. ScreenToClient(GetDesktopWindow(), &pt);
  511. MainRc.right = pt.x - MainRc.left;
  512. MainRc.bottom = pt.y - MainRc.top;
  514. /* Save off the current window position/size */
  515. WritePrivateProfileString(szAppName, "left",
  516.    itoa(MainRc.left,   szZipOptions, 10),
  517.    szWiZIniFile);
  518. WritePrivateProfileString(szAppName, "right",
  519.    itoa(MainRc.right,  szZipOptions, 10),
  520.    szWiZIniFile);
  521. WritePrivateProfileString(szAppName, "top",
  522.    itoa(MainRc.top,    szZipOptions, 10),
  523.    szWiZIniFile);
  524. WritePrivateProfileString(szAppName, "bottom",
  525.    itoa(MainRc.bottom, szZipOptions, 10),
  526.    szWiZIniFile);
  528. /* Now let's save off the edit window position */
  529. GetWindowRect(hWndStatic, &MainRc);
  530. pt.x = MainRc.left;
  531. pt.y = MainRc.top;
  532. ScreenToClient(GetDesktopWindow(), &pt);
  533. MainRc.left = pt.x;
  534. MainRc.top = pt.y;
  536. pt.x = MainRc.right;
  537. pt.y = MainRc.bottom;
  538. ScreenToClient(GetDesktopWindow(), &pt);
  539. MainRc.right = pt.x - MainRc.left;
  540. MainRc.bottom = pt.y - MainRc.top;
  542. /* Save off the current window position/size */
  543. WritePrivateProfileString(szAppName, "Edit left",
  544.    itoa(MainRc.left,   szZipOptions, 10),
  545.    szWiZIniFile);
  546. WritePrivateProfileString(szAppName, "Edit right",
  547.    itoa(MainRc.right,  szZipOptions, 10),
  548.    szWiZIniFile);
  549. WritePrivateProfileString(szAppName, "Edit top",
  550.    itoa(MainRc.top,    szZipOptions, 10),
  551.    szWiZIniFile);
  552. WritePrivateProfileString(szAppName, "Edit bottom",
  553.    itoa(MainRc.bottom, szZipOptions, 10),
  554.    szWiZIniFile);
  555. }
  557. #ifdef __BORLANDC__
  558. #pragma warn -par
  559. #endif
  560. void ZipWndProc(HWND hWnd, WORD wMessage, WPARAM wParam, LPARAM lParam)
  561. {
  562. RECT  rClient;
  563. #ifndef WIN32
  564. FARPROC lpfnPrefs;
  565. #endif
  566. switch (LOWORD(wParam))
  567.    {
  568.    case IDM_ZIP_TARGET:
  569.          ZipRetCode = FALSE;
  570.          MakeArchive(hWnd);
  571.          lstrcpy(lpumb->szZipFileName, ZpZCL.lpszZipFN);
  572.          if (ZipRetCode == ZE_OK)
  573.             {
  574.             lstrcpy(lpumb->szFileName, lpumb->szZipFileName);
  575.             UpdateListBox();
  576.             WinAssert(hWndList);
  577.             GetClientRect( hWndList, &rClient );
  578.             OffsetRect( &rClient, 0, dyChar );
  579.             rClient.top = rClient.bottom;
  580.             rClient.bottom = rClient.top + (6*dyChar);
  581. #ifndef WIN32
  582.             SendMessage(hWndList, LB_SETSEL, 1, 0L);
  583. #else
  584.             ListViewSetSel(0, TRUE);
  585. #endif
  586.             UpdateButtons(); /* update state of buttons */
  587.             SetCaption(hWnd);
  588.             InvalidateRect( hWnd, &rClient, TRUE);
  589.             }
  590.          break;
  591.    case IDM_ZIP_PREFERENCES:
  592.          {
  593. #ifndef WIN32
  594.          lpfnPrefs = MakeProcInstance((FARPROC)ZipPreferencesProc, hInst);
  595.          DialogBox(hInst, "ZIP_PREFS", hWnd, lpfnPrefs);
  596.          FreeProcInstance(lpfnPrefs);
  597. #else
  598.          DialogBox(hInst, "ZIP_PREFS", hWnd, (DLGPROC)ZipPreferencesProc);
  599. #endif
  600.          }
  601.          break;
  602.    case IDM_UNZIP_PREFERENCES:
  603.          {
  604. #ifndef WIN32
  605.          lpfnPrefs = MakeProcInstance((FARPROC)UnZipPreferencesProc, hInst);
  606.          DialogBox(hInst, "UNZIP_PREFS", hWnd, lpfnPrefs);
  607.          FreeProcInstance(lpfnPrefs);
  608. #else
  609.          DialogBox(hInst, "UNZIP_PREFS", hWnd, (DLGPROC)UnZipPreferencesProc);
  610. #endif
  611.          }
  612.          break;
  613.    }
  614. return;
  615. }
  616. #ifdef __BORLANDC__
  617. #pragma warn .par
  618. #endif