472 lines
16 KiB
C
Executable File
472 lines
16 KiB
C
Executable File
/*
|
|
* EX04WIN.C
|
|
*
|
|
* C/Windows Example program for ArchiveLib 2.0
|
|
*
|
|
* Copyright (c) Greenleaf Software, Inc. 1994 - 1996
|
|
* All Rights Reserved
|
|
*
|
|
* MEMBERS/FUNCTIONS DEMONSTRATED
|
|
*
|
|
* deleteALStorage()
|
|
* ALStorageCompare()
|
|
* ALStorageDelete()
|
|
* ALStorageGetStatusCode()
|
|
* newALFile()
|
|
* newALMemory()
|
|
* ALArchiveExtract()
|
|
* newALArchiveFromStorage()
|
|
* ALEntrySetStorage()
|
|
* ALStorageSetMonitor()
|
|
* ALMonitorSetObjectSize()
|
|
* ALMonitorSetObjectStart()
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* EX04WIN.C demonstrates newALMemory(). It lets you
|
|
* compress selected input files to a memory archive. It then turns around
|
|
* and decompresses the objects to a new memory files, then compares the
|
|
* contents of the two.
|
|
*
|
|
* This is a very simple Windows program. It works by creating a modeless
|
|
* dialog box, then wrapping a framing window around it. By using a framing
|
|
* window as the main window we are able to handle accelerator keys, menus,
|
|
* and icons a bit easier. Because of this approach, WinMain() and
|
|
* MainWndProc() are not very exciting, and have been moved down to the
|
|
* bottom of the file. MainWndProc() does handle menus and accelerator
|
|
* keys, so it comes first.
|
|
*
|
|
* This program is functionally equivalent to EX03WIN.CPP. The C version
|
|
* uses the translation layer functions to get the job done, but if
|
|
* you put them side by side, you won't see too much difference.
|
|
*
|
|
* REVISION HISTORY
|
|
*
|
|
* February 1, 1996 2.0A : Second release
|
|
*
|
|
*/
|
|
|
|
#define STRICT
|
|
#include <windows.h>
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
|
|
#include "arclib.h"
|
|
#include "algauge.h"
|
|
#include "winmon.h"
|
|
#include "filestor.h"
|
|
#include "memstore.h"
|
|
#include "glarc.h"
|
|
#include "pkarc.h"
|
|
#include "ex04win.h"
|
|
|
|
/*
|
|
* I don't have a 32 bit version of CTL3D.DLL for Symantec or Microsoft.
|
|
*/
|
|
|
|
#if defined( AL_BORLAND ) || !defined( AL_FLAT_MODEL )
|
|
#define AL_3D
|
|
#include "ctl3d.h"
|
|
#else
|
|
#define Ctl3dColorChange()
|
|
#define Ctl3dRegister( a )
|
|
#define Ctl3dAutoSubclass( a )
|
|
#define Ctl3dUnregister( a )
|
|
#endif
|
|
|
|
int iInstanceNumber;
|
|
HINSTANCE hInstance;
|
|
HWND hDlgMain = 0;
|
|
hALStorage hFile = 0;
|
|
|
|
void SizeFramingWindow( HWND hDlg );
|
|
|
|
/*
|
|
* This routine is a bit longer than I might have liked. This is because
|
|
* it really is several routines combined into one. It's most important
|
|
* tasks are to first create a memory based archive with a bunch of files
|
|
* stuffed into it, then extract all those files into newly created
|
|
* memory objects. Finally, the orginal files are compared to the memory
|
|
* objects to make sure the compress/extract cycle is good.
|
|
*/
|
|
|
|
void CompressFiles( HWND hDlg, int list_box )
|
|
{
|
|
hALMonitor monitor;
|
|
hALEntryList list;
|
|
hALArchive archive;
|
|
hALEntry job;
|
|
|
|
/*
|
|
* The first section of this routine is pretty similar to lots of other
|
|
* example programs, both under Windows and DOS. We create a new archive
|
|
* using an ALMemory object as the base, then create a list with elements
|
|
* picked out from a list box, then insert them into an archive.
|
|
*/
|
|
hFile = newALWinMemory( "archive in RAM", 0, 0 );
|
|
if ( !hFile )
|
|
return;
|
|
monitor = newALWindowsMessage( AL_MONITOR_OBJECTS,
|
|
GetDlgItem( hDlg, AL_PROGRESS_TEXT ),
|
|
AL_SEND_RATIO,
|
|
GetDlgItem( hDlg, AL_PROGRESS_BAR ),
|
|
0 );
|
|
#if defined( ZIP )
|
|
list = newALListPkTools( monitor, AL_DEFAULT, AL_DEFAULT, AL_DEFAULT );
|
|
archive = newALPkArchiveFromStorage( hFile );
|
|
#else
|
|
list = newALListGlTools( monitor, AL_DEFAULT );
|
|
archive = newALGlArchiveFromStorage( hFile );
|
|
#endif
|
|
ALEntryListMakeEntriesFromListBox( list, hDlg, list_box );
|
|
ALArchiveCreate( archive, list );
|
|
if ( ALArchiveGetStatusCode( archive ) < 0 ) {
|
|
MessageBox( hDlg, "Error creating archive", "EX04WIN", MB_ICONEXCLAMATION );
|
|
deleteALStorage( hFile );
|
|
hFile = 0;
|
|
return;
|
|
}
|
|
/*
|
|
* Here I modify the job list so that the archive data records will
|
|
* be extracted to memory objects instead of file objects. Then I
|
|
* execute the extract function, creating a scad of new ALMemory
|
|
* objects. At this point, the only way I have of getting to those
|
|
* memory objects is by way of the list, so I have to hang on to it.
|
|
* But I'm done with the archive, so I can delete it.
|
|
*/
|
|
for ( job = ALEntryListGetFirstEntry( list );
|
|
job != 0;
|
|
job = ALEntryGetNextEntry( job ) ) {
|
|
char file_name[ 128 ];
|
|
hALStorage file;
|
|
|
|
file = ALEntryGetStorage( job );
|
|
#if defined( AL_FLAT_MODEL )
|
|
strcpy( file_name, ALStorageGetName( file ) );
|
|
ALEntrySetStorage( job, newALMemory( file_name, 0, 0 ) );
|
|
#else
|
|
_fstrcpy( file_name, ALStorageGetName( file ) );
|
|
ALEntrySetStorage( job, newALHugeMemory( file_name, 0, 0 ) );
|
|
#endif
|
|
deleteALStorage( file );
|
|
}
|
|
ALArchiveExtract( archive, list );
|
|
if ( ALArchiveGetStatusCode( archive ) < 0 ) {
|
|
MessageBox( hDlg, "Error extracting from archive", "EX04WIN", MB_ICONEXCLAMATION );
|
|
deleteALStorage( hFile );
|
|
hFile = 0;
|
|
return;
|
|
}
|
|
ALStorageDelete( hFile );
|
|
deleteALStorage( hFile );
|
|
hFile = 0;
|
|
/*
|
|
* Now I iterate through the list. For every entry in the list, I compare
|
|
* the memory object with the original ALFile object. Note that I am
|
|
* using a monitor object to track the progress of the comparison. This
|
|
* is kind of a tricky bit. Anyway, I do the compare and print the
|
|
* results.
|
|
*/
|
|
for ( job = ALEntryListGetFirstEntry( list );
|
|
job != 0;
|
|
job = ALEntryGetNextEntry( job ) ) {
|
|
char buf[ 128 ];
|
|
int result;
|
|
|
|
hFile = newALFile( ALStorageGetName( ALEntryGetStorage( job ) ) );
|
|
wsprintf( buf, "Comparing %s", (LPSTR) ALStorageGetName( hFile) );
|
|
SetDlgItemText( hDlg, AL_PROGRESS_TEXT, buf );
|
|
/*
|
|
* Since I am monitoring objects, I need to make these two setup function
|
|
* calls to the monitor if I expect it to work properly.
|
|
*/
|
|
ALStorageSetMonitor( hFile, monitor );
|
|
ALMonitorSetObjectSize( monitor, -1 );
|
|
ALMonitorSetObjectStart( monitor, 0 );
|
|
result = ALStorageCompare( hFile, ALEntryGetStorage( job ) );
|
|
if ( ALStorageGetStatusCode( hFile ) < 0 ) {
|
|
deleteALStorage( hFile );
|
|
hFile = 0;
|
|
return;
|
|
}
|
|
deleteALStorage( hFile );
|
|
hFile = 0;
|
|
if ( result != AL_SUCCESS ) {
|
|
SetDlgItemText( hDlg, AL_PROGRESS_TEXT, "Failure!" );
|
|
break;
|
|
}
|
|
SetDlgItemText( hDlg, AL_PROGRESS_TEXT, "Success!" );
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This is the window procedure for the modeless dialog. It is where
|
|
* all the commands and so on are handled.
|
|
*/
|
|
|
|
BOOL AL_EXPORT CALLBACK MainDialogProc( HWND hDlg,
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
char buf[ 81 ];
|
|
|
|
switch ( message ) {
|
|
/*
|
|
* This is where I initialize the window title, and clear/set any other
|
|
* controls to their proper initial state.
|
|
*/
|
|
case WM_INITDIALOG :
|
|
SizeFramingWindow( hDlg );
|
|
wsprintf( buf, "Windows Example 04 <instance %d>", iInstanceNumber );
|
|
SetWindowText( GetParent( hDlg ), buf );
|
|
SendDlgItemMessage( hDlg,
|
|
AL_INPUT_LIST,
|
|
LB_DIR,
|
|
DDL_READWRITE,
|
|
(LPARAM)( (LPSTR) "*.*" ) );
|
|
return( TRUE );
|
|
/*
|
|
* CTL3D stuff. I'm not entirely sure what this does, but the dox say
|
|
* to use it.
|
|
*/
|
|
case WM_SYSCOLORCHANGE :
|
|
Ctl3dColorChange();
|
|
break;
|
|
/*
|
|
* Everything exciting the user wants to make happen gets to the program
|
|
* by way of the WM_COMMAND message handler.
|
|
*/
|
|
|
|
case WM_COMMAND :
|
|
switch ( LOWORD( wParam ) ) {
|
|
/*
|
|
* The only command I am locking for on the list box is the double click.
|
|
* If I see a double click, it means it is time to compress the files.
|
|
*/
|
|
case AL_INPUT_LIST :
|
|
#if defined( AL_FLAT_MODEL )
|
|
AL_UNUSED_PARAMETER( lParam );
|
|
switch ( HIWORD( wParam ) ) {
|
|
#else
|
|
switch ( HIWORD( lParam ) ) {
|
|
#endif
|
|
case LBN_DBLCLK :
|
|
if ( !hFile )
|
|
CompressFiles( hDlg, AL_INPUT_LIST );
|
|
break;
|
|
}
|
|
break;
|
|
/*
|
|
* This button or the return key both start the Compression cycle.
|
|
*/
|
|
case AL_CYCLE :
|
|
case IDOK :
|
|
if ( !hFile )
|
|
CompressFiles( hDlg, AL_INPUT_LIST );
|
|
break;
|
|
/*
|
|
* If the user tries to exit while work is in progress, we just set the
|
|
* error status and do something annoying. Otherwise we close the window
|
|
*
|
|
*/
|
|
case AL_EXIT :
|
|
case WM_QUIT :
|
|
if ( hFile ) {
|
|
ALStorageSetError( hFile,
|
|
AL_USER_ABORT,
|
|
"User pressed abort key" );
|
|
FlashWindow( GetParent( hDlg ), 1 );
|
|
FlashWindow( GetParent( hDlg ), 0 );
|
|
return FALSE;
|
|
}
|
|
PostMessage( GetParent( hDlg ),WM_DESTROY, 0, 0 );
|
|
DestroyWindow( hDlgMain );
|
|
hDlgMain = 0;
|
|
return TRUE;
|
|
/*
|
|
* Likewise for abort, we set the error status for the object in question.
|
|
*/
|
|
case AL_ABORT :
|
|
if ( hFile )
|
|
ALStorageSetError( hFile, AL_USER_ABORT, "User pressed abort key" );
|
|
return TRUE;
|
|
default :
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/*
|
|
* The about box dialog procedure is pretty boring. The most interesting
|
|
* thing it does is center itself on the screen.
|
|
*/
|
|
|
|
BOOL AL_EXPORT CALLBACK
|
|
AboutDialogProc( HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam )
|
|
{
|
|
RECT rc;
|
|
|
|
AL_UNUSED_PARAMETER( lParam );
|
|
|
|
switch ( message ) {
|
|
case WM_INITDIALOG :
|
|
GetWindowRect( hDlg, &rc );
|
|
SetWindowPos( hDlg,
|
|
0,
|
|
((GetSystemMetrics(SM_CXSCREEN) - (rc.right - rc.left)) / 2),
|
|
((GetSystemMetrics(SM_CYSCREEN) - (rc.bottom - rc.top)) / 2),
|
|
0, 0, SWP_NOSIZE | SWP_NOACTIVATE);
|
|
break;
|
|
case WM_COMMAND :
|
|
switch ( wParam ) {
|
|
case IDOK :
|
|
case WM_QUIT :
|
|
case WM_DESTROY :
|
|
EndDialog( hDlg, TRUE );
|
|
return TRUE;
|
|
|
|
}
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* The main window is nothing more than a shell that exists to create
|
|
* the dialog box, take menu commands, and process accelerator keys.
|
|
*/
|
|
|
|
LONG AL_EXPORT CALLBACK MainWndProc( HWND hWnd,
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
switch ( message ) {
|
|
case WM_COMMAND:
|
|
switch( wParam ) {
|
|
case AL_ABOUT :
|
|
DialogBox( hInstance, "ALAboutDialog", 0, (DLGPROC) AboutDialogProc );
|
|
return TRUE;
|
|
case AL_EXIT :
|
|
PostQuitMessage( 0 );
|
|
}
|
|
break;
|
|
case WM_SETFOCUS:
|
|
SetFocus( hDlgMain ); /* insure that the Dialog Box has the focus */
|
|
break;
|
|
case WM_DESTROY:
|
|
PostQuitMessage( 0 );
|
|
break;
|
|
}
|
|
return DefWindowProc( hWnd, message, wParam, lParam );
|
|
}
|
|
|
|
/*
|
|
* WinMain calls the initialization routine for the progress gauge,
|
|
* registers our class. It then creates the dialog, and starts the
|
|
* message pump.
|
|
*/
|
|
int PASCAL WinMain( HINSTANCE instance,
|
|
HINSTANCE previous_instance,
|
|
LPSTR cmd_line,
|
|
int nCmdShow )
|
|
{
|
|
HWND hWnd;
|
|
FARPROC lpfn;
|
|
MSG msg;
|
|
HACCEL hAccel;
|
|
|
|
AL_UNUSED_PARAMETER( cmd_line );
|
|
|
|
hInstance = instance;
|
|
if ( previous_instance == 0 ) {
|
|
WNDCLASS wc;
|
|
wc.style = 0;
|
|
wc.lpfnWndProc = (WNDPROC) MainWndProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = 0;
|
|
wc.hInstance = hInstance;
|
|
wc.hIcon = LoadIcon( hInstance, "ALIcon" );
|
|
wc.hCursor = LoadCursor(0,IDC_ARROW);
|
|
wc.hbrBackground = (HBRUSH) GetStockObject( WHITE_BRUSH );
|
|
wc.lpszMenuName = 0;
|
|
wc.lpszClassName = "GreenleafDialogClass";
|
|
if ( !RegisterClass( &wc ) )
|
|
return FALSE;
|
|
iInstanceNumber = 0;
|
|
}
|
|
#if !defined( AL_FLAT_MODEL )
|
|
else {
|
|
GetInstanceData( previous_instance,
|
|
(PBYTE) &iInstanceNumber,
|
|
sizeof iInstanceNumber );
|
|
iInstanceNumber++;
|
|
}
|
|
#endif
|
|
Ctl3dRegister( hInstance );
|
|
Ctl3dAutoSubclass( hInstance );
|
|
hWnd = CreateWindow( "GreenleafDialogClass",
|
|
"Greenleaf Example Program",
|
|
WS_OVERLAPPED | WS_CAPTION | WS_MINIMIZEBOX | WS_SYSMENU,
|
|
CW_USEDEFAULT,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
hInstance,
|
|
0 );
|
|
|
|
lpfn = MakeProcInstance( (FARPROC) MainDialogProc, hInstance );
|
|
hDlgMain = CreateDialog( hInstance, "ALMainDialog", hWnd, (DLGPROC) lpfn );
|
|
ShowWindow( hWnd, nCmdShow );
|
|
ShowWindow( hDlgMain, SW_SHOW );
|
|
hAccel = LoadAccelerators( hInstance, "ALAccelerator" );
|
|
while ( GetMessage ( &msg, 0, 0, 0 ) ) {
|
|
HWND hWndAccel = GetActiveWindow();
|
|
if ( !( hWndAccel && TranslateAccelerator( hWndAccel, hAccel, &msg ) ) )
|
|
{
|
|
if ( hDlgMain == NULL || !IsDialogMessage( hDlgMain,&msg ) ) {
|
|
TranslateMessage( &msg );
|
|
DispatchMessage( &msg );
|
|
}
|
|
}
|
|
}
|
|
Ctl3dUnregister( instance );
|
|
return (msg.wParam);
|
|
}
|
|
|
|
/*
|
|
* I need this routine for one purpose only. After the dialog is loaded,
|
|
* it calls this routine, which adjusts the size of the framing window to
|
|
* fit exactly around the dialog box. It also moves it to the center of
|
|
* the screen.
|
|
*/
|
|
|
|
void SizeFramingWindow( HWND hDlg )
|
|
{
|
|
RECT rect;
|
|
int x;
|
|
int y;
|
|
|
|
GetWindowRect( hDlg, &rect );
|
|
y = GetSystemMetrics( SM_CYSCREEN );
|
|
y -= ( rect.bottom - rect.top );
|
|
y -= GetSystemMetrics( SM_CYCAPTION );
|
|
y /= 2;
|
|
x = GetSystemMetrics( SM_CXSCREEN );
|
|
x -= rect.right - rect.left;
|
|
x /= 2;
|
|
SetWindowPos( GetParent( hDlg ),
|
|
0,
|
|
x,
|
|
y,
|
|
rect.right - rect.left /*+ GetSystemMetrics( SM_CXBORDER ) * 2 */,
|
|
rect.bottom - rect.top + GetSystemMetrics( SM_CYCAPTION ) /* + GetSystemMetrics( SM_CYBORDER ) * 2 */,
|
|
SWP_NOZORDER );
|
|
}
|