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

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

压缩解压

开发平台：

Visual C++

action.c：源码内容
  1. /* Action.c module of WizUnZip.
  2.  * Author: Robert A. Heath, 1993
  3.  * I, Robert Heath, place this source code module in the public domain.
  4.  *
  5.  * Modifications: Mike White 1995, 1996
  6.  * Now modified for WiZ - WizUnZip no longer exists
  7.  */
  9. #include <stdio.h>
  10. #include <string.h>
  11. #include <stdlib.h>
  12. #ifndef  WIN32
  13. #  include <dos.h>
  14. #  include <ctype.h>
  15. #endif
  16. #include "wiz.h"
  17. #include "unzipwindlldecs.h"
  18. #include "helpids.h"
  19. #ifdef ZE_MEM
  20. #undef ZE_MEM
  21. #define ZE_MEM 4
  22. #endif
  23. #include "ziperr.h"
  25. int argc;
  26. char **argv;
  28. extern BOOL fUpdateEntries;
  29. extern BOOL fSpool;
  30. extern char szRefDir[PATH_MAX];
  31. extern LPSTR szFileList;
  32. extern HANDLE hFileList;
  33. unsigned long dSpaceToUse;
  35. char __based(__segname("STRINGS_TEXT")) szNoMemory[] =
  36.             "Insufficient memory for this operation!";
  38. char __based(__segname("STRINGS_TEXT")) szCantChDir[] =
  39.          "Can't change directory to %s!";
  41. BOOL IsValidArchive(LPSTR archive)
  42. {
  43. int retcode, AllCodes = FALSE;
  45. hSaveCursor = SetCursor(hHourGlass);
  46. ShowCursor(TRUE);
  47. retcode = (*Unz_Validate)((char *)archive, AllCodes);
  48. ShowCursor(FALSE);
  49. SetCursor(hSaveCursor);
  50. return retcode;
  51. }
  53. /* Get Selection Count returns a count of the selected
  54.  * list box items. If the count is  greater than zero, it also returns
  55.  * a pointer to a locked list in local memory of the item nos.
  56.  * and their local memory handle.
  57.  *
  58.  * A value of -1 indicates an error.
  59.  *
  60.  * Note the WIN32 version does not use the parameter hListBox
  61.  */
  63. #ifdef __BORLANDC__
  64. #pragma argsused
  65. #endif
  66. int CLBItemsGet(HWND hListBox, int __far * __far *ppnSelItems, HANDLE *phnd)
  67. {
  68. #ifndef WIN32
  69. int cSelLBItems = (int)SendMessage(hListBox, LB_GETSELCOUNT, 0, 0L);
  70. #else
  71. int i, j, k = 0;
  72. LV_ITEM lvi;
  73. int cSelLBItems = ListView_GetSelectedCount(hWndList);
  74. #endif
  76. if ( !phnd )
  77.    return -1;
  79. *phnd = 0;
  80. if (cSelLBItems)
  81.    {
  82.    *phnd = GlobalAlloc(GMEM_FIXED, cSelLBItems * sizeof(int));
  83.    if ( !*phnd )
  84.       return -1;
  86.    *ppnSelItems = (int __far *)GlobalLock( *phnd );
  87.    if ( !*ppnSelItems )
  88.       {
  89.       GlobalFree( *phnd );
  90.       *phnd = 0;
  91.       return -1;
  92.       }
  94.    /* Get list of selected items. Return value is number of selected items */
  95. #ifndef WIN32
  96.    if (SendMessage(hWndList, LB_GETSELITEMS, cSelLBItems, (LONG)*ppnSelItems) != cSelLBItems)
  97.       {
  98.       GlobalUnlock(*phnd);
  99.       GlobalFree(*phnd);
  100.       *phnd = 0;
  101.       return -1;
  102.       }
  103. #else
  104.    j = ListView_GetItemCount(hWndList);
  105.    for (i = 0; i < j; i++)
  106.       {
  107.       lvi.mask      = LVIF_STATE;
  108.       lvi.stateMask = LVIS_SELECTED;
  109.       lvi.iItem     = i;
  110.       lvi.iSubItem  = 0;
  112.       ListView_GetItem(hWndList, &lvi);
  114.       if (lvi.state)
  115.          {
  116.          (*ppnSelItems)[k++] = i;
  117.          }
  118.       }
  119. #endif
  120.    }
  121.    return cSelLBItems;
  122. }
  124. #ifndef WIN32
  125. /* Re-select listbox contents from given list. The pnSelItems is a
  126.  * list containing the indices of those items selected in the listbox.
  127.  * This list was probably created by GetLBSelCount() above.
  128.  *
  129.  * This routine is only called from wndproc.c when switching between
  130.  * the long and short format. As the short format is not supported
  131.  * by the Win32 version, this routine is not necessary.
  132.  *
  133.  */
  134. void ReselectLB(HWND hListBox, int cSelLBItems, int __far *pnSelItems)
  135. {
  136. int i;
  138. for (i = 0; i < cSelLBItems; ++i)
  139.    {
  140.    SendMessage(hListBox, LB_SETSEL, TRUE, MAKELPARAM(pnSelItems[i],0));
  141.    }
  142. }
  143. #endif
  145. /* Action is called on double-clicking, or selecting one of the
  146.  * main action buttons. The action code is the action
  147.  * relative to the listbox or the button ID.
  148.  */
  149. void Action(HWND hWnd, WPARAM wActionCode)
  150. {
  151. HANDLE  hMem;
  152. int i;
  153. int iSelection;
  154. int cch;
  155. unsigned long dFreeSpace, dStrlen = 0;
  156. int cSelLBItems;
  157. int __far *pnSelItems;  /* pointer to list of selected items */
  158. #ifndef WIN32
  159. struct diskfree_t df;
  160. #else
  161. DWORD SectorsPerCluster, BytesPerSector, FreeClusters, Clusters;
  162. #endif
  163. HANDLE  hnd = 0;
  164. char **pszIndex;
  165. char *sz;
  166. LPSTR lpszT;
  167. #ifndef WIN32
  168. WORD wIndex = (WORD)(!uf.fFormatLong ? SHORT_FORM_FNAME_INX
  169.    : LONG_FORM_FNAME_INX);
  170. #endif
  172. cSelLBItems = CLBItemsGet(hWndList, &pnSelItems, &hnd);
  173. /* if no items were selected */
  174. if (cSelLBItems < 1)
  175.    return;
  177.     /* Note: this global value can be overriden in replace.c */
  178. uf.fDoAll = (lpDCL->noflag) ? 1 : 0;
  180. SetCapture(hWnd);
  181. hSaveCursor = SetCursor(hHourGlass);
  182. ShowCursor(TRUE);
  184.     /* If all the files are selected pass in no filenames */
  185.     /* since unzipping all files is the default */
  186. hMem = GlobalAlloc( GPTR, (PATH_MAX * 2));
  187. if ( !hMem )
  188.    goto done;
  189. lpszT = (LPSTR)GlobalLock( hMem );
  190. if ( !lpszT )
  191.    {
  192.    GlobalFree( hMem );
  193.    goto done;
  194.    }
  196. hFileList = GlobalAlloc( GPTR, FILENAME_BUF_SIZE);
  197. szFileList = (LPSTR)GlobalLock(hFileList);
  198. if (!szFileList)
  199.    {
  200.    GlobalFree(hFileList);
  201.    goto done;
  202.    }
  204. argc = ((WORD)cSelLBItems == cZippedFiles) ? 0 : 1;
  205. iSelection = 0;
  206. do
  207.    {
  208.    if ((argc) || (fUpdateEntries))
  209.       {
  210.       dSpaceToUse = 0;
  211.       pszIndex = (char **)szFileList;
  212.       cch = (sizeof(char *) * ((cSelLBItems > cchFilesMax-1 ) ? cchFilesMax :
  213.          cSelLBItems+1));
  214.       sz = szFileList + cch;
  216.       for (i=0; ((i+iSelection) < cSelLBItems) && (i < cchFilesMax-1); ++i)
  217.          {
  218. #ifndef WIN32
  219.          cch = (int)SendMessage(hWndList, LB_GETTEXTLEN, pnSelItems[i+iSelection], 0L);
  220.          if (cch != LB_ERR)
  221.             {
  222.             cch = (int)SendMessage(hWndList, LB_GETTEXT, pnSelItems[i+iSelection], (LONG)lpszT);
  223.             if ((cch != LB_ERR) && (cch > (int)wIndex))
  224.                {
  225.                /* Get uncompressed totals to pre-flight the extraction process
  226.                 * The pre-flight portion of this needs to be modified to occur
  227.                 * only during actual extraction to disk.
  228.                 */
  229.                strncpy(sz, lpszT, 9);
  230.                sz[9] = '';
  231.                dSpaceToUse += atol(sz);
  232.                lstrcpy(sz, lpszT+wIndex);
  233.                dStrlen += lstrlen(sz) + 1;
  234.                if (dStrlen > FILENAME_BUF_SIZE )
  235.                   {
  236.                   MessageBox(hWndMain, "Try selecting fewer files at a time",
  237.                   "Insufficient Memory", MB_OK |MB_SYSTEMMODAL|
  238.                   MB_ICONEXCLAMATION);
  239.                   goto done;
  240.                   }
  241.                pszIndex[i] = sz;
  242.                sz += (cch + 1 - wIndex);
  243.                }
  244.             else
  245.                {
  246.                break;
  247.                }
  248.             }
  249.          else
  250.             {
  251.             MessageBeep(1);
  252.             goto done;
  253.             }
  254. #else
  255.          /* Get uncompressed totals to pre-flight the extraction process
  256.           * The pre-flight portion of this needs to be modified to occur
  257.           * only during actual extraction to disk.
  258.           */
  259.          ListView_GetItemText(hWndList, pnSelItems[i+iSelection], 1, lpszT,
  260.                (PATH_MAX * 2));
  261.          lstrcpy(sz, lpszT);
  262.          dSpaceToUse += atol(sz);
  264.          /* Now we get the actual name */        
  265.          ListView_GetItemText(hWndList, pnSelItems[i+iSelection], 0, lpszT,
  266.                (PATH_MAX * 2));
  267.          lstrcpy(sz, lpszT+1);
  268.          dStrlen += lstrlen(sz) + 1;
  269.          if (dStrlen > FILENAME_BUF_SIZE )
  270.             {
  271.             MessageBox(hWndMain, "Try selecting fewer files at a time",
  272.             "Insufficient Memory", MB_OK |MB_SYSTEMMODAL|
  273.             MB_ICONEXCLAMATION);
  274.             goto done;
  275.             }
  276.          pszIndex[i] = sz;
  277.          sz += (strlen(lpszT) + 1);
  278. #endif
  279.          } /* end of for loop */
  280.       if (i == 0)
  281.          {
  282.          goto done;
  283.          }
  284.       argc = i;
  286.       pszIndex[i] = 0;
  287.       iSelection += i;
  288.       }
  289.    else
  290.       {
  291.       iSelection = cSelLBItems;
  292.       }
  294. switch (wActionCode)
  295.    {
  296. #ifdef WIN32
  297.    char tempChar;
  298. #endif
  299.    int Ok;
  300.    case 0:         /* extract button */
  301.          /* Get amount of free space on target drive */
  302. #ifndef WIN32
  303.           _dos_getdiskfree((toupper(szUnzipToDirName[0]) - 'A'+1), &df);
  304.           dFreeSpace = (long)df.avail_clusters *
  305.                        ((long)df.sectors_per_cluster *
  306.                        (long)df.bytes_per_sector);
  307. #else
  308.          tempChar = szUnzipToDirName[3];
  309.          szUnzipToDirName[3] = '';
  310.          GetDiskFreeSpace(szUnzipToDirName, &SectorsPerCluster, &BytesPerSector, &FreeClusters, &Clusters);
  311.          szUnzipToDirName[3] = tempChar;
  312.          dFreeSpace = (long)SectorsPerCluster * (long)BytesPerSector * (long)FreeClusters;
  313. #endif
  314.          if (dFreeSpace < dSpaceToUse)
  315.             {
  316.             sprintf(sz, "Free Disk Space = %lu bytesnUncompressed Files Total %lu bytesnContinue?n",
  317.                dFreeSpace, dSpaceToUse);
  318.             Ok = MessageBox(hWndMain, sz, "Insufficient Disk Space?", MB_OKCANCEL |
  319.                MB_ICONEXCLAMATION);
  320.             }
  321.          else
  322.             Ok = IDOK;
  323.          if (Ok != IDOK)
  324.             break;
  325.          lpDCL->ncflag = 0;
  326.          lpDCL->fQuiet = 0;
  327.          lpDCL->ntflag = 0;
  328.          lpDCL->nvflag = 0;
  329.          lpDCL->nUflag = lpDCL->ExtractOnlyNewer;
  330.          lpDCL->nzflag = 0;
  331.          lpDCL->ndflag = (int)(uf.fRecreateDirs ? 1 : 0);
  332.          lpDCL->noflag = uf.fDoAll;
  333.          lpDCL->naflag = (int)(uf.fTranslate ? 1 : 0);
  334.          lpDCL->lpszZipFN = lpumb->szFileName;
  335.          argv = (char **)szFileList;
  336.          if (!uf.fUnzipToZipDir && szUnzipToDirName[0])
  337.             {
  338.             lstrcpy(lpumb->szBuffer, szUnzipToDirName); /* OK to clobber szBuffer! */
  339.             }
  340.          hSaveCursor = SetCursor(hHourGlass);
  341.          ShowCursor(TRUE);
  342.          if (szUnzipToDirName[0])
  343.             lpDCL->lpszExtractDir = szUnzipToDirName;
  344.          else
  345.             lpDCL->lpszExtractDir = NULL;
  346.          Unz_SingleEntryPoint(argc, argv, 0, NULL, lpDCL, lpUserFunctions);
  347.          ShowCursor(FALSE);
  348.          SetCursor(hSaveCursor);
  349.          ShowCursor(TRUE);
  350.          if (!uf.fUnzipToZipDir && szUnzipToDirName[0])
  351.             {
  352.             lstrcpy(lpumb->szBuffer, lpumb->szDirName); /* OK to clobber szBuffer! */
  353.             }
  354.          break;
  355.         case 1:     /* display to message window */
  356.             {
  357.             int rc; /* return code */
  358.             bRealTimeMsgUpdate = FALSE;
  359.             lpDCL->fQuiet = 2; // Kill all messages
  360.             lpDCL->ncflag = 1;
  361.             lpDCL->ntflag = 0;
  362.             lpDCL->nvflag = 0;
  363.             lpDCL->nUflag = 1;
  364.             lpDCL->nzflag = 0;
  365.             lpDCL->ndflag = 0;
  366.             lpDCL->noflag = 0;
  367.             lpDCL->naflag = TRUE;
  368.             lpDCL->nZIflag = 0;
  369.             lpDCL->lpszZipFN = lpumb->szFileName;
  370.             argv = (char **)szFileList;
  371.             hSaveCursor = SetCursor(hHourGlass);
  372.             ShowCursor(TRUE);
  373.             lpDCL->lpszExtractDir = NULL;
  374.             rc = Unz_SingleEntryPoint(argc, argv, 0, NULL, lpDCL, lpUserFunctions);
  375.             if (rc == IZ_UNSUP)
  376.                BufferOut("%s is an encrypted file. Encryption not supported in this version",
  377.                          argv[0]);
  378.             SetWindowText(hWndStatic, argv[0]);
  379.             ShowCursor(FALSE);
  380.             SetCursor(hSaveCursor);
  381.             bRealTimeMsgUpdate = TRUE;
  383.             /* Following extraction to status window, user will want
  384.              * to scroll around, so put him/her in Edit/Status window.
  385.              */
  386.             if (rc != IZ_UNSUP)
  387.                PostMessage(hWnd, WM_COMMAND, IDM_SETFOCUS_ON_STATUS, 0L);
  388.             fSpool = FALSE;
  389.             }
  390.             break;
  391.         case 2:     /* test */
  392.             lpDCL->ncflag = 0;
  393.             lpDCL->fQuiet = 0;
  394.             lpDCL->ntflag = 1;
  395.             lpDCL->nvflag = 0;
  396.             lpDCL->nUflag = 1;
  397.             lpDCL->nzflag = 0;
  398.             lpDCL->ndflag = 0;
  399.             lpDCL->noflag = 0;
  400.             lpDCL->naflag = 0;
  401.             lpDCL->nZIflag = 0;
  402.             lpDCL->lpszZipFN = lpumb->szFileName;
  403.             argv = (char **)szFileList;
  404.             hSaveCursor = SetCursor(hHourGlass);
  405.             ShowCursor(TRUE);
  406.             lpDCL->lpszExtractDir = NULL;
  407.             Unz_SingleEntryPoint(argc, argv, 0, NULL, lpDCL, lpUserFunctions);
  408.             ShowCursor(FALSE);
  409.             SetCursor(hSaveCursor);
  410.             break;
  411.         case 3:     /* Get Zip Information */
  412.             {
  413.             lpDCL->fQuiet = 2;
  414.             lpDCL->ncflag = 0;
  415.             lpDCL->ntflag = 0;
  416.             lpDCL->nvflag = 0;
  417.             lpDCL->nUflag = 0;
  418.             lpDCL->nzflag = 0;
  419.             lpDCL->ndflag = 0;
  420.             lpDCL->noflag = 0;
  421.             lpDCL->naflag = 0;
  422.             lpDCL->nZIflag = 1;
  423.             lpDCL->lpszZipFN = lpumb->szFileName;
  424.             argv = (char **)szFileList;
  425.             hSaveCursor = SetCursor(hHourGlass);
  426.             ShowCursor(TRUE);
  427.             lpDCL->lpszExtractDir = NULL;
  428.             Unz_SingleEntryPoint(argc, argv, 0, NULL, lpDCL, lpUserFunctions);
  429.             ShowCursor(FALSE);
  430.             SetCursor(hSaveCursor);
  431.             lpDCL->nZIflag = 0;
  432.             break;
  433.             }
  434.         case 4:     /* Delete Archive Entries */
  435.             {
  436.             int retcode;
  437.             /* Save off zip flags */
  438.             BOOL fSuffix = ZpOpt.fSuffix;
  439.             BOOL fEncrypt = ZpOpt.fEncrypt;
  440.             BOOL fSystem = ZpOpt.fSystem;
  441.             BOOL fVolume = ZpOpt.fVolume;
  442.             BOOL fExtra = ZpOpt.fExtra;
  443.             BOOL fNoDirEntries = ZpOpt.fNoDirEntries;
  444.             BOOL fExcludeDate = ZpOpt.fExcludeDate;
  445.             BOOL fVerbose = ZpOpt.fVerbose;
  446.             BOOL fQuiet = ZpOpt.fQuiet;
  447.             BOOL fCRLF_LF = ZpOpt.fCRLF_LF;
  448.             BOOL fLF_CRLF = ZpOpt.fLF_CRLF;
  449.             BOOL fJunkDir = ZpOpt.fJunkDir;
  450.             BOOL fRecurse = ZpOpt.fRecurse;
  451.             BOOL fGrow = ZpOpt.fGrow;
  452.             BOOL fForce = ZpOpt.fForce;
  453.             BOOL fMove = ZpOpt.fMove;
  454.             BOOL fUpdate = ZpOpt.fUpdate;
  455.             BOOL fFreshen = ZpOpt.fFreshen;
  456.             BOOL fJunkSFX = ZpOpt.fJunkSFX;
  457.             BOOL fLatestTime = ZpOpt.fLatestTime;
  458.             BOOL fmakesfx = fMakeSFX;
  459.             BOOL fComment = ZpOpt.fComment;
  460.             BOOL fOffsets = ZpOpt.fOffsets;
  462.             /* Set all zip flags to false */
  463.             ZpOpt.fSuffix = FALSE;
  464.             ZpOpt.fEncrypt = FALSE;
  465.             ZpOpt.fSystem = FALSE;
  466.             ZpOpt.fVolume = FALSE;
  467.             ZpOpt.fExtra = FALSE;
  468.             ZpOpt.fNoDirEntries = FALSE;
  469.             ZpOpt.fExcludeDate = FALSE;
  470.             ZpOpt.fVerbose = FALSE;
  471.             ZpOpt.fQuiet = FALSE;
  472.             ZpOpt.fCRLF_LF = FALSE;
  473.             ZpOpt.fLF_CRLF = FALSE;
  474.             ZpOpt.fJunkDir = FALSE;
  475.             ZpOpt.fRecurse = FALSE;
  476.             ZpOpt.fGrow = FALSE;
  477.             ZpOpt.fForce = FALSE;
  478.             ZpOpt.fMove = FALSE;
  479.             ZpOpt.fUpdate = FALSE;
  480.             ZpOpt.fFreshen = FALSE;
  481.             ZpOpt.fJunkSFX = FALSE;
  482.             ZpOpt.fLatestTime = FALSE;
  483.             ZpOpt.fComment = FALSE;
  484.             ZpOpt.fOffsets = FALSE;
  485.             fMakeSFX = FALSE;
  487.             ZpOpt.fDeleteEntries = TRUE;
  488.             ZpZCL.argc = argc;
  489.             ZpZCL.lpszZipFN = lpumb->szFileName;
  490.             ZpZCL.FNV = (char **)szFileList;
  491.             retcode = MessageBox(hWndMain, "Are You Sure?",
  492.                "Deleting Archive Entries",
  493.                MB_OKCANCEL | MB_ICONEXCLAMATION);
  494.             if (retcode == IDOK)
  495.                {
  496.                BufferOut( "Deleting Files From Archive: %sn",
  497.                   lpumb->szFileName);
  498.                hSaveCursor = SetCursor(hHourGlass);
  499.                ShowCursor(TRUE);
  500.                ZipSetOptions(ZpOpt);
  501.                retcode = ZipArchive(ZpZCL);
  502.                ShowCursor(FALSE);
  503.                SetCursor(hSaveCursor);
  504.                if (retcode == ZE_OK)
  505.                   UpdateListBox();
  506.                }
  507.             else
  508.                BufferOut( "Deleting Files from archive canceledn");
  509.             /* Restore zip flags */
  510.             ZpOpt.fDeleteEntries = FALSE;
  511.             ZpOpt.fSuffix = fSuffix;
  512.             ZpOpt.fEncrypt = fEncrypt;
  513.             ZpOpt.fSystem = fSystem;
  514.             ZpOpt.fVolume = fVolume;
  515.             ZpOpt.fExtra = fExtra;
  516.             ZpOpt.fNoDirEntries = fNoDirEntries;
  517.             ZpOpt.fExcludeDate = fExcludeDate;
  518.             ZpOpt.fVerbose = fVerbose;
  519.             ZpOpt.fQuiet = fQuiet;
  520.             ZpOpt.fCRLF_LF = fCRLF_LF;
  521.             ZpOpt.fLF_CRLF = fLF_CRLF;
  522.             ZpOpt.fJunkDir = fJunkDir;
  523.             ZpOpt.fRecurse = fRecurse;
  524.             ZpOpt.fGrow = fGrow;
  525.             ZpOpt.fForce = fForce;
  526.             ZpOpt.fMove = fMove;
  527.             ZpOpt.fUpdate = fUpdate;
  528.             ZpOpt.fFreshen = fFreshen;
  529.             ZpOpt.fJunkSFX = fJunkSFX;
  530.             ZpOpt.fLatestTime = fLatestTime;
  531.             ZpOpt.fComment = fComment;
  532.             ZpOpt.fOffsets = fOffsets;
  533.             fMakeSFX = fmakesfx;
  534.             }
  535.             break;
  536.         case 5:     /* Update Archive Entries */
  537.             {
  538.             int retcode;
  539. #ifndef WIN32
  540.             FARPROC lpGetDirProc;
  541. #endif
  542.             dwCommDlgHelpId = HELPID_ZIP_UPDATE_ARCHIVE;
  543.             ZpZCL.argc = argc;
  544.             ZpZCL.lpszZipFN = lpumb->szFileName;
  545.             ZpZCL.FNV = (char **)szFileList;
  546.             retcode = MessageBox(hWndMain, "Are You Sure?",
  547.                "Update All Archive Entries",
  548.                MB_OKCANCEL | MB_ICONEXCLAMATION);
  549.             if (retcode == IDOK)
  550.                {
  551.                OPENFILENAME ofn;
  552.                char szTemp[256];
  553. #ifndef WIN32
  554.                _fmemset(&ofn, '', sizeof(OPENFILENAME)); /* initialize struct */
  555. #else
  556.                memset(&ofn, '', sizeof(OPENFILENAME)); /* initialize struct */
  557. #endif
  558.                WinAssert(hWnd);
  559.                szTemp[0] = '';
  560.                ofn.lStructSize = sizeof(OPENFILENAME);
  561.                ofn.hwndOwner = hWnd;
  562.                ofn.hInstance = hInst;
  563.                ofn.lpstrFilter = "All Files (*.*)*.*";
  564.                ofn.nFilterIndex = 1;
  566.                ofn.lpstrFile = szTemp;
  567.                ofn.nMaxFile = PATH_MAX;
  568.                ofn.lpstrFileTitle = NULL;
  569.                ofn.nMaxFileTitle = PATH_MAX; /* ignored ! */
  570.                ofn.lpstrTitle = (LPSTR)"Set Reference Directory";
  571.                ofn.lpstrInitialDir = NULL;
  572.                ofn.Flags = OFN_SHOWHELP | OFN_ENABLEHOOK | OFN_CREATEPROMPT |
  573.                   OFN_HIDEREADONLY|OFN_ENABLETEMPLATE;
  574. #ifndef WIN32
  575.                lpGetDirProc = MakeProcInstance((FARPROC)GetDirProc, hInst);
  576. #   ifndef MSC
  577.                (UINT CALLBACK *)ofn.lpfnHook = (UINT CALLBACK *)lpGetDirProc;
  578. #   else
  579.                ofn.lpfnHook = lpGetDirProc;
  580. #   endif
  581. #else
  582.                ofn.lpfnHook = (LPOFNHOOKPROC)GetDirProc;
  583. #endif
  584.                ofn.lpTemplateName = "GETDIR";   /* see getfiles.dlg   */
  585.                if ((GetOpenFileName(&ofn)) &&
  586.                   (szRefDir[0] != ''))
  587.                   {
  588.                   BufferOut( "Updating Files in Archive: %sn",
  589.                      lpumb->szFileName);
  590.                   hSaveCursor = SetCursor(hHourGlass);
  591.                   ShowCursor(TRUE);
  592.                   ZipSetOptions(ZpOpt);
  593.                   retcode = ZipArchive(ZpZCL);
  594.                   ShowCursor(FALSE);
  595.                   SetCursor(hSaveCursor);
  596.                   if (retcode == ZE_OK)
  597.                      UpdateListBox();
  598.                   }
  599.                }
  600.             else
  601.                BufferOut( "Updating archive canceledn");
  602.             break;
  603.             }
  604.           }
  605.     } while (iSelection < cSelLBItems);
  608.     /* march through list box checking what's selected
  609.      * and what is not.
  610.      */
  612. done:
  614.     if ( hMem )
  615.        {
  616.        GlobalUnlock( hMem );
  617.        GlobalFree( hMem );
  618.        }
  619.     if (hFileList)
  620.        {
  621.        GlobalUnlock(hFileList);
  622.        GlobalFree(hFileList);
  623.        }
  624.     GlobalUnlock(hnd);
  625.     GlobalFree(hnd);
  628.     ShowCursor(FALSE);
  629.     SetCursor(hSaveCursor);
  630.     ReleaseCapture();
  631.     SoundAfter();      /* play sound afterward if requested */
  632.     if (!uf.fIconSwitched)  /* if haven't already, switch icons */
  633.     {
  634.         HANDLE hIcon;
  636.         hIcon = LoadIcon(hInst,"unzipped"); /* load final icon   */
  637.         WinAssert(hIcon);
  638. #ifndef WIN32
  639.         SetClassWord(hWndMain, GCW_HICON, hIcon);
  640. #else
  641.         SetClassLong(hWndMain, GCL_HICON, (LONG)hIcon);
  642. #endif
  643.         uf.fIconSwitched = TRUE;    /* flag that we've switched it  */
  644.     }
  645. }
  647. /* Display the archive comment using the Info-ZIP engine. */
  648. void DisplayComment(HWND hWnd)
  649. {
  651.    SetCapture(hWnd);
  652.    hSaveCursor = SetCursor(hHourGlass);
  653.    ShowCursor(TRUE);
  654.    bRealTimeMsgUpdate = FALSE;
  655.    /* Called here when showing zipfile comment */
  656.    lpDCL->ncflag = 0;
  657.    lpDCL->fQuiet = 0;
  658.    lpDCL->ntflag = 0;
  659.    lpDCL->nvflag = 0;
  660.    lpDCL->nUflag = 1;
  661.    lpDCL->nzflag = 1;
  662.    lpDCL->ndflag = 0;
  663.    lpDCL->noflag = 0;
  664.    lpDCL->naflag = 0;
  665.    argc   = 0;
  666.    lpDCL->lpszZipFN = lpumb->szFileName;
  667.    argv = NULL;
  668.    lpDCL->lpszExtractDir = NULL;
  669.    Unz_SingleEntryPoint(argc, argv, 0, NULL, lpDCL, lpUserFunctions);
  670.    ShowCursor(FALSE);
  671.    SetCursor(hSaveCursor);
  672.    bRealTimeMsgUpdate = TRUE;
  673.    ReleaseCapture();
  674.    SoundAfter();      /* play sound during if requested         */
  675. }