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

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

压缩解压

开发平台：

Visual C++

wndproc.c：源码内容
  1. /* Windows Info-ZIP Window Procedure, wndproc.c.
  2.  * Author: Robert A. Heath, 157 Chartwell Rd., Columbia, SC 29210
  3.  * I, Robert Heath, place this source code module in the public domain.
  4.  *
  5.  * Modifications: 1995, 1996 M. White
  6.  */
  7. #include <sys/types.h>
  8. #include <sys/stat.h>
  9. #include <time.h>
  10. #include <string.h>
  11. #include <stdio.h>
  12. #include <ctype.h>
  13. #ifdef __BORLANDC__
  14. #  include <dir.h>
  15. #else
  16. #  include <direct.h>
  17. #endif
  18. #include "wiz.h"
  19. #include "helpids.h"
  20. /* For a some reason I haven't bothered to try to figure out
  21.  * shellapi.h must follow wiz.h
  22.  */
  23. #include <shellapi.h>
  25. FARPROC lpOldEditProc;
  26. extern LRESULT CALLBACK SubClassEditProc(HWND, WORD, WPARAM, LPARAM);
  28. char LongFileTrailer[] =
  29.      "%7lu  %7lu %4s                    %u file%s";
  30. char ShortFileTrailer[] = "%7lu                    %u file%s";
  31. char Far HeadersShort[]  = " Length    Date    Time    Name";
  32. char Far HeadersLong[]  =
  33.   " Length     Size Ratio   Date     Time   Name";
  34. char Far *Headers[] = {HeadersShort, HeadersLong};
  35. char szTotalsLine[80];              /* text for totals of zip archive */
  37. BOOL fUpdateEntries, bSizing = FALSE, bMouseButtonDown = FALSE;
  38. OPENFILENAME ofnTemp; /* Open file name structure for edit box save and open */
  39. /* Forward Refs
  40.  */
  41. void GetDirectory(LPSTR lpDir);
  42. void GetHelpContext(WPARAM wParam);
  43. extern LPUSERFUNCTIONS lpUserFunctions;
  45. HWND hPatternSelectDlg; /* pattern select modeless dialog   */
  46. static UINT uCommDlgHelpMsg;   /* common dialog help message ID */
  47. DWORD dwCommDlgHelpId = HELPID_HELP; /* what to pass to WinHelp() */
  48. char szFormatKeyword[2][6] = { "short", "long" };
  49. static BOOL move_flag = FALSE;
  50. static BOOL rename_flag = FALSE;
  51. DWORD dwHelpContextId;
  52. LPSTR lpchLast;
  54. #ifndef WIN32
  55. /* Trailers are the lines just above the totals */
  56. static char * __based(__segname("STRINGS_TEXT")) szTrailers[2] = {
  57. " ------                    -------",
  58. "-------  -------  ---                    -------"
  59. } ;
  60. #endif
  61. static char __based(__segname("STRINGS_TEXT")) szCantChDir[] =
  62.    "Internal error: Cannot change directory. Common dialog error code is 0x%lX.";
  64. /* size of char in SYSTEM font in pixels */
  65. #ifndef WIN32
  66. short dxChar, dyChar;
  67. #else
  68. long dxChar, dyChar;
  69. #endif
  70. /*       This will allow you to perform a hit test on a line in the
  71.          list box, however, you then tend to lose the concept of being
  72.          able to do ctrl-mouse click and undo selections. It wasn't
  73.          important enough to spend any more time fooling with.
  74. */
  75. #if 0
  76. void MapCursorToListItem(void);
  77. void MapCursorToListItem(void)
  78. {
  79. DWORD          dwpos;
  80. LV_HITTESTINFO lvhti;
  81. UINT           state;
  82. LV_ITEM        lvi;
  83. int            iItemClicked;
  84. if (ListView_GetItemCount(hWndList))
  85.    {
  86.    /* Find out where the cursor was */
  87.    dwpos = GetMessagePos();
  88.    lvhti.pt.x = LOWORD(dwpos);
  89.    lvhti.pt.y = HIWORD(dwpos);
  91.    MapWindowPoints(HWND_DESKTOP, hWndList, &lvhti.pt, 1);
  92.    state = lvhti.pt.x;
  93.    lvhti.pt.x = 0;
  94.    /* Now do a hittest with this point. We keep testing so we can
  95.       find out if the mouse click was anywhere on the row.
  96.     */
  97.    while (((iItemClicked = ListView_HitTest(hWndList, &lvhti)) < 0) &&
  98.          (lvhti.pt.x < (int)state))
  99.          {
  100.          lvhti.pt.x++;
  101.          }
  103.    /* Okay, have we clicked on a live item? */
  104.    if (lvhti.flags & LVHT_ONITEM)
  105.       {
  106.       lvi.mask      = LVIF_STATE;
  107.       lvi.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
  108.       lvi.iItem     = iItemClicked;
  109.       lvi.iSubItem  = 0;
  111.       ListView_GetItem(hWndList, &lvi);
  113.       if (lvi.state & LVIS_SELECTED)
  114.          lvi.state = 0;
  115.       else
  116.          lvi.state = LVIS_SELECTED | LVIS_FOCUSED;
  118.       ListView_SetItem(hWndList, &lvi);
  119.       }
  120.    }
  121. }
  122. #endif
  124. LPSTR lstrrchr(LPSTR lpszSrc, char chFind)
  125. {
  126. LPSTR   lpszFound = (LPSTR)0;
  127. LPSTR   lpszT;
  129. if ( lpszSrc )
  130.    {
  131.    for (lpszT = lpszSrc; *lpszT; ++lpszT)
  132.        {
  133.        if ((*lpszT) == chFind)
  134.           lpszFound = lpszT;
  135.        }
  136.    }
  137. return lpszFound;
  138. }
  140. /* Copy only the path portion of current file name into
  141.  * given buffer, lpszDestDir, translate into ANSI.
  142.  */
  143. void GetArchiveDir(LPSTR lpszDestDir)
  144. {
  145. LPSTR lpchLast;
  147. /* strip off filename to make directory name    */
  148. lstrcpy(lpszDestDir, lpumb->szFileName);
  149. if ((lpchLast = lstrrchr(lpszDestDir, '\'))!=0)
  150.    *lpchLast = '';
  151. else if ((lpchLast = lstrrchr(lpszDestDir, ':'))!=0)
  152.    *(++lpchLast) = ''; /* clobber char AFTER the colon! */
  153. }
  155. void GetDirectory(LPSTR lpDir)
  156. {
  157. LPSTR lpchLast;
  158. /* If no '\' then set directory name to "" */
  159. if ((lpchLast = lstrrchr(lpDir, '\')) == 0)
  160.    {
  161.    lpDir[0] = '';
  162.    return;
  163.    }
  164. /* strip off filename to make directory name    */
  165. if ((lpchLast = lstrrchr(lpDir, '\'))!=0)
  166.    *lpchLast = '';
  167. else if ((lpchLast = lstrrchr(lpDir, ':'))!=0)
  168.    *(++lpchLast) = ''; /* clobber char AFTER the colon! */
  169. }
  171. /*
  172.  * FUNCTION: SetCaption(HWND hWnd)
  173.  * PURPOSE: Set new caption for main window
  174.  */
  175. void
  176. SetCaption(HWND hWnd)
  177. {
  178. #define SIMPLE_NAME_LEN 15
  179. static BOOL FirstTime = TRUE;
  180. WORD wMenuState;
  181. char szSimpleFileName[SIMPLE_NAME_LEN+1];  /* just the 8.3 part in ANSI char set */
  182. LPSTR lpszFileNameT;        /* pointer to simple filename               */
  183. BOOL    fIconic = IsIconic(hWnd);   /* is window iconic ?   */
  184. BOOL fWndEnabled; /* Is button to be enabled? */
  186. /* point to simple filename in OEM char set */
  187. if ((((lpszFileNameT = lstrrchr(lpumb->szFileName, '\'))!=0) ||
  188.    ((lpszFileNameT = lstrrchr(lpumb->szFileName, ':')))!=0))
  189.    lpszFileNameT++;
  190. else
  191.    lpszFileNameT = lpumb->szFileName;
  193. #ifndef WIN32
  194. _fstrncpy(szSimpleFileName, lpszFileNameT, SIMPLE_NAME_LEN);
  195. #else
  196. strncpy(szSimpleFileName, lpszFileNameT, SIMPLE_NAME_LEN);
  197. #endif
  198. szSimpleFileName[SIMPLE_NAME_LEN] = ''; /* force termination */
  200. wMenuState = (WORD)(szSimpleFileName[0] ? MF_ENABLED : MF_GRAYED);
  201. fWndEnabled = (BOOL) (szSimpleFileName[0] ? TRUE : FALSE);
  202. /* Enable/Disable menu items */
  203. EnableMenuItem(hMenu, IDM_SELECT_ALL, wMenuState|MF_BYCOMMAND);
  204. EnableMenuItem(hMenu, IDM_DESELECT_ALL, wMenuState|MF_BYCOMMAND);
  205. EnableMenuItem(hMenu, IDM_SELECT_BY_PATTERN, wMenuState|MF_BYCOMMAND);
  207. /* Enable/Disable buttons */
  208. if (!FirstTime)
  209.    {
  210.    WinAssert(hSelectAll);
  211.    EnableWindow( hSelectAll, fWndEnabled);
  212.    WinAssert(hDeselectAll);
  213.    EnableWindow( hDeselectAll, fWndEnabled);
  214.    WinAssert(hSelectPattern);
  215.    EnableWindow( hSelectPattern, fWndEnabled);
  216.    }
  218. if ((lstrlen(szUnzipToDirName) == 2) && (szUnzipToDirName[1] == ':') &&
  219.    szSimpleFileName[0])
  220.    {
  221.    lstrcpy(szUnzipToDirName, lpumb->szFileName);
  222.    if ((lpszFileNameT = lstrrchr(szUnzipToDirName, '\'))!=0)
  223.       lpszFileNameT[0] = '';
  224.    if (lstrlen(szUnzipToDirName) == 2)
  225.       lstrcat(szUnzipToDirName, "\");
  226.    }
  227. if (!szSimpleFileName[0])
  228.    lstrcpy(szSimpleFileName, "No Zip File");
  229. wsprintf(lpumb->szBuffer, "%s - %s %s %s",
  230.                (LPSTR)szAppName,
  231.                (LPSTR)(szSimpleFileName),
  232.                (LPSTR)(!fIconic && szUnzipToDirName[0] ? " - " : ""),
  233.                (LPSTR)(!fIconic ? szUnzipToDirName : ""));
  234. SetWindowText(hWnd, lpumb->szBuffer);
  235. FirstTime = FALSE;
  236. }
  238. /*
  239.  * FUNCTION: WiZWndMainProc(HWND, unsigned, WORD, LONG)
  240.  *
  241.  * PURPOSE:  Processes messages
  242.  *
  243.  * MESSAGES:
  244.  *
  245.  * WM_DESTROY      - destroy window
  246.  * WM_SIZE         - window size has changed
  247.  * WM_QUERYENDSESSION - willing to end session?
  248.  * WM_ENDSESSION   - end Windows session
  249.  * WM_CLOSE        - close the window
  250.  * WM_SIZE         - window resized
  251.  * WM_PAINT        - windows needs to be painted
  252.  * WM_DROPFILES    - open a dropped file
  253.  * COMMENTS:
  254.  * WM_COMMAND processing:
  255.  *    IDM_OPEN -  open a new file.
  256.  *    IDM_EXIT -  exit.
  257.  *    IDM_ABOUT - display "About" box.
  258.  */
  260. LRESULT WINAPI WiZMainWndProc(HWND hWnd, WORD wMessage, WPARAM wParam, LPARAM lParam)
  261. {
  263. HDC hDC;                /* device context       */
  264. TEXTMETRIC    tm;           /* text metric structure    */
  265. char drive;
  266. #ifndef WIN32
  267. FARPROC lpfnAbout, lpfnSelectDir;
  268. #endif
  269. char *ptr;
  271. switch (wMessage)
  272.     {
  273.     case WM_CREATE: /* create  window       */
  274.       hInst = ((LPCREATESTRUCT)lParam)->hInstance;
  275.       hAccTable = LoadAccelerators(hInst, "WiZAccels");
  276.       hBrush = CreateSolidBrush(GetSysColor(BG_SYS_COLOR)); /* background */
  278.       hMenu = GetMenu(hWnd);
  280.       /* Get an hourglass cursor to use during file transfers */
  281.       hHourGlass = LoadCursor(0, IDC_WAIT);
  283.       hFixedFont = GetStockObject(ANSI_FIXED_FONT);
  284.       hDC = GetDC(hWnd);  /* get device context */
  285.       hOldFont = SelectObject(hDC, hFixedFont);
  286.       GetTextMetrics(hDC, &tm);
  287.       ReleaseDC(hWnd, hDC);
  288.       dxChar = tm.tmAveCharWidth;
  289.       dyChar = tm.tmHeight + tm.tmExternalLeading + tm.tmInternalLeading;
  291.       WinAssert(hWnd);
  292. #ifndef WIN32
  293.       hWndList = CreateWindow("listbox", NULL,
  294.                         WS_CHILD|WS_DLGFRAME|WS_VSCROLL|LBS_NOTIFY|
  295.                         LBS_EXTENDEDSEL|ES_NOHIDESEL,
  296.                         0, 0,
  297.                         0, 0,
  298.                         hWnd, (HMENU)IDM_LISTBOX,
  299.                         GetWindowWord (hWnd, GWW_HINSTANCE), NULL);
  300. #else
  301.       hWndList = CreateWindow(WC_LISTVIEW, NULL,
  302.                         WS_CHILD | WS_DLGFRAME |
  303.                         LVS_REPORT | LVS_SHOWSELALWAYS |
  304.                         LVS_SORTASCENDING,
  305.                         0, 0,
  306.                         0, 0,
  307.                         hWnd, (HMENU)IDM_LISTBOX,
  308.                         (HANDLE)GetWindowLong (hWnd, GWL_HINSTANCE), NULL);
  309. #endif
  310.       WinAssert(hWndList);
  311.       SendMessage(hWndList, WM_SETFONT, (WPARAM)hFixedFont, FALSE);
  312.       WinAssert(hWnd);
  314. #ifdef WIN32
  315.       {
  316.       LV_COLUMN lvc;
  317.       int       iCol;
  318.       char      szText[6][20]= {"Name", "Orig Size", "Comp Size","Ratio","  Date",
  319.                   "Time"};
  321.       /* Initialize the LV_COLUMN structure. */
  322.       lvc.mask    = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
  323.       lvc.fmt     = LVCFMT_LEFT;
  324.       lvc.cx      = 95;
  326.       for (iCol = 0; iCol < 6; iCol++)
  327.           {
  328.           lvc.pszText = szText[iCol];
  329.           lvc.iSubItem = iCol;
  330.           if (ListView_InsertColumn(hWndList, iCol, &lvc) == -1)
  331.               return FALSE;
  332.           }
  334.       ListView_SetColumnWidth(hWndList, 0, MAKELPARAM((int)30*dxChar, 0));
  335.       ListView_SetColumnWidth(hWndList, 1, MAKELPARAM((int)11*dxChar, 0));
  336.       ListView_SetColumnWidth(hWndList, 2, MAKELPARAM((int)11*dxChar, 0));
  337.       ListView_SetColumnWidth(hWndList, 3, MAKELPARAM((int)7*dxChar, 0));
  338.       ListView_SetColumnWidth(hWndList, 4, MAKELPARAM((int)10*dxChar, 0));
  339.       ListView_SetColumnWidth(hWndList, 5, MAKELPARAM((int)7*dxChar, 0));
  340.       }
  341. #endif /* WIN32 */
  343. #ifndef WIN32
  344.       hWndStatic = CreateWindow("StaticClass", "WiZ Edit/Status Window",
  345.                             WS_OVERLAPPEDWINDOW|WS_SIZEBOX,
  346.                             0, 0,
  347.                             0, 0,
  348.                             hWnd,
  349.                             (HWND) 0,
  350.                             GetWindowWord (hWnd, GWW_HINSTANCE), NULL);
  352.       hWndEdit = CreateWindow("edit", NULL,
  353.                             WS_CHILD |ES_MULTILINE|ES_NOHIDESEL|
  354.                             ES_AUTOHSCROLL|WS_VSCROLL|WS_HSCROLL,
  355.                             0, 0,
  356.                             0, 0,
  357.                             hWndStatic,
  358.                             NULL,
  359.                             GetWindowWord (hWnd, GWW_HINSTANCE),
  360.                             NULL);
  361. #else
  362.       hWndStatic = CreateWindow("StaticClass", "WiZ Edit/Status Window",
  363.                             WS_OVERLAPPEDWINDOW|WS_SIZEBOX,
  364.                             0, 0,
  365.                             0, 0,
  366.                             hWnd,
  367.                             NULL, /* Use class menu */
  368.                             (HANDLE)GetWindowLong (hWnd, GWL_HINSTANCE), NULL);
  370.       WinAssert(hWndStatic);
  372.       hWndEdit = CreateWindow("RICHEDIT", NULL,
  373.                             WS_CHILD |ES_MULTILINE|ECO_AUTOWORDSELECTION|
  374.                             ECO_AUTOHSCROLL|WS_VSCROLL|WS_HSCROLL|
  375.                             ES_NOHIDESEL|ECO_AUTOVSCROLL,
  376.                             0, 0,
  377.                             0, 0,
  378.                             hWndStatic,
  379.                             NULL,
  380.                             (HANDLE)GetWindowLong (hWnd, GWL_HINSTANCE),
  381.                             NULL);
  382. #endif
  383.       WinAssert(hWndEdit);
  385.       /* Subclass the edit control */
  386.       lpOldEditProc = (FARPROC)GetWindowLong (hWndEdit, GWL_WNDPROC);
  387.       SetWindowLong (hWndEdit, GWL_WNDPROC, (LONG)SubClassEditProc);
  389.       /* Now we set the maximum size the edit control can utilize */
  390. #ifdef WIN32
  391.       SendMessage(hWndEdit, EM_EXLIMITTEXT, (WPARAM)0, (LPARAM)EDIT_BUF_SIZE);
  392. #else
  393.       SendMessage(hWndEdit, EM_LIMITTEXT, (WPARAM) 0, 0L);
  394. #endif
  395.       SendMessage(hWndEdit, WM_SETFONT, (WPARAM)hFixedFont, TRUE);
  397. #ifdef WIN32
  398.       /* Insure rich edit control alignment is set to left */
  399.       {
  400.       PARAFORMAT pf;
  402.       pf.cbSize = sizeof(pf);
  403.       pf.dwMask = PFM_ALIGNMENT;
  404.       pf.wAlignment = PFA_LEFT;
  405.       SendMessage(hWndEdit, EM_SETPARAFORMAT, 0, (LPARAM)&pf);
  406.       }
  407. #endif
  408.       GetWizOptions(); /* Get options from .INI file */
  409.       UpdateListBox();
  410. #ifndef WIN32
  411.       SendMessage(hWndList, LB_SETSEL, 1, 0L);
  412. #else
  413.       ListViewSetSel(0, TRUE);
  414. #endif
  415.       SetCaption(hWnd);
  416.       uCommDlgHelpMsg = RegisterWindowMessage((LPSTR)HELPMSGSTRING); /* register open help message */
  417.       if ( uf.fCanDragDrop )
  418.          DragAcceptFiles( hWnd, TRUE );
  419.       break;
  421.     case WM_SETFOCUS:
  422.         SetFocus(hWndList);
  423.         break;
  425. #ifdef WIN32
  426.     /* This whole section is only for the ListView control which is only
  427.        available with Windows 95/Windows NT - and not for 16 bit Windows
  428.        programs.
  429.      */
  430.     case WM_NOTIFY:
  431.          {
  432.          DWORD          dwpos;
  433.          NM_LISTVIEW *pNm = (NM_LISTVIEW *)lParam;
  435.          /* Are we dealing with a message from the list box? */
  436.          if (pNm->hdr.hwndFrom != hWndList)
  437.             break;
  439.          switch (pNm->hdr.code) {
  441.          case NM_RCLICK: /* Now is it a right mouse button click? */
  442.             {
  443. /*       This will allow you to perform a hit test on a line in the
  444.          list box, however, you then tend to lose the concept of being
  445.          able to do ctrl-mouse click and undo selections. It wasn't
  446.          important enough to spend any more time fooling with.
  447.             MapCursorToListItem();
  448. */
  449.             dwpos = GetMessagePos();
  450.             PostMessage(hWndMain, WM_RBUTTONUP, (WPARAM) 0L, (LPARAM) dwpos); /* Yep */
  451.             break;
  452.             }
  454.          case NM_DBLCLK: /* Double-click in ListView control */
  455.             {
  456. /*       This will allow you to perform a hit test on a line in the
  457.          list box, however, you then tend to lose the concept of being
  458.          able to do ctrl-mouse click and undo selections. It wasn't
  459.          important enough to spend any more time fooling with.
  460.             MapCursorToListItem();
  461. */
  462.             UpdateButtons();
  463.             if ( uf.fCanDragDrop )
  464.                DragAcceptFiles( hWnd, FALSE );
  466.             Action(hWnd, (WPARAM)(wLBSelection - IDM_LB_EXTRACT));
  467.             if ( uf.fCanDragDrop )
  468.                DragAcceptFiles( hWnd, TRUE );
  469.             break;
  470.             }
  471.          /* This is for "sorting" and is a kludge as it requires reading
  472.             from disk each time you do a sort, but I don't know a better
  473.             way other than keeping a list in memory which results in a
  474.             whole bunch of memory being eaten up just for a "fancy". If
  475.             the time delay bothers you - don't do it, just take this out.
  476.           */
  477.          case LVN_COLUMNCLICK: /* Column clicked on - now sort */
  478.             ListViewSortOnColumns(pNm->iSubItem);
  479. #ifndef WIN32
  480.             SendMessage(hWndList, LB_SETSEL, 1, 0L);
  481. #else
  482.             ListViewSetSel(0, TRUE);
  483. #endif
  484.             break;
  485.          case LVN_ITEMCHANGED:
  486.             {
  487.             UpdateButtons();
  488.             break;
  489.             }
  490. /*       This will allow you to perform a hit test on a line in the
  491.          list box, however, you then tend to lose the concept of being
  492.          able to do ctrl-mouse click and undo selections. It wasn't
  493.          important enough to spend any more time fooling with.
  495.          case NM_CLICK:
  496.             MapCursorToListItem();
  497.             break;
  498. */
  499.             }
  500.          break;
  501.          }
  502. #endif /* WIN32 ? */
  504.     case WM_ACTIVATE:
  505.         /* This section is put in to fix a weird problem with the listbox
  506.            not displaying the contents of an archive file if it is either
  507.            dropped on WiZ, or if it is started from the command line.
  508.            I have no idea why this happens.
  509.         */
  510.         {
  511.         extern int ofretval;
  512.         if ((lpumb->szFileName[0]!='') && (ofretval))
  513.            {
  514.            UpdateListBox();
  515.            /* We have to have something selected before we can
  516.               activate the buttons!
  517.             */
  518. #ifndef WIN32
  519.            SendMessage(hWndList, LB_SETSEL, 1, 0L);
  520. #else
  521.            ListViewSetSel(0, TRUE);
  522. #endif
  523.            UpdateButtons();
  524.            }
  525.         ofretval = 0;
  526.         }
  527.         SetCaption(hWnd);
  528.         return DefWindowProc(hWnd, wMessage, wParam, lParam);
  530.     case WM_SIZE:
  531.         SizeWindow();
  532.         break;
  534.     case WM_SYSCOMMAND:
  535.         return DefWindowProc( hWnd, wMessage, wParam, lParam );
  537.     case WM_RBUTTONUP:
  538.          /*
  539.            PURPOSE: Display and track popup menu on button click.
  541.            PARAMETERS:
  542.              hWnd      - Window handle
  543.              lparam    - Coordinates where the mouse was pressed
  545.            Always returns 0 - Message handled
  546.           */
  547.          {
  548.            HMENU hmenu;
  549.            HMENU hmenuTrackPopup;
  550.           RECT  rc;
  551.          BOOL fButtonState;
  552.           POINT pt;
  553.          DWORD dwpos;
  555.           /* Draw the appropriate "floating" popup in the client area
  556.             Check the listbox first
  557.           */
  558.           GetWindowRect(hWndList, &rc);
  559.             dwpos = GetMessagePos();
  560.             pt.x = LOWORD(dwpos);
  561.             pt.y = HIWORD(dwpos);
  562.           if (PtInRect(&rc, pt))
  563.              {
  564.               /* Get the menu for the popup from the resource file. */
  565.               hmenu = LoadMenu(hInst, "PopupListMenu");
  566.               if (!hmenu)
  567.                  return 0;
  569.               /* Get the first menu in it which we will use for the call to
  570.                * TrackPopup(). This could also be created on the fly using
  571.                * CreatePopupMenu and then using InsertMenu() or
  572.                * AppendMenu.
  573.              */
  574.               hmenuTrackPopup = GetSubMenu(hmenu, 0);
  575.             if (lpumb->szFileName[0] &&
  576. #ifndef WIN32
  577.                SendMessage(hWndList, LB_GETSELCOUNT, 0, 0L)) /* anything selected ? */
  578. #else
  579.                ListView_GetSelectedCount(hWndList))
  580. #endif
  581.                   fButtonState = TRUE;
  582.             else
  583.                   fButtonState = FALSE;
  585.             EnableMenuItem(hmenuTrackPopup, IDM_EXTRACT,
  586.                (fButtonState ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  587.             EnableMenuItem(hmenuTrackPopup, IDM_DISPLAY,
  588.                (fButtonState ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  589.             EnableMenuItem(hmenuTrackPopup, IDM_TEST,
  590.                (fButtonState ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  591.             EnableMenuItem(hmenuTrackPopup, IDM_SHOW_COMMENT,
  592.                    (BOOL)(fButtonState && lpUserFunctions->cchComment ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  593.             EnableMenuItem(hmenuTrackPopup, IDM_GET_ZIPINFO,
  594.                  (fButtonState ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  595.             EnableMenuItem(hmenuTrackPopup, IDM_UPDATE_ZIP,
  596.                  (fButtonState ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  597.             EnableMenuItem(hmenuTrackPopup, IDM_ZIP_DELETE_ENTRIES,
  598.                (fButtonState ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  599.             if (lpumb->szFileName[0] != '')
  600.                fButtonState = TRUE;
  601.             else
  602.                fButtonState = FALSE;
  603.             EnableMenuItem(hmenuTrackPopup, IDM_COPY_ARCHIVE,
  604.                (fButtonState ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  605.             EnableMenuItem(hmenuTrackPopup, IDM_MOVE_ARCHIVE,
  606.                (fButtonState ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  607.             EnableMenuItem(hmenuTrackPopup, IDM_DELETE_ARCHIVE,
  608.                (fButtonState ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  609.             EnableMenuItem(hmenuTrackPopup, IDM_RENAME_ARCHIVE,
  610.                 (fButtonState ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  611.             EnableMenuItem(hmenuTrackPopup, IDM_SELECT_ALL,
  612.                (fButtonState ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  613.             EnableMenuItem(hmenuTrackPopup, IDM_DESELECT_ALL,
  614.                (fButtonState ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  615.             EnableMenuItem(hmenuTrackPopup, IDM_SELECT_BY_PATTERN,
  616.                (fButtonState ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  618.               /* Draw and track the "floating" popup */
  619. #ifdef WIN32
  620.               TrackPopupMenuEx(hmenuTrackPopup,
  621.                          TPM_LEFTALIGN | TPM_TOPALIGN |     /* default values */
  622.                          TPM_LEFTBUTTON | TPM_HORIZONTAL |  /* equivalent to 0 */
  623.                          TPM_RIGHTBUTTON,                   /* Right selection */
  624.                          pt.x, pt.y,
  625.                          hWnd,
  626.                          NULL);
  627. #else
  628.               TrackPopupMenu(hmenuTrackPopup,
  629.                          TPM_LEFTALIGN |   /* default values */
  630.                          TPM_LEFTBUTTON |  /* equivalent to 0 */
  631.                          TPM_RIGHTBUTTON,  /* Right selection */
  632.                          pt.x, pt.y, 0,
  633.                          hWnd,
  634.                          NULL);
  635. #endif
  636.               /* Destroy the menu since we are done with it. */
  637.               DestroyMenu(hmenu);
  638.               return 0;
  639.              }
  641.          /* The mouse was not in the list box, now let's check the edit box */
  642.          GetWindowRect(hWndEdit, &rc);
  643.          if (PtInRect(&rc, pt))
  644.             {
  645.             UINT fEnable;
  646.             UINT ichStart, ichEnd;
  647. #ifndef WIN32
  648.             DWORD dwResult;
  649. #endif
  650.             /* Get the edit control menu which we will use for the call to
  651.              * TrackPopup(). This could also be created on the fly using
  652.              * CreatePopupMenu and then using InsertMenu() or
  653.              * AppendMenu.
  654.              */
  655.             hmenu = LoadMenu(hInst, "EditMenu");
  656.             if (!hmenu)
  657.                return 0;
  658.             /* Get the edit menu from the parent of the edit control */
  659.             hmenuTrackPopup = GetSubMenu(hmenu, 1);
  660.             /* Is an "undo" operation possible? */
  661.                 fEnable = (UINT)SendMessage(hWndEdit, EM_CANUNDO, 0, 0);
  662.             EnableMenuItem(hmenuTrackPopup, IDM_EDIT_UNDO,
  663.                (fEnable ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  665.                 /* Can we paste to the edit control? */
  666.                 if (OpenClipboard(hWnd))
  667.                    {
  668.                    /* Only allow text */
  669.                    if (IsClipboardFormatAvailable(CF_TEXT) ||
  670.                        IsClipboardFormatAvailable(CF_OEMTEXT))
  671.                        fEnable = TRUE;
  672.                    else
  673.                        fEnable = FALSE;
  674.                    }
  675.                 CloseClipboard();
  676.                 EnableMenuItem(hmenuTrackPopup, IDM_EDIT_PASTE,
  677.                     (fEnable ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  679.                 /* Is anything selected in the edit control */
  680. #ifdef WIN32
  681.                 SendMessage(hWndEdit, EM_GETSEL, (WPARAM)&ichStart, (LPARAM)&ichEnd);
  682.             fEnable = (ichStart != ichEnd);
  683. #else
  684.                 dwResult = SendMessage(hWndEdit, EM_GETSEL, 0, 0);
  685.             ichStart = LOWORD(dwResult);
  686.             ichEnd = HIWORD(dwResult);
  687.             fEnable = (ichStart != ichEnd);
  688. #endif
  689.             EnableMenuItem(hmenuTrackPopup, IDM_EDIT_CUT,
  690.                (fEnable ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  691.             EnableMenuItem(hmenuTrackPopup, IDM_EDIT_COPY,
  692.                (fEnable ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  693.             EnableMenuItem(hmenuTrackPopup, IDM_EDIT_DELETE,
  694.                (fEnable ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  696.             /* Anything in the edit control at all? */
  697.             fEnable = (UINT)SendMessage(hWndEdit, WM_GETTEXTLENGTH, 0, 0);
  698.             EnableMenuItem(hmenuTrackPopup, IDM_EDIT_SELECT_ALL,
  699.                (fEnable ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  700.             EnableMenuItem(hmenuTrackPopup, IDM_CLEAR_STATUS,
  701.                (fEnable ? MF_ENABLED : MF_DISABLED|MF_GRAYED)|MF_BYCOMMAND);
  703.             /* Draw and track the "floating" popup */
  704. #ifdef WIN32
  705.             TrackPopupMenuEx(hmenuTrackPopup,
  706.                          TPM_LEFTALIGN | TPM_TOPALIGN |     /* default values */
  707.                          TPM_LEFTBUTTON | TPM_HORIZONTAL |  /* equivalent to 0 */
  708.                          TPM_RIGHTBUTTON,                   /* Right selection */
  709.                          pt.x, pt.y,
  710.                          hWndEdit,
  711.                          NULL);
  712. #else
  713.             TrackPopupMenu(hmenuTrackPopup,
  714.                          TPM_LEFTALIGN |      /* default values */
  715.                          TPM_LEFTBUTTON |
  716.                          TPM_RIGHTBUTTON,     /* Right selection */
  717.                          pt.x, pt.y, 0,
  718.                          hWnd,
  719.                          NULL);
  720. #endif
  721.            }
  722.         return 0;
  723.         }
  725.     /*
  726.      *
  727.      * This section is solely to cause the bubble help to be drawn with
  728.      * different colors than the background window. This is not necessary
  729.      * for 16 bit windows, as this is done for you.
  730.      *
  731.      */
  732. #ifdef WIN32
  733.     case WM_CTLCOLORSTATIC:
  734.            {
  735.            POINT point;
  736.            SetBkColor((HDC)wParam, GetSysColor(COLOR_INFOBK));
  737.            SetBkMode((HDC)wParam, OPAQUE);
  738.            SetTextColor((HDC)wParam, GetSysColor(COLOR_INFOTEXT));
  739.            point.x = point.y = 0;
  740.            ClientToScreen(hWnd, &point);
  741.            SetBrushOrgEx((HDC)wParam, point.x, point.y, NULL);
  742.            hBrush = CreateSolidBrush(GetSysColor(COLOR_INFOBK));
  743.            return ((DWORD)hBrush);
  744.            }
  745. #endif
  746.     case WM_COMMAND:
  747.         /* Was F1 just pressed in a menu, or are we in help mode */
  748.         /* (Shift-F1)? */
  750.         if (uf.fHelp)
  751.            {
  752.            GetHelpContext(wParam);
  754.            if ((!dwHelpContextId) && (uf.fHelp))
  755.               {
  756.               MessageBox( hWnd, "Context Help not available for this item",
  757.                          "Help Example", MB_OK);
  758.               }
  759.            else
  760.               if (uf.fHelp)
  761.                   WinHelp(hWnd,szHelpFileName,HELP_CONTEXT,dwHelpContextId);
  762.            uf.fHelp = FALSE;
  763.         }
  764.         else /* not in help mode */
  765.         {
  766. #ifndef WIN32
  767.         RECT  rClient;
  768. #endif
  769.             switch (LOWORD(wParam))
  770.             {
  771.             case IDM_GREP_ARCHIVE:
  772.                {
  773.                extern char baseDir[PATH_MAX];
  774.                extern char SearchPattern[PATH_MAX];
  775.                char *p, drive[2], szTmp[PATH_MAX];
  776.                OPENFILENAME ofn;
  777. #ifndef WIN32
  778.                FARPROC lpfnGrepArchive;
  779. #endif
  780. //               dwCommDlgHelpId = HELPID_MAKEDIR_HELP; /* if someone hits help */
  781.                if ( uf.fCanDragDrop )
  782.                     DragAcceptFiles( hWnd, FALSE );
  784. #ifndef WIN32
  785.                _fmemset(&ofn, '', sizeof(OPENFILENAME)); /* initialize struct */
  786. #else
  787.                memset(&ofn, '', sizeof(OPENFILENAME)); /* initialize struct */
  788. #endif
  789.                WinAssert(hWnd);
  790.                szTmp[0] = '';
  791.                ofn.lStructSize = sizeof(OPENFILENAME);
  792.                ofn.hwndOwner = hWnd;
  793.                ofn.hInstance = hInst;
  794.                ofn.lpstrFilter = "All Files (*.*)*.*";
  795.                ofn.nFilterIndex = 1;
  797.                ofn.lpstrFile = szTmp;
  798.                ofn.nMaxFile = PATH_MAX;
  799.                ofn.lpstrFileTitle = NULL;
  800.                ofn.nMaxFileTitle = PATH_MAX; /* ignored ! */
  801.                ofn.lpstrTitle = (LPSTR)"Find Files in Archive";
  802.                ofn.lpstrInitialDir = NULL;
  803.                ofn.Flags = OFN_SHOWHELP | OFN_ENABLEHOOK | OFN_CREATEPROMPT |
  804.                   OFN_HIDEREADONLY | OFN_ENABLETEMPLATE | OFN_NOCHANGEDIR;
  805. #ifndef WIN32
  806.                lpfnGrepArchive = MakeProcInstance((FARPROC)GrepArchiveProc, hInst);
  807. #   ifndef MSC
  808.                (UINT CALLBACK *)ofn.lpfnHook = (UINT CALLBACK *)lpfnGrepArchive;
  809. #   else
  810.                ofn.lpfnHook = lpfnGrepArchive;
  811. #   endif
  812. #else
  813.                ofn.lpfnHook = (LPOFNHOOKPROC)GrepArchiveProc;
  814. #endif
  815.                ofn.lpTemplateName = "GREPARCHIVES";   /* see grep.dlg   */
  816.                GetOpenFileName(&ofn);
  817.                if ((lstrlen(SearchPattern) != 0) &&
  818.                   (lstrlen(baseDir) != 0))
  819.                   {
  820.                   drive[0] = baseDir[0];
  821.                   drive[1] = '';
  822.                   p = &baseDir[2];
  823.                   /* Off we go - the control handle is set to null as a flag */
  824.                   FindFile(drive, p, NULL);
  825.                   }
  826.                }
  827.                if (uf.fCanDragDrop)
  828.                    DragAcceptFiles(hWnd, TRUE);
  829.                break;
  830. #ifndef WIN32
  831.             /* Deal with the Edit box menu items */
  832.             case IDM_EDIT_UNDO:
  833.                     SendMessage(hWndEdit, EM_UNDO, 0, 0);
  834.                break;
  835.             case IDM_EDIT_CUT:
  836.                     SendMessage(hWndEdit, WM_CUT, 0, 0);
  837.                break;
  838.             case IDM_EDIT_COPY:
  839.                     SendMessage(hWndEdit, WM_COPY, 0, 0);
  840.                break;
  841.             case IDM_EDIT_PASTE:
  842.                     SendMessage(hWndEdit, WM_PASTE, 0, 0);
  843.                break;
  844.             case IDM_EDIT_DELETE:
  845.                     SendMessage(hWndEdit, WM_CLEAR, 0, 0);
  846.                SetWindowText(hWndStatic, "WiZ Edit/Status Window");
  847.                break;
  848.             case IDM_EDIT_SELECT_ALL:
  849.                     SendMessage(hWndEdit, EM_SETSEL, (WPARAM)0,
  850.                   (LPARAM)MAKELPARAM(0,-1));
  851.                break;
  852. #endif
  854.             case IDM_ZIP_TARGET:
  855.             case IDM_ZIP_PREFERENCES:
  856.             case IDM_UNZIP_PREFERENCES:
  857.                 if ( uf.fCanDragDrop )
  858.                     DragAcceptFiles( hWnd, FALSE );
  860.                 ZipWndProc(hWnd, wMessage, wParam, lParam);
  861.                 WriteZipOptionsProfile();
  863.                 if ( uf.fCanDragDrop )
  864.                     DragAcceptFiles( hWnd, TRUE );
  865.                break;
  866.             case IDM_OPEN:
  867.                 /* If unzipping separately and previous file exists,
  868.                  * go to directory where archive lives.
  869.                  */
  870.                 if ( uf.fCanDragDrop )
  871.                     DragAcceptFiles( hWnd, FALSE );
  873.             /* If not unzipping to same directory as archive and
  874.              * file already open, go to where file lives.
  875.              * If extracting to different directory, return to
  876.              * that directory after selecting archive to open.
  877.              */
  878.             if (lpumb->szUnzipFromDirName[0])
  879.                {
  880.                lstrcpy(lpumb->szDirName, lpumb->szUnzipFromDirName);
  881.                }
  882.             if (lpumb->szFileName[0])
  883.                {
  884.                /* strip off filename to make directory name    */
  885.                GetArchiveDir(lpumb->szDirName);
  886.                }
  887.             else
  888.                {
  889.                if (!lpumb->szUnzipFromDirName[0])
  890.                   lpumb->szDirName[0] = ''; /* assume no dir   */
  891.                }
  892.             lpumb->szBuffer[0] = '';
  893. #ifndef WIN32
  894.             _fmemset(&lpumb->ofn, '', sizeof(OPENFILENAME)); /* initialize struct */
  895. #else
  896.             memset(&lpumb->ofn, '', sizeof(OPENFILENAME)); /* initialize struct */
  897. #endif
  898.             lpumb->ofn.lStructSize = sizeof(OPENFILENAME);
  899.             lpumb->ofn.hwndOwner = hWnd;
  900.             lpumb->ofn.lpstrFilter = "Zip Files (*.zip)*.zipSelf-extracting Files (*.exe)*.exeAll Files (*.*)*.*";
  901.             lpumb->ofn.nFilterIndex = 1;
  902.             lpumb->ofn.lpstrFile = lpumb->szFileName;
  903.             lpumb->szFileName[0] = '';   /* no initial filename   */
  904.             lpumb->ofn.nMaxFile = PATH_MAX;
  905.             lpumb->ofn.lpstrFileTitle = lpumb->szBuffer; /* ignored */
  906.             lpumb->ofn.lpstrInitialDir = (LPSTR)(!lpumb->szDirName[0] ? NULL : lpumb->szDirName);
  908.             lpumb->ofn.nMaxFileTitle = PATH_MAX;
  909.             lpumb->ofn.Flags = OFN_SHOWHELP | OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST |
  910.                    OFN_HIDEREADONLY|OFN_NOVALIDATE;
  911.             dwCommDlgHelpId = HELPID_OPEN; /* specify correct help for open dlg   */
  912.             if (GetOpenFileName(&lpumb->ofn))   /* if successful file open  */
  913.                {
  914.                /* Yes, you should be able to get the fully qualified path name
  915.                   in lpumb->szFileName when you return from GetOpenFileName(),
  916.                   however, at least Borland 4.52 (others?) does not return a fully
  917.                   qualified path, but simply the file name. This kludge gets
  918.                   around that.
  919.                 */  
  920.                getcwd(lpumb->szDirName, PATH_MAX);
  921.                /* If we get a fully qualified file name, then the second
  922.                   character should be a colon.
  923.                 */
  924.                if (lpumb->szFileName[1] != ':')
  925.                   {
  926.                   lstrcpy(lpumb->szBuffer, lpumb->szDirName);
  927.                   if (lpumb->szBuffer[lstrlen(lpumb->szBuffer)-1] != '\')
  928.                      lstrcat(lpumb->szBuffer, "\");
  929.                   lstrcat(lpumb->szBuffer, lpumb->szFileName);
  930.                   lstrcpy(lpumb->szFileName, lpumb->szBuffer);
  931.                   }
  932.                /*
  933.                Save the last "unzip from" directory
  934.                */
  935.                if (lpumb->szDirName[1] == ':')
  936.                   drive = lpumb->szDirName[0];
  937.                else
  938.                   drive = '';
  940.                if (uf.fSaveUnZipFromDir &&
  941.                   (toupper(drive) != 'A') &&
  942.                   (toupper(drive) != 'B'))
  943.                   {
  944.                   lstrcpy(lpumb->szUnzipFromDirName, lpumb->szDirName);
  945.                   if (lpumb->szUnzipFromDirName[strlen(lpumb->szUnzipFromDirName)-1]
  946.                      == ':')
  947.                      lstrcat(lpumb->szUnzipFromDirName, "\");
  948.                   WritePrivateProfileString(szAppName, szDefaultUnzipFromDir,
  949.                                  lpumb->szUnzipFromDirName, szWiZIniFile);
  950.                   }
  951.                else
  952.                   WritePrivateProfileString(szAppName, szDefaultUnzipFromDir,
  953.                                  "", szWiZIniFile);
  954.                if (uf.fUnzipToZipDir || /* unzipping to same directory as archive */
  955.                   szUnzipToDirName[0] == '') /* or no default */
  956.                   {
  957.                   /* strip off filename to make directory name    */
  958.                   lstrcpy(szUnzipToDirName, lpumb->szDirName);
  959.                   }
  960.                }
  961.                UpdateListBox(); /* fill in list box */
  962. #ifndef WIN32
  963.                SendMessage(hWndList, LB_SETSEL, 1, 0L);
  964. #else
  965.                 ListViewSetSel(0, TRUE);
  966. #endif               
  967.                UpdateButtons(); /* update state of buttons */
  968.                SetCaption(hWnd);
  969. #ifndef WIN32
  970.                /* Update archive totals area */
  971.                WinAssert(hWndList);
  972.                GetClientRect( hWndList, &rClient );
  973.                OffsetRect( &rClient, 0, dyChar );
  974.                rClient.top = rClient.bottom;
  975.                rClient.bottom = rClient.top + (6*dyChar);
  976.                InvalidateRect( hWnd, &rClient, TRUE);
  977. #endif
  978.                if ( uf.fCanDragDrop )
  979.                   DragAcceptFiles( hWnd, TRUE );
  980.                break;
  982.             case IDM_CHDIR:
  983.                 if ( uf.fCanDragDrop )
  984.                     DragAcceptFiles( hWnd, FALSE );
  986. #ifndef WIN32
  987.                 _fmemset(&lpumb->ofn, '', sizeof(OPENFILENAME)); /* initialize struct */
  988. #else
  989.                 memset(&lpumb->ofn, '', sizeof(OPENFILENAME)); /* initialize struct */
  990. #endif
  991.                 lpumb->ofn.lStructSize = sizeof(OPENFILENAME);
  992.                 lpumb->ofn.hwndOwner = hWnd;
  993.                 lpumb->ofn.hInstance = hInst;
  994.                 lpumb->ofn.lpstrFilter = "All Files (*.*)*.*";
  995.                 lpumb->ofn.nFilterIndex = 1;
  996.                 lstrcpy(lpumb->szUnzipToDirNameTmp, szUnzipToDirName); /* initialize */
  997.                 { /* Braces are here to allow the declaration of uDirNameLen */
  998. #ifndef WIN32
  999.                 size_t uDirNameLen = _fstrlen(lpumb->szUnzipToDirNameTmp);
  1000. #else
  1001.                 size_t uDirNameLen = strlen(lpumb->szUnzipToDirNameTmp);
  1002. #endif
  1003.                /* If '\' not at end of directory name, add it now.
  1004.                 */
  1005.                 if (uDirNameLen > 0 && lpumb->szUnzipToDirNameTmp[uDirNameLen-1] != '\')
  1006.                    lstrcat(lpumb->szUnzipToDirNameTmp, "\");
  1007.                 }
  1008.                 lstrcat(lpumb->szUnzipToDirNameTmp,
  1009.                     "johnny376376.375374373"); /* fake name */
  1010.                 lpumb->ofn.lpstrFile = lpumb->szUnzipToDirNameTmp; /* result goes here! */
  1011.                 lpumb->ofn.nMaxFile = PATH_MAX;
  1012.                 lpumb->ofn.lpstrFileTitle = NULL;
  1013.                 lpumb->ofn.nMaxFileTitle = PATH_MAX; /* ignored ! */
  1014.                 lpumb->ofn.lpstrInitialDir = szUnzipToDirName;
  1015.                 lpumb->ofn.lpstrTitle = (LPSTR)"Unzip To";
  1016.                 lpumb->ofn.Flags = OFN_SHOWHELP | OFN_PATHMUSTEXIST |
  1017.                            OFN_HIDEREADONLY|OFN_NOCHANGEDIR;
  1018.                 lpumb->ofn.Flags = OFN_SHOWHELP | OFN_PATHMUSTEXIST | OFN_ENABLEHOOK |
  1019.                            OFN_HIDEREADONLY|OFN_ENABLETEMPLATE|OFN_NOCHANGEDIR;
  1020. #ifndef WIN32
  1021.                 lpfnSelectDir =
  1022.                   MakeProcInstance((FARPROC)SelectDirProc, hInst);
  1023. #ifndef MSC
  1024.                 (UINT CALLBACK *)lpumb->ofn.lpfnHook = (UINT CALLBACK *)lpfnSelectDir;
  1025. #else
  1026.                 lpumb->ofn.lpfnHook = lpfnSelectDir;
  1027. #endif
  1029. #else
  1030.                 lpumb->ofn.lpfnHook = (LPOFNHOOKPROC)SelectDirProc;
  1031. #endif
  1032.                 lpumb->ofn.lpTemplateName = "SELDIR";   /* see seldir.dlg   */
  1033.                 dwCommDlgHelpId = HELPID_CHDIR; /* in case user hits "help" button */
  1034.                 if (GetSaveFileName(&lpumb->ofn)) /* successfully got dir name ? */
  1035.                    {
  1036. #ifndef WIN32
  1037.                    ptr = _fstrrchr(lpumb->ofn.lpstrFile, '\');
  1038. #else
  1039.                    ptr = strrchr(lpumb->ofn.lpstrFile, '\');
  1040. #endif
  1041.                    if (ptr != NULL)
  1042.                       lpumb->ofn.lpstrFile[(int)(ptr - lpumb->ofn.lpstrFile)] = '';
  1043.                    lstrcpy(szUnzipToDirName, lpumb->ofn.lpstrFile); /* save result */
  1045.                    if (szUnzipToDirName[1] == ':')
  1046.                       {
  1047.                       drive = szUnzipToDirName[0];
  1048.                       if (lstrlen(szUnzipToDirName) == 2)
  1049.                          { /* We only have a drive letter and a colon */
  1050.                          lstrcat(szUnzipToDirName, "\");
  1051.                          }
  1052.                       }
  1053.                    else
  1054.                       drive = '';
  1055.                    if (uf.fSaveUnZipToDir &&
  1056.                       (toupper(drive) != 'A') &&
  1057.                       (toupper(drive) != 'B'))
  1058.                        {
  1059.                   /* Always save last directory written to */
  1060.                        WritePrivateProfileString(szAppName, szDefaultUnzipToDir,
  1061.                           szUnzipToDirName, szWiZIniFile);
  1062.                        }
  1063.                    SetCaption(hWnd);
  1064.                    }
  1065.                 else /* either real error or canceled */
  1066.                    {
  1067.                    DWORD dwExtdError = CommDlgExtendedError(); /* debugging */
  1069.                    if (dwExtdError != 0L) /* if not canceled then real error */
  1070.                       {
  1071.                       wsprintf (lpumb->szBuffer, szCantChDir, dwExtdError);
  1072.                       MessageBox (hWnd, lpumb->szBuffer, szAppName, MB_ICONINFORMATION | MB_OK);
  1073.                       }
  1074.                    }
  1075. #ifndef WIN32
  1076.                 FreeProcInstance(lpfnSelectDir);
  1077. #endif
  1078.                 if ( uf.fCanDragDrop )
  1079.                     DragAcceptFiles( hWnd, TRUE );
  1080.                 break;
  1081.             case IDM_DELETE_ARCHIVE:
  1082.                 {
  1083.                 char szStr[PATH_MAX];
  1084.                 if ( uf.fCanDragDrop )
  1085.                     DragAcceptFiles( hWnd, FALSE );
  1086.                 sprintf(szStr, "Are you sure you want to deleten%s", lpumb->szFileName);
  1087.                 if (MessageBox(hWnd, szStr, "Deleting File", MB_ICONSTOP | MB_OKCANCEL) == IDOK)
  1088.                    {
  1089.                    remove(lpumb->szFileName);
  1090.                    BufferOut("Deleting %sn", lpumb->szFileName);
  1091. #ifndef WIN32
  1092.                    SendMessage(hWndList, LB_RESETCONTENT, 0, 0);
  1093. #else
  1094.                    ListView_DeleteAllItems(hWndList);
  1095. #endif
  1096.                    lpumb->szFileName[0] = '';
  1097.                    SetCaption(hWnd);
  1098.                    UpdateButtons(); /* update state of buttons */
  1099.                    }
  1100.                 if ( uf.fCanDragDrop )
  1101.                   DragAcceptFiles( hWnd, TRUE );
  1102.                 break;
  1103.                 }
  1104.             case IDM_MOVE_ARCHIVE:
  1105.                 /*
  1106.                  * Yes - this can be done under Win32 differently, but
  1107.                  * you have to go through some hoops, and this just makes
  1108.                  * it easier.
  1109.                  */
  1110.                 move_flag = TRUE;
  1111.                 dwCommDlgHelpId = HELPID_MOVE_ARCHIVE; /* in case user hits "help" button */
  1112.             case IDM_RENAME_ARCHIVE:
  1113.                 if (!move_flag)
  1114.                    {
  1115.                    rename_flag = TRUE;
  1116.                    dwCommDlgHelpId = HELPID_RENAME_ARCHIVE; /* in case user hits "help" button */
  1117.                    }
  1118.             case IDM_COPY_ARCHIVE:
  1119.                 if ( uf.fCanDragDrop )
  1120.                     DragAcceptFiles( hWnd, FALSE );
  1121.                 if ((!move_flag) && (!rename_flag))
  1122.                    dwCommDlgHelpId = HELPID_COPY_ARCHIVE; /* in case user hits "help" button */
  1123.                 CopyArchive(hWnd, move_flag, rename_flag);
  1124.                 if ( uf.fCanDragDrop )
  1125.                     DragAcceptFiles( hWnd, TRUE );
  1126.                 move_flag = FALSE;
  1127.                 rename_flag = FALSE;
  1128.                 break;
  1130.             case IDM_EXIT:
  1131.                 WriteZipOptionsProfile();
  1132.                 SendMessage(hWnd, WM_CLOSE, 0, 0L);
  1133.                 break;
  1135.             case IDM_HELP:  /* Display Help */
  1136. #ifndef WIN32
  1137.                 WinHelp(hWnd,szHelpFileName,HELP_INDEX,0L);
  1138. #else
  1139.                 WinHelp(hWnd,szHelpFileName,HELP_FINDER,0L);
  1140. #endif
  1141.                 break;
  1143.             case IDM_SHIFT_HELP:
  1144.                 uf.fHelp = TRUE;
  1145.                 SetCursor(hHelpCursor);
  1146.                 break;
  1148.             case IDM_ESCAPE:
  1149.                 if (uf.fHelp)
  1150.                     {
  1151.                    uf.fHelp = FALSE;
  1152. #ifndef WIN32
  1153.                    SetCursor((HCURSOR)GetClassWord(hWndMain,GCW_HCURSOR));
  1154. #else
  1155.                    SetCursor((HCURSOR)GetClassLong(hWndMain,GCL_HCURSOR));
  1156. #endif
  1157.                    dwHelpContextId = (DWORD) 0L;
  1158.                    return 0;
  1159.                    }
  1160.                 break;
  1162.             case IDM_HELP_HELP:
  1163.                 WinHelp(hWnd,"WINHELP.HLP",HELP_INDEX,0L);
  1164.                 break;
  1166.             case IDM_ABOUT:
  1167.                 if ( uf.fCanDragDrop )
  1168.                     DragAcceptFiles( hWnd, FALSE );
  1169. #ifndef WIN32
  1170.                 lpfnAbout = MakeProcInstance(AboutProc, hInst);
  1171.                 DialogBox(hInst, "About", hWnd, lpfnAbout);
  1172.                 FreeProcInstance(lpfnAbout);
  1173. #else
  1174.                 DialogBox(hInst, "About", hWnd, AboutProc);
  1175. #endif
  1176.                 if ( uf.fCanDragDrop )
  1177.                     DragAcceptFiles( hWnd, TRUE );
  1178.                 break;
  1180. #ifndef WIN32
  1181.             case IDM_LISTBOX:       /* command from listbox     */
  1182.                 if (cZippedFiles)
  1183.                 {
  1184.                     switch (GET_WM_COMMAND_CMD(wParam, lParam))
  1185.                     {
  1186.                     case LBN_SELCHANGE:
  1187.                         UpdateButtons();
  1188.                         break;
  1189.                     case LBN_DBLCLK:
  1190.                         UpdateButtons();
  1191.                         if ( uf.fCanDragDrop )
  1192.                             DragAcceptFiles( hWnd, FALSE );
  1194.                         Action(hWnd, (WPARAM)(wLBSelection - IDM_LB_EXTRACT));
  1195.                         if ( uf.fCanDragDrop )
  1196.                             DragAcceptFiles( hWnd, TRUE );
  1197.                         break;
  1198.                     }
  1199.                 }
  1200.                 break;
  1201.             case IDM_LONG:
  1202.             case IDM_SHORT:
  1203.                 /* If format change, uncheck old, check new. */
  1204.                 if ((LOWORD(wParam) - IDM_SHORT) != (signed int)uf.fFormatLong)
  1205.                 {
  1206.                     WPARAM wFormatTmp = (WPARAM)(LOWORD(wParam)  - IDM_SHORT);
  1207.                     int __far *pnSelItems; /* pointer to list of selected items */
  1208.                     HANDLE  hnd = 0;
  1209.                     int cSelLBItems ; /* no. selected items in listbox */
  1210.                     RECT    rClient;
  1212.                     cSelLBItems = CLBItemsGet(hWndList, &pnSelItems, &hnd);
  1213.                     CheckMenuItem(hMenu, (IDM_SHORT+uf.fFormatLong), MF_BYCOMMAND|MF_UNCHECKED);
  1214.                     CheckMenuItem(hMenu, (IDM_SHORT+wFormatTmp), MF_BYCOMMAND|MF_CHECKED);
  1215.                     uf.fFormatLong = wFormatTmp;
  1216.                     UpdateListBox();
  1218.                     WriteZipOptionsProfile();
  1220.                     /* anything previously selected ? */
  1221.                     if (cSelLBItems > 0)
  1222.                        {
  1223.                        ReselectLB(hWndList, cSelLBItems, pnSelItems);
  1224.                        GlobalUnlock(hnd);
  1225.                        GlobalFree(hnd);
  1226.                        }
  1228.                     /* make sure labels & Zip archive totals get updated */
  1229.                     WinAssert(hWnd);
  1230.                     GetClientRect( hWnd, &rClient );
  1231.                     /* Drop down two lines for button row */
  1232.                     rClient.top = (2*dyChar);
  1233.                     rClient.bottom = rClient.top + (2*dyChar);
  1234.                     /* Okay, now we selected only the "header" for
  1235.                      * repainting, invalidate it.
  1236.                      */
  1237.                     InvalidateRect( hWnd, &rClient, TRUE);
  1238.                     WinAssert(hWndList);
  1239.                     GetClientRect( hWndList, &rClient );
  1240.                     rClient.top = rClient.bottom;
  1241.                     /* Now allow for two lines for button row,
  1242.                      * two lines for the "header" and two lines
  1243.                      * for the trailer. Then invalidate it.
  1244.                      */
  1245.                     rClient.bottom = rClient.top + (6*dyChar);
  1246.                     InvalidateRect( hWnd, &rClient, TRUE);
  1247.                 }
  1248.                 break;
  1249. #endif
  1250.             case IDM_SAVE_UNZIP_TO_DIR:
  1251.                 /* Toggle value of fSaveUnzipToDir flag. */
  1252.                 uf.fSaveUnZipToDir = !uf.fSaveUnZipToDir;
  1253.                 CheckMenuItem(hMenu,IDM_SAVE_UNZIP_TO_DIR,MF_BYCOMMAND|
  1254.                                 (WORD)(uf.fSaveUnZipToDir ? MF_CHECKED: MF_UNCHECKED));
  1255.                 WriteZipOptionsProfile();
  1256.                 if (uf.fSaveUnZipToDir)
  1257.                    WritePrivateProfileString(szAppName, szDefaultUnzipToDir,
  1258.                          "", szWiZIniFile);
  1259.                 break;
  1261.             case IDM_SAVE_UNZIP_FROM_DIR:
  1262.                 /* Toggle value of fSaveUnzipToDir flag. */
  1263.                 uf.fSaveUnZipFromDir = !uf.fSaveUnZipFromDir;
  1264.                 CheckMenuItem(hMenu,IDM_SAVE_UNZIP_FROM_DIR,MF_BYCOMMAND|
  1265.                                 (WORD)(uf.fSaveUnZipFromDir ? MF_CHECKED: MF_UNCHECKED));
  1266.                 WriteZipOptionsProfile();
  1267.                 if (uf.fSaveUnZipFromDir)
  1268.                    WritePrivateProfileString(szAppName, szDefaultUnzipFromDir,
  1269.                          "", szWiZIniFile);
  1270.                 break;
  1272.             case IDM_UNZIP_TO_ZIP_DIR:
  1273.                 /* toggle value of Unzip to .ZIP  */
  1274.                 uf.fUnzipToZipDir = !uf.fUnzipToZipDir;
  1275.                 CheckMenuItem(hMenu,IDM_UNZIP_TO_ZIP_DIR,MF_BYCOMMAND|
  1276.                                     (WORD)(uf.fUnzipToZipDir ? MF_CHECKED:MF_UNCHECKED));
  1277.                 EnableMenuItem(hMenu,IDM_CHDIR,MF_BYCOMMAND|
  1278.                                     (WORD)(uf.fUnzipToZipDir ? MF_GRAYED:MF_ENABLED));
  1279.                 WriteZipOptionsProfile();
  1280.                 if (uf.fUnzipToZipDir && lpumb->szDirName[0])
  1281.                    {
  1282.                    lstrcpy(szUnzipToDirName, lpumb->szDirName); /* get new dirname */
  1283.                    SetCaption(hWnd);
  1284.                    }
  1285.                 break;
  1286.             case IDM_SAVE_ZIP_TO_DIR:
  1287.                fSaveZipToDir = !fSaveZipToDir;
  1288.                CheckMenuItem(hMenu, IDM_SAVE_ZIP_TO_DIR,
  1289.                   MF_BYCOMMAND | (fSaveZipToDir ? MF_CHECKED : MF_UNCHECKED));
  1290.                if (!fSaveZipToDir)
  1291.                   szTargetZipDir[0] = '';
  1292.                WriteZipOptionsProfile();
  1293.                break;
  1294.             case IDM_MAKE_DIR:
  1295.                {
  1296.                FARPROC lpfnMakeDir;
  1297.                dwCommDlgHelpId = HELPID_MAKEDIR_HELP; /* if someone hits help */
  1298.                lpfnMakeDir = MakeProcInstance(MakeDirProc, hInst);
  1299.                DialogBox(hInst, "MAKEDIR", hWnd, lpfnMakeDir);
  1300. #ifndef WIN32
  1301.                FreeProcInstance(lpfnMakeDir);
  1302. #endif
  1303.                }
  1304.                break;
  1305.             case IDM_SOUND_OPTIONS: /* launch Sound Options dialog box   */
  1306.              {
  1307.             FARPROC lpfnSoundOptions;
  1308.             dwCommDlgHelpId = HELPID_SOUND_OPTIONS; /* if someone hits "help" */
  1309.                 lpfnSoundOptions = MakeProcInstance(SoundProc, hInst);
  1310.                 DialogBox(hInst, "SOUND", hWnd, lpfnSoundOptions);
  1311. #ifndef WIN32
  1312.                 FreeProcInstance(lpfnSoundOptions);
  1313. #endif
  1314.             }
  1315.                 break;
  1317.             case IDM_SHOW_COMMENT:
  1318.                 /* display the archive comment in mesg window */
  1319.                 if ( uf.fCanDragDrop )
  1320.                     DragAcceptFiles( hWnd, FALSE );
  1321.                 DisplayComment(hWnd);
  1322.                 if ( uf.fCanDragDrop )
  1323.                     DragAcceptFiles( hWnd, TRUE );
  1324.                 break;
  1326.             case IDM_SHOW_BUBBLE_HELP:
  1327.                 /* Show toolbar help */
  1328.                 uf.fShowBubbleHelp = !uf.fShowBubbleHelp;
  1329.                 CheckMenuItem(hMenu, IDM_SHOW_BUBBLE_HELP,
  1330.                  MF_BYCOMMAND | (uf.fShowBubbleHelp ? MF_CHECKED : MF_UNCHECKED));
  1331.                 WriteZipOptionsProfile();
  1332.                 break;
  1334.             case IDM_GET_ZIPINFO:
  1335.             case IDM_UPDATE_ZIP:
  1336.             case IDM_DISPLAY:
  1337.             case IDM_TEST:
  1338.             case IDM_EXTRACT:
  1339.             case IDM_ZIP_DELETE_ENTRIES:
  1340.                 if ( uf.fCanDragDrop )
  1341.                     DragAcceptFiles( hWnd, FALSE );
  1343.                 fUpdateEntries = TRUE;
  1344.                 Action(hWnd, (WPARAM)(LOWORD(wParam) - IDM_EXTRACT));
  1345.                 if (ZpOpt.fOffsets)
  1346.                    {
  1347. #ifndef WIN32
  1348.                    DWORD i;
  1349.                    i = SendMessage(hWndList , LB_GETCOUNT, 0, 0);
  1350.                    SendMessage(hWndList , LB_SELITEMRANGE,
  1351.                           (WPARAM) FALSE, MAKELONG(0, i));
  1352. #else
  1353.                    DWORD i, j;
  1354.                    i = ListView_GetItemCount(hWndList);
  1355.                    for (j = 0; j < i; j++)
  1356.                         ListViewSetSel(j, TRUE);
  1357. #endif
  1358.                    }
  1359.                 if ( uf.fCanDragDrop )
  1360.                     DragAcceptFiles( hWnd, TRUE );
  1361.                 break;
  1363.             case IDM_SELECT_ALL:
  1364.             case IDM_DESELECT_ALL:
  1365.                 if (cZippedFiles)
  1366.                    {
  1367. #ifndef WIN32
  1368.                    SendMessage(hWndList , LB_SELITEMRANGE,
  1369.                           (WPARAM)(LOWORD(wParam) == IDM_DESELECT_ALL ? FALSE : TRUE),
  1370.                           MAKELONG(0, (cZippedFiles-1)));
  1371. #else
  1372.                    int i;
  1373.                    int iItems = ListView_GetItemCount(hWndList);
  1374.                    if (LOWORD(wParam) == IDM_DESELECT_ALL)
  1375.                        for (i = 0; i < iItems; i++)
  1376.                            ListViewSetSel(i, FALSE);
  1377.                    else
  1378.                        for (i = 0; i < iItems; i++)
  1379.                            ListViewSetSel(i, TRUE);
  1380. #endif
  1381.                    UpdateButtons();
  1382.                    }
  1383.                 break;
  1385.          case IDM_SELECT_BY_PATTERN:
  1386.             if (!hPatternSelectDlg)
  1387.                {
  1388.                DLGPROC lpfnPatternSelect;
  1390.                dwCommDlgHelpId = HELPID_SELECT_BY_PATTERN;
  1391.                lpfnPatternSelect = (DLGPROC)MakeProcInstance(PatternSelectProc, hInst);
  1392.                WinAssert(lpfnPatternSelect)
  1393.                hPatternSelectDlg =
  1394.                CreateDialog(hInst, "PATTERN", hWnd, lpfnPatternSelect);
  1395.                WinAssert(hPatternSelectDlg);
  1396.                }
  1397.             break;
  1399.          case IDM_CLEAR_STATUS:  /* forward to status window */
  1400.             SendMessage(hWndEdit, WM_COMMAND, IDM_CLEAR_STATUS, 0L);
  1401.             break;
  1403.          case IDM_EDIT_SAVE_AS:
  1404.             {
  1405.             OFSTRUCT ofs;
  1406.             char szFilename[PATH_MAX] = "";
  1407.             char *p;
  1408. #ifdef WIN32
  1409.             DWORD bytes_written;
  1410.             HANDLE hFile;
  1411. #else
  1412.             HFILE hFile;
  1413. #endif
  1415.             memset(&ofnTemp, 0, sizeof (ofnTemp));
  1416.             memset(&ofs, 0, sizeof(ofs));
  1417.             GetWindowText(hWndStatic, szFilename, PATH_MAX);
  1418.             for (p = szFilename; *p; p++)
  1419.                if (*p == '/')
  1420.                   *p = '\';
  1421.             ofnTemp.lStructSize = sizeof (ofnTemp);
  1422.             ofnTemp.hwndOwner = hWndMain;
  1423.             ofnTemp.hInstance = hInst;
  1424.             ofnTemp.lpstrFilter = "All Files (*.*)*.*";
  1425.             ofnTemp.nFilterIndex = 1;
  1426.             ofnTemp.lpstrFile = szFilename;
  1427.             ofnTemp.nMaxFile = PATH_MAX;
  1428.             ofnTemp.lpstrInitialDir = NULL;
  1429.             ofnTemp.Flags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
  1431.              if (GetSaveFileName (&ofnTemp))
  1432.                {
  1433.                unsigned int txtlen;
  1434.                txtlen = (unsigned int)SendMessage(hWndEdit, WM_GETTEXTLENGTH, 0, 0);
  1435.                if (txtlen != 0)
  1436.                   txtlen++;
  1437.                SendMessage(hWndEdit, WM_GETTEXT, txtlen, (LPARAM)pszBuffer);
  1438. #ifndef WIN32
  1439.                hFile = OpenFile(szFilename, &ofs, OF_CREATE);
  1440.                _lwrite (hFile, pszBuffer, lstrlen(pszBuffer));
  1441.                _lclose (hFile);
  1442. #else
  1443.                hFile = CreateFile(szFilename, GENERIC_WRITE, 0, NULL,
  1444.                   CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  1445.                WriteFile(hFile, pszBuffer, lstrlen(pszBuffer), &bytes_written,NULL);
  1446.                CloseHandle(hFile);
  1447. #endif
  1448.                SetWindowText(hWndStatic, szFilename);
  1449.                }
  1450.             }
  1451.             break;
  1453.          case IDM_EDIT_OPEN_FILE:
  1454.             {
  1455.             OFSTRUCT ofs;
  1456.             char szFilename[PATH_MAX] = "";
  1457. #ifdef WIN32
  1458.             DWORD bytes_written, dwSize;
  1459.             HANDLE hFile;
  1460. #else
  1461.             HFILE hFile;
  1462. #endif
  1464.             memset(&ofnTemp, 0, sizeof (ofnTemp));
  1465.             memset(&ofs, 0, sizeof(ofs));
  1467.             ofnTemp.lStructSize = sizeof (ofnTemp);
  1468.             ofnTemp.hwndOwner = hWndMain;
  1469.             ofnTemp.hInstance = hInst;
  1470.             ofnTemp.lpstrFilter = "All Files (*.*)*.*";
  1471.             ofnTemp.nFilterIndex = 1;
  1472.             ofnTemp.lpstrFile = szFilename;
  1473.             ofnTemp.nMaxFile = PATH_MAX;
  1474.             ofnTemp.lpstrInitialDir = NULL;
  1475.             ofnTemp.Flags = OFN_FILEMUSTEXIST;
  1477.             if (GetOpenFileName (&ofnTemp))
  1478.                {
  1479.                extern BOOL MapCRtoCRLF(LPSTR);
  1480.                SendMessage(hWndEdit, WM_COMMAND, IDM_CLEAR_STATUS, 0L);
  1481. #ifndef WIN32
  1482.                hFile = OpenFile(szFilename, &ofs, OF_READ);
  1483.                _lread (hFile, pszBuffer, (UINT)EDIT_BUF_SIZE);
  1484.                _lclose (hFile);
  1485. #else
  1486.                hFile = CreateFile(szFilename, GENERIC_READ, 0, NULL,
  1487.                   OPEN_EXISTING, FILE_ATTRIBUTE_ARCHIVE, NULL);
  1488.                dwSize = GetFileSize(hFile, NULL);
  1489.                if (dwSize >= (dwEditBufSize - 1))
  1490.                   {
  1491.                   HGLOBAL hTemp;
  1492.                   GlobalUnlock(hEditor);
  1493.                   hTemp = GlobalReAlloc(hEditor, dwSize + 0x1000,
  1494.                      GMEM_MOVEABLE|GMEM_ZEROINIT);
  1495.                   if (hTemp)
  1496.                      {
  1497.                      hEditor = hTemp;
  1498.                      dwEditBufSize = dwSize + 0x1000;
  1499.                      }
  1500.                   else
  1501.                      MessageBox(hWndMain,
  1502.                         "Cannot allocate enough memory for file. Truncating file.",
  1503.                         "Insufficient Memory",
  1504.                         MB_ICONINFORMATION|MB_OK);
  1505.                   pszBuffer = GlobalLock(hEditor);
  1506.                   memset(pszBuffer, '', dwEditBufSize);
  1507.                   }
  1508.                ReadFile(hFile, pszBuffer, dwSize, &bytes_written, NULL);
  1509.                CloseHandle(hFile);
  1510. #endif
  1511.                /* Convert CR to CRLF and strip formfeeds */
  1512.                MapCRtoCRLF(pszBuffer);
  1514.                SendMessage(hWndEdit, WM_SETTEXT, 0, (LPARAM)pszBuffer);
  1515.                SetWindowText(hWndStatic, szFilename);
  1516.                UpdateWindow(hWndEdit);
  1517.                }
  1518.             }
  1519.             break;
  1521.          case IDM_MAX_STATUS:
  1522.             {
  1523.             SendMessage(hStatusButton, WM_LBUTTONDOWN,
  1524.                   MK_LBUTTON, MAKELPARAM(5,5) );
  1525.             break;
  1526.             }
  1528.          case IDM_SETFOCUS_ON_STATUS: /* posted from Action() following extract-to-Status */
  1529.             SetFocus(hWndEdit);   /* set focus on Status so user can scroll */
  1530.             break;
  1532.          case IDM_ZIP_STATS:
  1533.             {
  1534.             char szCompFactor[10];
  1535.             char sgn;
  1536.             char CompFactorStr[] = "%c%d%%";
  1537.             char CompFactor100[] = "100%%";
  1539.             if (lpumb->szFileName[0])   /* if file selected */
  1540.                {
  1541.                if (lpUserFunctions->TotalSizeComp > lpUserFunctions->TotalSize)
  1542.                   sgn = '-';
  1543.                else
  1544.                   sgn = ' ';
  1546.                if (lpUserFunctions->CompFactor == 100)
  1547.                    sprintf(szCompFactor, CompFactor100);
  1548.                else
  1549.                    sprintf(szCompFactor, CompFactorStr, sgn,
  1550.                       lpUserFunctions->CompFactor);
  1551.                wsprintf(szTotalsLine,
  1552.                "Total Sizett%7lunCompressed Sizet%7lunRatiott%6snTotal Filest%7u",
  1553.                       lpUserFunctions->TotalSize,
  1554.                       lpUserFunctions->TotalSizeComp,
  1555.                       szCompFactor,
  1556.                       lpUserFunctions->NumMembers);
  1557.                MessageBox(hWndMain, szTotalsLine,
  1558.                   lpumb->szFileName, MB_ICONINFORMATION | MB_OK);
  1559.                }
  1560.             }
  1561.             break;
  1562.          default:
  1563.             return DefWindowProc(hWnd, wMessage, wParam, lParam);
  1564.             }
  1565.         } /* bottom of not in help mode */
  1566.         break;
  1568.     case WM_SETCURSOR:
  1569.         /* In help mode it is necessary to reset the cursor in response */
  1570.         /* to every WM_SETCURSOR message.Otherwise, by default, Windows */
  1571.         /* will reset the cursor to that of the window class. */
  1573.         if (uf.fHelp)
  1574.         {
  1575.             SetCursor(hHelpCursor);
  1576.             break;
  1577.         }
  1578.         return DefWindowProc(hWnd, wMessage, wParam, lParam);
  1581.     case WM_INITMENU:
  1582.         if (uf.fHelp)
  1583.            {
  1584.            SetCursor(hHelpCursor);
  1585.            }
  1586.         return TRUE;
  1588.     case WM_ENTERIDLE:
  1589.         if ((LOWORD(wParam) == MSGF_MENU) && (GetKeyState(VK_F1) & 0x8000))
  1590.            {
  1591.            uf.fHelp = TRUE;
  1592.            PostMessage(hWnd, WM_KEYDOWN, VK_RETURN, 0L);
  1593.            }
  1594.         break;
  1596.     case WM_CLOSE:
  1597.         DestroyWindow(hWnd);
  1598.         break;
  1600.     case WM_DESTROY:
  1601.         if ( uf.fCanDragDrop )
  1602.             DragAcceptFiles( hWnd, FALSE );
  1603.         DeleteObject(hBrush);
  1604.         WinHelp(hWnd, szHelpFileName, HELP_QUIT, 0L);
  1605.         PostQuitMessage(0);
  1606.         break;
  1608.     case WM_DROPFILES:
  1609.         {
  1610.         WORD    cFiles;
  1612.         /* Get the number of files that have been dropped */
  1613.         cFiles = (WORD)DragQueryFile( (HDROP)wParam, (UINT)-1, lpumb->szBuffer, (UINT)256);
  1615.         /* Only handle one dropped file until MDI-ness happens */
  1616.         if (cFiles == 1)
  1617.            {
  1618.            RECT    rClient;
  1620.            DragQueryFile( (HDROP)wParam, 0, lpumb->szFileName, PATH_MAX);
  1621.            GetArchiveDir(lpumb->szDirName); /* get archive dir name */
  1622.            if (uf.fUnzipToZipDir || /* unzipping to same directory as archive */
  1623.                szUnzipToDirName[0] == '') /* or no default */
  1624.               {
  1625.               /* strip off filename to make directory name    */
  1626.               lstrcpy(szUnzipToDirName, lpumb->szDirName);
  1627.               }
  1628.            lstrcpy(lpumb->szBuffer, lpumb->szDirName); /* get scratch copy */
  1629.            DlgDirList (hWnd, lpumb->szBuffer, 0, 0, 0); /* change dir */
  1630.            UpdateListBox(); /* fill in list box */
  1631. #ifndef WIN32
  1632.            SendMessage(hWndList, LB_SETSEL, 1, 0L);
  1633. #else
  1634.            ListViewSetSel(0, TRUE);
  1635. #endif           
  1636.            UpdateButtons(); /* update state of buttons */
  1638.            WinAssert(hWndList);
  1639.            GetClientRect( hWndList, &rClient );
  1640.            OffsetRect( &rClient, 0, dyChar );
  1641.            rClient.top = rClient.bottom;
  1642.            rClient.bottom = rClient.top + (2*dyChar);
  1643.            InvalidateRect( hWnd, &rClient, TRUE);
  1644.            SetCaption(hWnd);
  1645.            }
  1646.         DragFinish( (HDROP)wParam );
  1647.         }
  1648.         break;
  1650. #ifndef WIN32
  1651.     case WM_PAINT:
  1652.            {
  1653.            PAINTSTRUCT ps;
  1654.            RECT    rClient;
  1655.            DWORD   dwBackColor;
  1656.            char szCompFactor[10];
  1657.            char sgn;
  1658.            char CompFactorStr[] = "%c%d%%";
  1659.            char CompFactor100[] = "100%%";
  1661.            hDC = BeginPaint( hWnd, &ps );
  1662.            if ( hDC )
  1663.               {
  1664.               WinAssert(hWndList);
  1665.               UpdateWindow( hWndList );
  1666.               hOldFont = SelectObject ( hDC, hFixedFont);
  1668.               WinAssert(hWnd);
  1669.               GetClientRect( hWnd, &rClient );
  1670.               dwBackColor = SetBkColor(hDC,GetSysColor(COLOR_SCROLLBAR));
  1672.               /* Move "header" down two lines for button room at top */
  1673.               rClient.top = 2 * dyChar;
  1674.               rClient.left += dxChar/2;
  1675.               /* "Draw the header */
  1676.               DrawText( hDC, (LPSTR)Headers[uf.fFormatLong], -1,
  1677.                   &rClient, DT_NOPREFIX | DT_TOP);
  1679.               if (lpumb->szFileName[0])   /* if file selected */
  1680.                  {
  1681.                  WinAssert(hWndList);
  1682.                  GetClientRect( hWndList, &rClient );
  1683.                  /* Drop rectangle down 1 vertical char + 2 */
  1684.                  OffsetRect( &rClient, 0, dyChar+2);
  1685.                  rClient.left += dxChar/2;
  1687.                  /* Move totals "trailer" down two lines for button room */
  1688.                  rClient.top = rClient.bottom + (2 * dyChar) +
  1689.                   (2 * GetSystemMetrics(SM_CYDLGFRAME));
  1690.                  rClient.bottom = rClient.top + dyChar;
  1691.                  DrawText( hDC, (LPSTR)szTrailers[uf.fFormatLong], -1,
  1692.                    &rClient, DT_NOPREFIX | DT_TOP);
  1694.                  /* Display totals line at bottom of listbox */
  1695.                  rClient.top += dyChar;
  1696.                  rClient.bottom += dyChar;
  1698.                  if (lpUserFunctions->TotalSizeComp > lpUserFunctions->TotalSize)
  1699.                     sgn = '-';
  1700.                  else
  1701.                     sgn = ' ';
  1703.                  if (lpUserFunctions->CompFactor == 100)
  1704.                      sprintf(szCompFactor, CompFactor100);
  1705.                  else
  1706.                      sprintf(szCompFactor, CompFactorStr, sgn,
  1707.                         lpUserFunctions->CompFactor);
  1708.                  if (uf.fFormatLong)
  1709.                      wsprintf(szTotalsLine, LongFileTrailer,
  1710.                         lpUserFunctions->TotalSize,
  1711.                         lpUserFunctions->TotalSizeComp,
  1712.                         szCompFactor,
  1713.                         lpUserFunctions->NumMembers,
  1714.                         lpUserFunctions->NumMembers == 1 ? "":"s");
  1715.                  else
  1716.                      wsprintf(szTotalsLine, ShortFileTrailer,
  1717.                         lpUserFunctions->TotalSize,
  1718.                         lpUserFunctions->NumMembers,
  1719.                         lpUserFunctions->NumMembers == 1 ? "" : "s");
  1721.                  DrawText( hDC, szTotalsLine, -1,
  1722.                     &rClient, DT_NOPREFIX | DT_TOP);
  1723.                  }
  1724.               SetBkColor(hDC, dwBackColor);
  1725.               (void)SelectObject ( hDC, hOldFont);
  1726.             }
  1727.            EndPaint(hWnd, &ps);
  1728.            break;
  1729.            }
  1730. #endif
  1731.    default:
  1732.       if (wMessage == uCommDlgHelpMsg)   /* common dialog help message ID */
  1733.          {
  1734.          WinHelp(hWnd, szHelpFileName, HELP_CONTEXT, dwCommDlgHelpId );
  1735.          return 0;
  1736.          }
  1737.       return DefWindowProc(hWnd, wMessage, wParam, lParam);
  1738.     }
  1739.     return 0;
  1740. }
  1742. void GetHelpContext(WPARAM wParam)
  1743. {
  1744. switch (LOWORD(wParam))
  1745.    {
  1746.    case IDM_ESCAPE:
  1747.       if (uf.fHelp)
  1748.          {
  1749.          uf.fHelp = FALSE;
  1750. #ifndef WIN32
  1751.          SetCursor((HCURSOR)GetClassWord(hWndMain,GCW_HCURSOR));
  1752. #else
  1753.          SetCursor((HCURSOR)GetClassLong(hWndMain,GCL_HCURSOR));
  1754. #endif
  1755.          dwHelpContextId = (DWORD) 0L;
  1756.          }
  1757.       break;
  1758.    case IDM_OPEN:
  1759.       dwHelpContextId = (DWORD) HELPID_OPEN;
  1760.       break;
  1761.    case IDM_EXIT:
  1762.       dwHelpContextId = (DWORD) HELPID_EXIT_CMD;
  1763.       break;
  1764.    case IDM_HELP:
  1765.       dwHelpContextId = (DWORD) HELPID_HELP;
  1766.       break;
  1767.    case IDM_HELP_HELP:
  1768.       dwHelpContextId = (DWORD) HELPID_HELP_HELP;
  1769.       break;
  1770.    case IDM_ABOUT:
  1771.       dwHelpContextId = (DWORD) HELPID_ABOUT;
  1772.       break;
  1773.    case IDM_RECR_DIR_STRUCT:
  1774.       dwHelpContextId = (DWORD) HELPID_RECR_DIR_STRUCT;
  1775.       break;
  1776.    case IDM_SHOW_BUBBLE_HELP:
  1777.       dwHelpContextId = (DWORD) HELPID_SHOW_BUBBLE_HELP;
  1778.       break;
  1779.    case IDM_UNZIP_TO_ZIP_DIR:
  1780.       dwHelpContextId = (DWORD) HELPID_UNZIP_TO_ZIP_DIR;
  1781.       break;
  1782.    case IDM_LISTBOX:
  1783.       dwHelpContextId = (DWORD) HELPID_LISTBOX;
  1784.       break;
  1785.    case IDM_EXTRACT:
  1786.       dwHelpContextId = (DWORD) HELPID_EXTRACT;
  1787.       break;
  1788.    case IDM_DISPLAY:
  1789.       dwHelpContextId = (DWORD) HELPID_DISPLAY;
  1790.       break;
  1791.    case IDM_TEST:
  1792.       dwHelpContextId = (DWORD) HELPID_TEST;
  1793.       break;
  1794.    case IDM_DESELECT_ALL:
  1795.       dwHelpContextId = (DWORD) HELPID_DESELECT_ALL;
  1796.       break;
  1797.    case IDM_SELECT_ALL:
  1798.       dwHelpContextId = (DWORD) HELPID_SELECT_ALL;
  1799.       break;
  1800.    case IDM_SELECT_BY_PATTERN:
  1801.       dwHelpContextId = (DWORD) HELPID_SELECT_BY_PATTERN;
  1802.       break;
  1803.    case IDM_CLEAR_STATUS:
  1804.       dwHelpContextId = (DWORD) HELPID_CLEAR_STATUS;
  1805.       break;
  1806.    case IDM_SOUND_OPTIONS:
  1807.       dwHelpContextId = (DWORD) HELPID_SOUND_OPTIONS;
  1808.       break;
  1809.    case IDM_MAX_STATUS:
  1810.       dwHelpContextId = (DWORD) HELPID_MAX_STATUS;
  1811.       break;
  1812.    case IDM_SAVE_UNZIP_FROM_DIR:
  1813.       dwHelpContextId = (DWORD) HELPID_SAVE_UNZIP_FROM_DIR;
  1814.       break;
  1815.    case IDM_SAVE_UNZIP_TO_DIR:
  1816.       dwHelpContextId = (DWORD) HELPID_SAVE_UNZIP_TO_DIR;
  1817.       break;
  1818.    case IDM_CHDIR:
  1819.       dwHelpContextId = (DWORD) HELPID_CHDIR;
  1820.       break;
  1821.    case IDM_COPY_ARCHIVE:
  1822.       dwHelpContextId = (DWORD) HELPID_COPY_ARCHIVE;
  1823.       break;
  1824.    case IDM_MOVE_ARCHIVE:
  1825.       dwHelpContextId = (DWORD) HELPID_MOVE_ARCHIVE;
  1826.       break;
  1827.    case IDM_DELETE_ARCHIVE:
  1828.       dwHelpContextId = (DWORD) HELPID_DELETE_ARCHIVE;
  1829.       break;
  1830.    case IDM_RENAME_ARCHIVE:
  1831.       dwHelpContextId = (DWORD) HELPID_RENAME_ARCHIVE;
  1832.       break;
  1833.    case IDM_MAKE_DIR:
  1834.       dwHelpContextId = (DWORD) HELPID_MAKEDIR_HELP;
  1835.       break;
  1836.    case IDM_MAKEDIR_HELP:
  1837.       dwHelpContextId = (DWORD) HELPID_MAKEDIR_HELP;
  1838.       break;
  1839.    case IDM_EDIT_OPEN_FILE:
  1840.       dwHelpContextId = (DWORD) HELPID_EDIT_OPEN_FILE;
  1841.       break;
  1842.    case IDM_EDIT_SAVE_AS:
  1843.       dwHelpContextId = (DWORD) HELPID_EDIT_SAVE_AS;
  1844.       break;
  1845.    default:
  1846.       dwHelpContextId = (DWORD) HELPID_BUTTONS;
  1847.    }
  1848. }