Subversion Repositories Kolibri OS

/*

  Copyright (c) 1990-2003 Info-ZIP.  All rights reserved.

  See the accompanying file LICENSE, version 2000-Apr-09 or later

  (the contents of which are also included in unzip.h) for terms of use.

  If, for some reason, all these files are missing, the Info-ZIP license

  also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html

*/

//******************************************************************************

//

// File:        WINMAIN.CPP

//

// Description: This module contains all the Windows specific code for Pocket

//              UnZip.  It contains the entire user interface.  This code knows

//              almost nothing about the Info-ZIP code.  All Info-ZIP related

//              functions are wrapped by helper functions in INTRFACE.CPP.  The

//              code in this module only calls those wrapper functions and

//              INTRFACE.CPP handles all the details and callbacks of the

//              Info-ZIP code.

//

// Copyright:   All the source files for Pocket UnZip, except for components

//              written by the Info-ZIP group, are copyrighted 1997 by Steve P.

//              Miller.  The product "Pocket UnZip" itself is property of the

//              author and cannot be altered in any way without written consent

//              from Steve P. Miller.

//

// Disclaimer:  All project files are provided "as is" with no guarantee of

//              their correctness.  The authors are not liable for any outcome

//              that is the result of using this source.  The source for Pocket

//              UnZip has been placed in the public domain to help provide an

//              understanding of its implementation.  You are hereby granted

//              full permission to use this source in any way you wish, except

//              to alter Pocket UnZip itself.  For comments, suggestions, and

//              bug reports, please write to stevemil@pobox.com.

//

// Functions:   WinMain

//              InitializeApplication

//              ShutdownApplication

//              RegisterUnzip

//              BuildImageList

//              WndProc

//              OnCreate

//              OnFileOpen

//              OnActionView

//              OnActionSelectAll

//              OnViewExpandedView

//              OnHelp

//              OnGetDispInfo

//              OnDeleteItem

//              OnItemChanged

//              Sort

//              CompareFunc

//              SetCaptionText

//              DrawBanner

//              AddDeleteColumns

//              ResizeColumns

//              GetZipErrorString

//              AddFileToListView

//              EnableAllMenuItems

//              CheckAllMenuItems

//              CenterWindow

//              AddTextToEdit

//              FormatValue

//              BuildAttributesString

//              BuildTypeString

//              GetFileFromPath

//              ForwardSlashesToBackSlashesA

//              ForwardSlashesToBackSlashesW

//              DeleteDirectory(LPTSTR szPath);

//              RegWriteKey

//              RegReadKey

//              WriteOptionString

//              WriteOptionInt

//              GetOptionString

//              GetOptionInt

//              DisableEditing

//              EditSubclassProc

//              GetMenuString

//              InitializeMRU

//              AddFileToMRU

//              RemoveFileFromMRU

//              ActivateMRU

//              ReadZipFileList

//              DlgProcProperties

//              MergeValues

//              CheckThreeStateBox

//              ExtractOrTestFiles

//              DlgProcExtractOrTest

//              FolderBrowser

//              DlgProcBrowser

//              SubclassSaveAsDlg

//              DlgProcExtractProgress

//              DlgProcViewProgress

//              UpdateProgress

//              PromptToReplace

//              DlgProcReplace

//              DlgProcPassword

//              DlgProcViewAssociation

//              DlgProcComment

//              DlgProcAbout

//

//

// Date      Name          History

// --------  ------------  -----------------------------------------------------

// 02/01/97  Steve Miller  Created (Version 1.0 using Info-ZIP UnZip 5.30)

//

//******************************************************************************

extern "C" {

#define __WINMAIN_CPP__

#define UNZIP_INTERNAL

#include "unzip.h"

#include "crypt.h"     // Needed to pick up CRYPT define setting and return values.

#include "unzvers.h"   // Only needed by consts.h (VERSION_DATE & VersionDate)

#include "consts.h"    // Only include once - defines constant string messages.

#include   // Common controls - mainly ListView and ImageList

#include    // Common dialogs - OpenFile dialog

#ifndef _WIN32_WCE

#include     // On NT, we use the SHBrowseForFolder() stuff.

#include   // CommandLineToArgvW() and ExtractIconEx()

#endif

#include "intrface.h"  // Interface between Info-ZIP and us

#include "winmain.h"   // Us

}

#include      // Must be outside of extern "C" block

//******************************************************************************

//***** "Local" Global Variables

//******************************************************************************

static LPCTSTR         g_szAppName     = TEXT("Pocket UnZip");

static LPCTSTR         g_szClass       = TEXT("PocketUnZip");

static LPCTSTR         g_szRegKey      = TEXT("Software\\Pocket UnZip");

static LPCTSTR         g_szTempDir     = NULL;

static HWND            g_hWndList      = NULL;

static HWND            g_hWndCmdBar    = NULL;

static int             g_cyCmdBar      = 0;

static HFONT           g_hFontBanner   = NULL;

static HICON           g_hIconMain     = NULL;

static WNDPROC         g_wpSaveAsDlg   = NULL;

static WNDPROC         g_wpEdit        = NULL;

static int             g_sortColumn    = -1;

static BOOL            g_fExpandedView = FALSE;

static BOOL            g_fLoading      = FALSE;

static BOOL            g_fSkipped      = FALSE;

static BOOL            g_fViewing      = FALSE;

static HWND            g_hWndWaitFor   = NULL;

static FILE_TYPE_NODE *g_pftHead       = NULL;

#ifdef _WIN32_WCE

static LPCTSTR         g_szHelpFile    = TEXT("\\windows\\punzip.htp");

#else

static TCHAR           g_szTempDirPath[_MAX_PATH];

static LPCTSTR         g_szHelpFile    = TEXT("punzip.html");

#endif

static COLUMN g_columns[] = {

   { TEXT("Name"),       LVCFMT_LEFT  },

   { TEXT("Size"),       LVCFMT_RIGHT },

   { TEXT("Type"),       LVCFMT_LEFT  },

   { TEXT("Modified"),   LVCFMT_LEFT  },

   { TEXT("Attributes"), LVCFMT_LEFT  },

   { TEXT("Compressed"), LVCFMT_RIGHT },

   { TEXT("Ratio"),      LVCFMT_RIGHT },

   { TEXT("Method"),     LVCFMT_LEFT  },

   { TEXT("CRC"),        LVCFMT_LEFT  },

   { TEXT("Comment"),    LVCFMT_LEFT  }

};

//******************************************************************************

//***** Local Function Prototypes

//******************************************************************************

// Startup and Shutdown Functions

void InitializeApplication(LPCTSTR szZipFile);

void ShutdownApplication();

void RegisterUnzip();

void BuildImageList();

// Our Main Window's Message Handler

LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

// Event Handlers for our Main Window

int OnCreate();

void OnFileOpen();

void OnActionView();

void OnActionSelectAll();

void OnViewExpandedView();

void OnHelp();

// Event Handlers for our List View

void OnGetDispInfo(LV_DISPINFO *plvdi);

void OnDeleteItem(NM_LISTVIEW *pnmlv);

void OnItemChanged(NM_LISTVIEW *pnmlv);

// List View Sort Functions

void Sort(int sortColumn, BOOL fForce);

int CALLBACK CompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM sortColumn);

// Helper/Utility Functions

void SetCaptionText(LPCTSTR szPrefix);

void DrawBanner(HDC hdc);

void AddDeleteColumns();

void ResizeColumns();

LPCTSTR GetZipErrorString(int error);

void AddFileToListView(FILE_NODE *pFile);

void EnableAllMenuItems(UINT uMenuItem, BOOL fEnabled);

void CheckAllMenuItems(UINT uMenuItem, BOOL fChecked);

void CenterWindow(HWND hWnd);

void AddTextToEdit(LPCSTR szText);

LPTSTR FormatValue(LPTSTR szValue, zusz_t uzValue);

LPTSTR BuildAttributesString(LPTSTR szBuffer, DWORD dwAttributes);

LPCSTR BuildTypeString(FILE_NODE *pFile, LPSTR szType);

LPCSTR GetFileFromPath(LPCSTR szPath);

void ForwardSlashesToBackSlashesA(LPSTR szBuffer);

#ifdef UNICODE

   void ForwardSlashesToBackSlashesW(LPWSTR szBuffer);

#  define ForwardSlashesToBackSlashes ForwardSlashesToBackSlashesW

#else

#  define ForwardSlashesToBackSlashes ForwardSlashesToBackSlashesA

#endif

void DeleteDirectory(LPTSTR szPath);

// Registry Functions

void RegWriteKey(HKEY hKeyRoot, LPCTSTR szSubKey, LPCTSTR szValue);

BOOL RegReadKey(HKEY hKeyRoot, LPCTSTR szSubKey, LPTSTR szValue, DWORD cBytes);

void WriteOptionString(LPCTSTR szOption, LPCTSTR szValue);

void WriteOptionInt(LPCTSTR szOption, DWORD dwValue);

LPTSTR GetOptionString(LPCTSTR szOption, LPCTSTR szDefault, LPTSTR szValue, DWORD nSize);

DWORD GetOptionInt(LPCTSTR szOption, DWORD dwDefault);

// EDIT Control Subclass Functions

void DisableEditing(HWND hWndEdit);

LRESULT CALLBACK EditSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

// MRU Functions

void InitializeMRU();

void AddFileToMRU(LPCSTR szFile);

void RemoveFileFromMRU(LPCTSTR szFile);

void ActivateMRU(UINT uIDItem);

// Open Zip File Functions

void ReadZipFileList(LPCTSTR wszPath);

// Zip File Properties Dialog Functions

BOOL CALLBACK DlgProcProperties(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

void MergeValues(int *p1, int p2);

void CheckThreeStateBox(HWND hDlg, int nIDButton, int state);

// Extract/Test Dialog Functions

void ExtractOrTestFiles(BOOL fExtract);

BOOL CALLBACK DlgProcExtractOrTest(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

// Folder Browsing Dialog Functions

BOOL FolderBrowser(LPTSTR szPath, DWORD dwLength);

BOOL CALLBACK DlgProcBrowser(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

void SubclassSaveAsDlg();

// Extraction/Test/View Progress Dialog Functions

BOOL CALLBACK DlgProcExtractProgress(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

BOOL CALLBACK DlgProcViewProgress(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

void UpdateProgress(EXTRACT_INFO *pei, BOOL fFull);

// Replace File Dialog Functions

int PromptToReplace(LPCSTR szPath);

BOOL CALLBACK DlgProcReplace(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

// Password Dialog Functions

BOOL CALLBACK DlgProcPassword(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

// View Association Dialog Functions

BOOL CALLBACK DlgProcViewAssociation(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

// Comment Dialog Functions

BOOL CALLBACK DlgProcComment(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

// About Dialog Functions

BOOL CALLBACK DlgProcAbout(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

//******************************************************************************

//***** WinMain - Our one and only entry point

//******************************************************************************

// Entrypoint is a tiny bit different on Windows CE - UNICODE command line.

#ifdef _WIN32_WCE

extern "C" int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,

                              LPTSTR lpCmdLine, int nCmdShow)

#else

extern "C" int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,

                              LPSTR lpCmdLine, int nCmdShow)

#endif

{

   // Wrap the whole ball of wax in a big exception handler.

   __try {

      // Store global instance handle.

      g_hInst = hInstance;

      // Create our banner font.  We need to do this before creating our window.

      // This font handle will be deleted in ShutdownApplication().

      LOGFONT lf;

      ZeroMemory(&lf, sizeof(lf));

      lf.lfHeight = 16;

      lf.lfWeight = FW_BOLD;

      lf.lfCharSet = ANSI_CHARSET;

      lf.lfOutPrecision = OUT_DEFAULT_PRECIS;

      lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;

      lf.lfQuality = DEFAULT_QUALITY;

      lf.lfPitchAndFamily = DEFAULT_PITCH | FF_SWISS;

      _tcscpy(lf.lfFaceName, TEXT("MS Sans Serif"));

      g_hFontBanner = CreateFontIndirect(&lf);

      // Define the window class for our application's main window.

      WNDCLASS wc;

      ZeroMemory(&wc, sizeof(wc));

      wc.lpszClassName = g_szClass;

      wc.hInstance     = hInstance;

      wc.lpfnWndProc   = WndProc;

      wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);

      TCHAR *szZipPath = NULL;

#ifdef _WIN32_WCE

      // Get our main window's small icon.  On Windows CE, we need to send ourself

      // a WM_SETICON in order for our task bar to update itself.

      g_hIconMain = (HICON)LoadImage(hInstance, MAKEINTRESOURCE(IDI_UNZIP),

                                     IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);

      wc.hIcon = g_hIconMain;

      // On Windows CE, we only need the WS_VISIBLE flag.

      DWORD dwStyle = WS_VISIBLE;

      // Get and store command line file (if any).

      if (lpCmdLine && *lpCmdLine) {

         szZipPath = lpCmdLine;

      }

#else

      // On NT we add a cursor, icon, and menu to our application's window class.

      wc.hCursor      = LoadCursor(NULL, IDC_ARROW);

      wc.hIcon        = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_UNZIP));

      wc.lpszMenuName = MAKEINTRESOURCE(IDR_UNZIP);

      // On Windows NT, we use the standard overlapped window style.

      DWORD dwStyle = WS_OVERLAPPEDWINDOW;

      TCHAR szBuffer[_MAX_PATH];

      // Get and store command line file (if any).

      if (lpCmdLine && *lpCmdLine) {

         MBSTOTSTR(szBuffer, lpCmdLine, countof(szBuffer));

         szZipPath = szBuffer;

      }

#endif

      // Register our window class with the OS.

      if (!RegisterClass(&wc)) {

         DebugOut(TEXT("RegisterClass() failed [%u]"), GetLastError());

      }

      // Create our main window using our registered window class.

      g_hWndMain = CreateWindow(wc.lpszClassName, g_szAppName, dwStyle,

                                CW_USEDEFAULT, CW_USEDEFAULT,

                                CW_USEDEFAULT, CW_USEDEFAULT,

                                NULL, NULL, hInstance, NULL);

      // Quit now if we failed to create our main window.

      if (!g_hWndMain) {

         DebugOut(TEXT("CreateWindow() failed [%u]"), GetLastError());

         ShutdownApplication();

         return 0;

      }

      // Make sure our window is visible.  Really only needed for NT.

      ShowWindow(g_hWndMain, nCmdShow);

      // Load our keyboard accelerator shortcuts.

      MSG    msg;

      HACCEL hAccel = LoadAccelerators(g_hInst, MAKEINTRESOURCE(IDR_UNZIP));

      DWORD  dwPaintFlags = 0;

      // The message pump.  Loop until we get a WM_QUIT message.

      while (GetMessage(&msg, NULL, 0, 0)) {

         // Check to see if this is an accelerator and handle it if neccessary.

         if (!TranslateAccelerator(g_hWndMain, hAccel, &msg)) {

            // If a normal message, then dispatch it to the correct window.

            TranslateMessage(&msg);

            DispatchMessage(&msg);

            // Wait until our application is up and visible before trying to

            // initialize some of our structures and load any command line file.

            if ((msg.message == WM_PAINT) && (dwPaintFlags != 0x11)) {

               if (msg.hwnd == g_hWndWaitFor) {

                  dwPaintFlags |= 0x01;

               } else if (msg.hwnd == g_hWndList) {

                  dwPaintFlags |= 0x10;

               }

               if (dwPaintFlags == 0x11) {

                  InitializeApplication((szZipPath && *szZipPath) ?

                                        szZipPath : NULL);

               }

            }

         }

      }

      // Clean up code.

      ShutdownApplication();

      // Nice clean finish - were out of here.

      return msg.wParam;

   } __except(EXCEPTION_EXECUTE_HANDLER) {

      // Something very bad happened.  Try our best to appear somewhat graceful.

      MessageBox(NULL,

         TEXT("An internal error occurred.  Possible causes are that you are ")

         TEXT("out of memory, a ZIP file (if one is loaded) contains an ")

         TEXT("unexpected error, or there is a bug in our program (that's why ")

         TEXT("it's free).  Pocket UnZip cannot continue.  It will exit now, ")

         TEXT("but you may restart it and try again.\n\n")

         TEXT("If the problem persists, please write to stevemil@pobox.com with ")

         TEXT("any information that might help track down the problem."),

         g_szAppName, MB_ICONERROR | MB_OK);

   }

   return 1;

}

//******************************************************************************

//***** Startup and Shutdown Functions

//******************************************************************************

void InitializeApplication(LPCTSTR szZipFile) {

   // This function is called after our class is registered and all our windows

   // are created and visible to the user.

   // Show hour glass cursor.

   HCURSOR hCur = SetCursor(LoadCursor(NULL, IDC_WAIT));

   // Register UnZip in the registry to handle ".ZIP" files.

   RegisterUnzip();

   // Enumerate the system file assoications and build an image list.

   BuildImageList();

   // Load our initial MRU into our menu.

   InitializeMRU();

   // Restore/remove our cursor.

   SetCursor(hCur);

   // Clear our initialization window handle.

   g_hWndWaitFor = NULL;

   // Load our command line file if one was specified. Otherwise, just update

   // our banner to show that no file is loaded.

   if (szZipFile) {

      ReadZipFileList(szZipFile);

   } else {

      DrawBanner(NULL);

   }

   // Enable some controls.

   EnableAllMenuItems(IDM_FILE_OPEN,          TRUE);

   EnableAllMenuItems(IDM_FILE_CLOSE,         TRUE);

   EnableAllMenuItems(IDM_VIEW_EXPANDED_VIEW, TRUE);

   EnableAllMenuItems(IDM_HELP_ABOUT,         TRUE);

   // Set our temporary directory.

#ifdef _WIN32_WCE

   g_szTempDir = TEXT("\\Temporary Pocket UnZip Files");

#else

   g_szTempDir = TEXT("C:\\Temporary Pocket UnZip Files");

   // Set the drive to be the same drive as the OS installation is on.

   if (GetWindowsDirectory(g_szTempDirPath, countof(g_szTempDirPath))) {

      lstrcpy(g_szTempDirPath + 3, TEXT("Temporary Pocket UnZip Files"));

      g_szTempDir  = g_szTempDirPath;

   }

#endif

}

//******************************************************************************

void ShutdownApplication() {

   // Free our banner font.

   if (g_hFontBanner) {

      DeleteObject(g_hFontBanner);

      g_hFontBanner = NULL;

   }

   // Delete our FILE_TYPE_NODE linked list.

   for (FILE_TYPE_NODE *pft = g_pftHead; pft; ) {

      FILE_TYPE_NODE *pftNext = pft->pNext;

      delete[] (BYTE*)pft;

      pft = pftNext;

   }

   g_pftHead = NULL;

   // If there are no other instances of our application open, then delete our

   // temporary directory and all the files in it.  Any files opened for viewing

   // should be locked and will fail to delete.  This is to be expected.

   if (g_szTempDir && (FindWindow(g_szClass, NULL) == NULL)) {

      TCHAR szPath[_MAX_PATH];

      _tcscpy(szPath, g_szTempDir);

      DeleteDirectory(szPath);

   }

}

//******************************************************************************

void RegisterUnzip() {

#ifdef _WIN32_WCE

   // WARNING!  Since Windows CE does not support any way to get your binary's

   // name at runtime, we have to hard-code in "punzip.exe".  If our binary is

   // not named this or is in a non-path directory, then we will fail to

   // register ourself with the system as the default application to handle

   // ".zip" files.

   TCHAR szPath[32] = TEXT("punzip.exe");

   TCHAR szTstPath[32];

#else

   // Get our module's path and file name.  We use the short path name for the

   // registry because it is guaranteed to contain no spaces.

   TCHAR szLongPath[_MAX_PATH];

   TCHAR szPath[_MAX_PATH];

   TCHAR szTstPath[_MAX_PATH];

   GetModuleFileName(NULL, szLongPath, countof(szLongPath));

   GetShortPathName(szLongPath, szPath, countof(szPath));

#endif

   // Store a pointer to the end of our path for easy appending.

   LPTSTR szEnd = szPath + _tcslen(szPath);

   BOOL fDoRegisterPUnZip = TRUE;

   // Associate "ZIP" file extensions to our application

   if (RegReadKey(HKEY_CLASSES_ROOT, TEXT(".zip"), szTstPath, sizeof(szTstPath)))

   {

      if (_tcscmp(szTstPath, TEXT("zipfile")) != 0)

         fDoRegisterPUnZip = FALSE;

      else if (RegReadKey(HKEY_CLASSES_ROOT, TEXT("zipfile\\shell\\Open\\command"),

                          szTstPath, sizeof(szTstPath)) &&

               (_tcsncmp(szTstPath, szPath, _tcslen(szPath)) != 0))

         fDoRegisterPUnZip = FALSE;

      if (!fDoRegisterPUnZip)

      {

         fDoRegisterPUnZip =

            (IDOK == MessageBox(g_hWndMain,

                                TEXT("Currently, Pocket UnZip is not registered as default ")

                                TEXT("handler for Zip archives.\n\n")

                                TEXT("Please, confirm that Pocket UnZip should now register itself ")

                                TEXT("as default application for handling Zip archives (.zip files)"),

                                g_szAppName,

                                MB_ICONQUESTION | MB_OKCANCEL));

      }

   }

   if (fDoRegisterPUnZip) {

      RegWriteKey(HKEY_CLASSES_ROOT, TEXT(".zip"), TEXT("zipfile"));

      RegWriteKey(HKEY_CLASSES_ROOT, TEXT("zipfile"), TEXT("ZIP File"));

      RegWriteKey(HKEY_CLASSES_ROOT, TEXT("zipfile\\shell"), NULL);

      RegWriteKey(HKEY_CLASSES_ROOT, TEXT("zipfile\\shell\\Open"), NULL);

      _tcscpy(szEnd, TEXT(" %1"));

      RegWriteKey(HKEY_CLASSES_ROOT, TEXT("zipfile\\shell\\Open\\command"), szPath);

      // Register our program icon for all ZIP files.

      _stprintf(szEnd, TEXT(",-%u"), IDI_ZIPFILE);

      RegWriteKey(HKEY_CLASSES_ROOT, TEXT("zipfile\\DefaultIcon"), szPath);

   }

   // Create our application option location.

   RegWriteKey(HKEY_CURRENT_USER, TEXT("Software"), NULL);

   RegWriteKey(HKEY_CURRENT_USER, g_szRegKey, NULL);

}

//******************************************************************************

void BuildImageList() {

   // Create our global image list.

#ifdef _WIN32_WCE

   // On Windows CE, we can't spare a color for the mask, so we have to create

   // the mask in a separate monochrome bitmap.

   HIMAGELIST hil = ImageList_Create(16, 16, ILC_COLOR | ILC_MASK, 8, 8);

   // Load our default bitmaps into the image list.

   HBITMAP hBmpImageList = LoadBitmap(g_hInst, MAKEINTRESOURCE(IDB_IMAGELIST));

   HBITMAP hBmpMask = LoadBitmap(g_hInst, MAKEINTRESOURCE(IDB_IMAGELIST_MASK));

   ImageList_Add(hil, hBmpImageList, hBmpMask);

   DeleteObject(hBmpImageList);

   DeleteObject(hBmpMask);

#else

   // On Windows NT, we use magenta as a transparency mask color.

   HIMAGELIST hil = ImageList_LoadBitmap(g_hInst, MAKEINTRESOURCE(IDB_IMAGELIST),

                                         16, 8, RGB(255, 0, 255));

#endif

   // Set up for our registry file type enumeration.

   FILE_TYPE_NODE *pftLast = NULL;

   TCHAR szExtension[128], szKey[128], szDescription[_MAX_PATH], szIconFile[_MAX_PATH + 16];

   DWORD dwIndex = 0, dwCount = countof(szExtension);

   // Enumerate all the keys immediately under HKEY_CLASSES_ROOT.

   while (ERROR_SUCCESS == RegEnumKeyEx(HKEY_CLASSES_ROOT, dwIndex++, szExtension,

                                        &dwCount, NULL, NULL, NULL, NULL))

   {

      dwCount = countof(szExtension);

      // Check to see if we read an extension key (starts with a period)

      if (*szExtension != TEXT('.')) {

         continue;

      }

      // Read the actual key name for this extension.

      if (!RegReadKey(HKEY_CLASSES_ROOT, szExtension, szKey, sizeof(szKey))) {

         continue;

      }

      // Read the Description for this extension.

      RegReadKey(HKEY_CLASSES_ROOT, szKey, szDescription, sizeof(szDescription));

      HICON hIcon = NULL;

      LPTSTR szEnd = szKey + _tcslen(szKey);

      // Attempt to get an icon for this extension from the "DefaultIcon" key.

      _tcscpy(szEnd, TEXT("\\DefaultIcon"));

      if (RegReadKey(HKEY_CLASSES_ROOT, szKey, szIconFile, sizeof(szIconFile))) {

         // Look for the comma between the file name and the image.

         LPTSTR szImageId = _tcschr(szIconFile, TEXT(','));

         if (szImageId) {

            // NULL terminate the file name portion of szIconFile.

            *(szImageId++) = TEXT('\0');

            // Get the image ID value from szIconFile.

            int imageId = _ttoi(szImageId);

            // Extract the icon from the module specified in szIconFile.

            ExtractIconEx(szIconFile, imageId, NULL, &hIcon, 1);

            if (hIcon == NULL) {

               ExtractIconEx(szIconFile, imageId, &hIcon, NULL, 1);

            }

         }

      }

      // If we failed to get the icon using the "DefaultIcon" key, then try

      // using the "shell\Open\command" key.

      if (hIcon == NULL) {

         _tcscpy(szEnd, TEXT("\\shell\\Open\\command"));

         if (RegReadKey(HKEY_CLASSES_ROOT, szKey, szIconFile, sizeof(szIconFile))) {

            // Get a pointer to just the binary - strip quotes and spaces.

            LPTSTR szPath;

            if (*szIconFile == TEXT('\"')) {

               szPath = szIconFile + 1;

               if (szEnd = _tcschr(szPath, TEXT('\"'))) {

                  *szEnd = TEXT('\0');

               }

            } else {

               szPath = szIconFile;

               if (szEnd = _tcschr(szPath, TEXT(' '))) {

                  *szEnd = TEXT('\0');

               }

            }

            // Extract the icon from the module specified in szIconFile.

            ExtractIconEx(szPath, 0, NULL, &hIcon, 1);

            if (hIcon == NULL) {

               ExtractIconEx(szPath, 0, &hIcon, NULL, 1);

            }

         }

      }

      // If we found an icon, add it to our image list.

      int image = -1;

      if (hIcon) {

         image = ImageList_AddIcon(hil, hIcon);

      }

      // If no icon could be found, then check to see if this is an executable.

      if ((image == -1) && (

#ifndef _WIN32_WCE // Windows CE only recognizes EXE's as executable.

         !_tcsicmp(szExtension + 1, TEXT("bat")) ||

         !_tcsicmp(szExtension + 1, TEXT("cmd")) ||

         !_tcsicmp(szExtension + 1, TEXT("com")) ||

#endif

         !_tcsicmp(szExtension + 1, TEXT("exe"))))

      {

         image = IMAGE_APPLICATION;

      }

      // If we don't have a description or a icon, then bail on this extension.

      if (!*szDescription && (image < 0)) {

         continue;

      }

      // Create our FILE_TYPE_NODE.

      size_t length = _tcslen(szExtension) - 1 + _tcslen(szDescription);

      FILE_TYPE_NODE *pft = (FILE_TYPE_NODE*) new BYTE[

         sizeof(FILE_TYPE_NODE) + (sizeof(TCHAR) * length)];

      // Bail out if we could not create our node.

      if (!pft) {

         DebugOut(TEXT("Not enough memory to create a FILE_TYPE_NODE."));

         continue;

      }

      // Fill in the node.

      pft->pNext = NULL;

      pft->image = (image >= 0) ? image : IMAGE_GENERIC;

      TSTRTOMBS(pft->szExtAndDesc, szExtension + 1, length + 2);

      size_t sizext = (strlen(pft->szExtAndDesc) + 1);

      TSTRTOMBS(pft->szExtAndDesc + sizext,

                szDescription, length - sizext + 2);

      // Add the node to our list.

      if (pftLast) {

         pftLast->pNext = pft;

      } else {

         g_pftHead = pft;

      }

      pftLast = pft;

   }

   // Assign this image list to our tree control.

   ListView_SetImageList(g_hWndList, hil, LVSIL_SMALL);

}

//******************************************************************************

//***** Our Main Window's Message Handler

//******************************************************************************

LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {

   switch(uMsg) {

      case WM_CREATE:

         g_hWndMain = hWnd;

         return OnCreate();

      case WM_ERASEBKGND:

         DrawBanner((HDC)wParam);

         return 0;

      case WM_SIZE:

         // Resize our list view control to match our client area.

         MoveWindow(g_hWndList, 0, g_cyCmdBar + 22, LOWORD(lParam),

                    HIWORD(lParam) - (g_cyCmdBar + 22), TRUE);

#ifndef _WIN32_WCE

         // On NT we have to resize our toolbar as well.

         MoveWindow(g_hWndCmdBar, 0, 0, LOWORD(lParam), g_cyCmdBar, TRUE);

#endif

         return 0;

      case WM_SETFOCUS:

         // Always direct focus to our list control.

         SetFocus(g_hWndList);

         return 0;

      case WM_DESTROY:

         PostQuitMessage(0);

         return 0;

      case WM_HELP:

         OnHelp();

         return 0;

      case WM_PRIVATE:

         switch (wParam) {

#ifdef _WIN32_WCE

            case MSG_SUBCLASS_DIALOG:

               SubclassSaveAsDlg();

               return 0;

#endif

            case MSG_ADD_TEXT_TO_EDIT:

               AddTextToEdit((LPCSTR)lParam);

               return 0;

            case MSG_PROMPT_TO_REPLACE:

               return PromptToReplace((LPCSTR)lParam);

#if CRYPT

            case MSG_PROMPT_FOR_PASSWORD:

               return DialogBoxParam(g_hInst, MAKEINTRESOURCE(IDD_PASSWORD),

                                     g_hDlgProgress, (DLGPROC)DlgProcPassword,

                                     lParam);

#endif

            case MSG_UPDATE_PROGRESS_PARTIAL:

               UpdateProgress((EXTRACT_INFO*)lParam, FALSE);

               return 0;

            case MSG_UPDATE_PROGRESS_COMPLETE:

               UpdateProgress((EXTRACT_INFO*)lParam, TRUE);

               return 0;

         }

         return 0;

      case WM_NOTIFY:

         switch (((LPNMHDR)lParam)->code) {

            case LVN_GETDISPINFO:

               OnGetDispInfo((LV_DISPINFO*)lParam);

               return 0;

            case LVN_DELETEITEM:

               OnDeleteItem((NM_LISTVIEW*)lParam);

               return 0;

            case LVN_COLUMNCLICK:

               Sort(((NM_LISTVIEW*)lParam)->iSubItem, FALSE);

               return 0;

            case LVN_ITEMCHANGED:

               OnItemChanged((NM_LISTVIEW*)lParam);

               return 0;

            case NM_DBLCLK:

            case NM_RETURN:

               OnActionView();

               return 0;

         }

         return 0;

      case WM_COMMAND:

         switch (LOWORD(wParam)) {

            case IDM_FILE_OPEN:

               OnFileOpen();

               return 0;

            case IDM_FILE_PROPERTIES:

               DialogBox(g_hInst, MAKEINTRESOURCE(IDD_PROPERTIES), hWnd, (DLGPROC)DlgProcProperties);

               return 0;

            case IDM_FILE_CLOSE:

               SendMessage(hWnd, WM_CLOSE, 0, 0);

               return 0;

            case IDM_ACTION_EXTRACT_ALL:

               OnActionSelectAll();

               // Fall through to IDM_ACTION_EXTRACT

            case IDM_ACTION_EXTRACT:

               ExtractOrTestFiles(TRUE);

               return 0;

            case IDM_ACTION_TEST_ALL:

               OnActionSelectAll();

               // Fall through to IDM_ACTION_TEST

            case IDM_ACTION_TEST:

               ExtractOrTestFiles(FALSE);

               return 0;

            case IDM_ACTION_VIEW:

               OnActionView();

               return 0;

            case IDM_ACTION_SELECT_ALL:

               OnActionSelectAll();

               return 0;

            case IDM_VIEW_EXPANDED_VIEW:

               OnViewExpandedView();

               return 0;

            case IDM_VIEW_COMMENT:

               DialogBox(g_hInst, MAKEINTRESOURCE(IDD_COMMENT), hWnd, (DLGPROC)DlgProcComment);

               return 0;

            case IDM_HELP_ABOUT:

               DialogBox(g_hInst, MAKEINTRESOURCE(IDD_ABOUT), hWnd, (DLGPROC)DlgProcAbout);

               return 0;

            case IDHELP:

               return SendMessage(hWnd, WM_HELP, 0, 0);

            default:

               // Check to see if a MRU file was selected.

               if ((LOWORD(wParam) >= MRU_START_ID) &&

                   (LOWORD(wParam) < (MRU_START_ID + MRU_MAX_FILE)))

               {

                  ActivateMRU(LOWORD(wParam));

               }

         }

    }

    return DefWindowProc(hWnd, uMsg, wParam, lParam);

}

//******************************************************************************

//***** Event Handlers for our Main Window

//******************************************************************************

int OnCreate() {

   // Our toolbar buttons.

   static TBBUTTON tbButton[] = {

      { 0, 0,                      0, TBSTYLE_SEP,    0, 0, 0, -1 },

      { 0, IDM_FILE_OPEN,          0, TBSTYLE_BUTTON, 0, 0, 0, -1 },

      { 0, 0,                      0, TBSTYLE_SEP,    0, 0, 0, -1 },

      { 1, IDM_FILE_PROPERTIES,    0, TBSTYLE_BUTTON, 0, 0, 0, -1 },

      { 0, 0,                      0, TBSTYLE_SEP,    0, 0, 0, -1 },

      { 2, IDM_ACTION_EXTRACT,     0, TBSTYLE_BUTTON, 0, 0, 0, -1 },

      { 3, IDM_ACTION_EXTRACT_ALL, 0, TBSTYLE_BUTTON, 0, 0, 0, -1 },

      { 0, 0,                      0, TBSTYLE_SEP,    0, 0, 0, -1 },

      { 4, IDM_ACTION_TEST,        0, TBSTYLE_BUTTON, 0, 0, 0, -1 },

      { 5, IDM_ACTION_TEST_ALL,    0, TBSTYLE_BUTTON, 0, 0, 0, -1 },

      { 0, 0,                      0, TBSTYLE_SEP,    0, 0, 0, -1 },

      { 6, IDM_ACTION_VIEW,        0, TBSTYLE_BUTTON, 0, 0, 0, -1 },

      { 0, 0,                      0, TBSTYLE_SEP,    0, 0, 0, -1 },

      { 7, IDM_VIEW_EXPANDED_VIEW, 0, TBSTYLE_BUTTON, 0, 0, 0, -1 },

      { 8, IDM_VIEW_COMMENT,       0, TBSTYLE_BUTTON, 0, 0, 0, -1 }

   };

   // Our toolbar buttons' tool tip text.

   static LPTSTR szToolTips[] = {

       TEXT(""),  // Menu

       TEXT("Open (Ctrl+O)"),

       TEXT("Properties (Alt+Enter)"),

       TEXT("Extract Selected Files"),

       TEXT("Extract All Files"),

       TEXT("Test Selected Files"),

       TEXT("Test All Files"),

       TEXT("View Selected File"),

       TEXT("Expanded View"),

       TEXT("View Zip File Comment")

   };

   // Initialize the common controls.

   InitCommonControls();

   // Check to see if we have a help file.

   BOOL fHelp = (GetFileAttributes(g_szHelpFile) != 0xFFFFFFFF);

   // Set our window's icon so it can update the task bar.

   if (g_hIconMain) {

      SendMessage(g_hWndMain, WM_SETICON, FALSE, (LPARAM)g_hIconMain);

   }

   // Create the tree control.  Our main window will resize it to fit.

   g_hWndList = CreateWindow(WC_LISTVIEW, TEXT(""),

                             WS_VSCROLL | WS_CHILD | WS_VISIBLE |

                             LVS_REPORT | LVS_SHOWSELALWAYS,

                             0, 0, 0, 0, g_hWndMain, NULL, g_hInst, NULL);

#ifdef _WIN32_WCE

   // Create a command bar and add the toolbar bitmaps to it.

   g_hWndCmdBar = CommandBar_Create(g_hInst, g_hWndMain, 1);

   CommandBar_AddBitmap(g_hWndCmdBar, g_hInst, IDB_TOOLBAR, 9, 16, 16);

   CommandBar_InsertMenubar(g_hWndCmdBar, g_hInst, IDR_UNZIP, 0);

   CommandBar_AddButtons(g_hWndCmdBar, countof(tbButton), tbButton);

   CommandBar_AddAdornments(g_hWndCmdBar, fHelp ? CMDBAR_HELP : 0, 0);

   // Add tool tips to the tool bar.

   CommandBar_AddToolTips(g_hWndCmdBar, countof(szToolTips), szToolTips);

   // Store the height of the command bar for later calculations.

   g_cyCmdBar = CommandBar_Height(g_hWndCmdBar);

   // We set our wait window handle to our menu window within our command bar.

   // This is the last window that will be painted during startup of our app.

   g_hWndWaitFor = GetWindow(g_hWndCmdBar, GW_CHILD);

   // Add the help item to our help menu if we have a help file.

   if (fHelp) {

      HMENU hMenu = GetSubMenu(CommandBar_GetMenu(g_hWndCmdBar, 0), 3);

      InsertMenu(hMenu, 0, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);

      InsertMenu(hMenu, 0, MF_BYPOSITION | MF_ENABLED, IDHELP, TEXT("&Help"));

   }

#else

   // Create a tool bar and add the toolbar bitmaps to it.

   g_hWndCmdBar = CreateToolbarEx(g_hWndMain, WS_CHILD | WS_VISIBLE | TBSTYLE_TOOLTIPS,

                                  1, 9, g_hInst, IDB_TOOLBAR, tbButton,

                                  countof(tbButton), 16, 16, 16, 16,

                                  sizeof(TBBUTTON));

   // Get our tool tip control.

   HWND hWndTT = (HWND)SendMessage(g_hWndCmdBar, TB_GETTOOLTIPS, 0, 0);

   // Set our tool tip strings.

   TOOLINFO ti;

   ti.cbSize = sizeof(ti);

   int tip = 0, button;

   while (SendMessage(hWndTT, TTM_ENUMTOOLS, tip++, (LPARAM)&ti)) {

      for (button = 0; button < countof(tbButton); button++) {

         if (tbButton[button].idCommand == (int)ti.uId) {

            ti.lpszText = szToolTips[tbButton[button].iBitmap + 1];

            SendMessage(hWndTT, TTM_UPDATETIPTEXT, 0, (LPARAM)&ti);

            break;

         }

      }

   }

   // Store the height of the tool bar for later calculations.

   RECT rc;

   GetWindowRect(g_hWndCmdBar, &rc);

   g_cyCmdBar = rc.bottom - rc.top;

   // We set our wait window handle to our toolbar.

   // This is the last window that will be painted during the startup of our app.

   g_hWndWaitFor = g_hWndCmdBar;

   // Add the help item to our help menu if we have a help file.

   if (fHelp) {

      HMENU hMenu = GetSubMenu(GetMenu(g_hWndMain), 3);

      InsertMenu(hMenu, 0, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);

      InsertMenu(hMenu, 0, MF_BYPOSITION | MF_ENABLED, IDHELP, TEXT("&Help\tF1"));

   }

#endif // _WIN32_WCE

   // Enable Full Row Select - This feature is supported on Windows CE and was

   // introduced to Win95/NT with IE 3.0.  If the user does not have a

   // COMCTL32.DLL that supports this feature, then they will just see the

   // old standard First Column Select.

   SendMessage(g_hWndList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT |

               SendMessage(g_hWndList, LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0));

   // Get our expanded view option from the registry.

   g_fExpandedView = GetOptionInt(TEXT("ExpandedView"), FALSE);

   // Show or remove menu check for expanded view option.

   CheckAllMenuItems(IDM_VIEW_EXPANDED_VIEW, g_fExpandedView);

   // Create our columns.

   AddDeleteColumns();

   // Set our current sort column to our name column

   Sort(0, TRUE);

   return 0;

}

//******************************************************************************

void OnFileOpen() {

   TCHAR szPath[_MAX_PATH] = TEXT("");

   OPENFILENAME ofn;

   ZeroMemory(&ofn, sizeof(ofn));

   ofn.lStructSize  = sizeof(ofn);

   ofn.hwndOwner    = g_hWndMain;

   ofn.hInstance    = g_hInst;

   ofn.lpstrFilter  = TEXT("ZIP files (*.zip)\0*.zip\0SFX files (*.exe)\0*.exe\0All Files (*.*)\0*.*\0");

   ofn.nFilterIndex = 1;

   ofn.lpstrFile    = szPath;

   ofn.nMaxFile     = countof(szPath);

   ofn.Flags        = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST;

   ofn.lpstrDefExt  = TEXT("zip");

   if (GetOpenFileName(&ofn)) {

      ReadZipFileList(szPath);

   }

}

//******************************************************************************

void OnActionView() {

   // We only allow a view if one item is selected.

   int count = ListView_GetSelectedCount(g_hWndList);

   if (count != 1) {

      return;

   }

   // Query the selected item for its FILE_NODE.

   LV_ITEM lvi;

   ZeroMemory(&lvi, sizeof(lvi));

   lvi.mask = LVIF_IMAGE | LVIF_PARAM;

   lvi.iItem = ListView_GetNextItem(g_hWndList, -1, LVNI_SELECTED);

   ListView_GetItem(g_hWndList, &lvi);

   FILE_NODE *pfn = (FILE_NODE*)lvi.lParam;

   // Bail out if the selected item is a folder or volume label.

   if (pfn->dwAttributes & (FILE_ATTRIBUTE_DIRECTORY | ZFILE_ATTRIBUTE_VOLUME)) {

      MessageBox(g_hWndMain, TEXT("You cannot view folders or volume labels."),

                 g_szAppName, MB_ICONINFORMATION | MB_OK);

      return;

   }

   // Make sure our temporary directory exists.

   CreateDirectory(g_szTempDir, NULL);

   TCHAR szPath[_MAX_PATH + 256];

   // Set our extraction directory to our temporary directory.

   if (!SetExtractToDirectory((LPTSTR)g_szTempDir)) {

      // Create error message.  Use szPath buffer because it is handy.

      _stprintf(szPath,

         TEXT("Could not create \"%s\"\n\n")

         TEXT("Most likely cause is that your drive is full."),

         g_szTempDir);

      // Display error message.

      MessageBox(g_hWndMain, szPath, g_szAppName, MB_ICONERROR | MB_OK);