ciderpress/app/Main.cpp

2711 lines
79 KiB
C++
Raw Normal View History

2007-03-27 17:47:10 +00:00
/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
/*
* Main window management.
*/
#include "stdafx.h"
#include "Main.h"
#include "MyApp.h"
#include "AboutDialog.h"
#include "NufxArchive.h"
#include "DiskArchive.h"
#include "BNYArchive.h"
#include "ACUArchive.h"
#include "ArchiveInfoDialog.h"
#include "PrefsDialog.h"
#include "EnterRegDialog.h"
#include "OpenVolumeDialog.h"
#include "Print.h"
#include "HelpTopics.h"
#include "../util/UtilLib.h"
#include "resource.h"
/* use MFC's fancy version of new for debugging */
//#define new DEBUG_NEW
static const char* kWebSiteURL = "http://www.faddensoft.com/";
/*
* Filters for the "open file" command. In some cases a file may be opened
* in more than one format, so it's necessary to keep track of what the
* file filter was set to when the file was opened.
*/
const char MainWindow::kOpenNuFX[] =
"ShrinkIt Archives (.shk .sdk .bxy .sea .bse)|*.shk;*.sdk;*.bxy;*.sea;*.bse|";
const char MainWindow::kOpenBinaryII[] =
"Binary II Archives (.bny .bqy .bxy)|*.bny;*.bqy;*.bxy|";
const char MainWindow::kOpenACU[] =
"ACU Archives (.acu)|*.acu|";
const char MainWindow::kOpenDiskImage[] =
"Disk Images (.shk .sdk .dsk .po .do .d13 .2mg .img .nib .nb2 .raw .hdv .dc .dc6 .ddd .app .fdi .iso .gz .zip)|"
"*.shk;*.sdk;*.dsk;*.po;*.do;*.d13;*.2mg;*.img;*.nib;*.nb2;*.raw;*.hdv;*.dc;*.dc6;*.ddd;*.app;*.fdi;*.iso;*.gz;*.zip|";
const char MainWindow::kOpenAll[] =
"All Files (*.*)|*.*|";
const char MainWindow::kOpenEnd[] =
"|";
static const struct {
//const char* extension;
char extension[4];
FilterIndex idx;
} gExtensionToIndex[] = {
{ "shk", kFilterIndexNuFX },
{ "bxy", kFilterIndexNuFX },
{ "bse", kFilterIndexNuFX },
{ "sea", kFilterIndexNuFX },
{ "bny", kFilterIndexBinaryII },
{ "bqy", kFilterIndexBinaryII },
{ "acu", kFilterIndexACU },
{ "dsk", kFilterIndexDiskImage },
{ "po", kFilterIndexDiskImage },
{ "do", kFilterIndexDiskImage },
{ "d13", kFilterIndexDiskImage },
{ "2mg", kFilterIndexDiskImage },
{ "img", kFilterIndexDiskImage },
{ "sdk", kFilterIndexDiskImage },
{ "raw", kFilterIndexDiskImage },
{ "ddd", kFilterIndexDiskImage },
{ "app", kFilterIndexDiskImage },
{ "fdi", kFilterIndexDiskImage },
{ "iso", kFilterIndexDiskImage },
{ "gz", kFilterIndexDiskImage }, // assume disk image inside
{ "zip", kFilterIndexDiskImage }, // assume disk image inside
};
const char* MainWindow::kModeNuFX = _T("nufx");
const char* MainWindow::kModeBinaryII = _T("bin2");
const char* MainWindow::kModeACU = _T("acu");
const char* MainWindow::kModeDiskImage = _T("disk");
/*
* ===========================================================================
* MainWindow
* ===========================================================================
*/
static const UINT gFindReplaceID = RegisterWindowMessage(FINDMSGSTRING);
BEGIN_MESSAGE_MAP(MainWindow, CFrameWnd)
ON_WM_CREATE()
ON_MESSAGE(WMU_LATE_INIT, OnLateInit)
//ON_MESSAGE(WMU_CLOSE_MAIN_DIALOG, OnCloseMainDialog)
ON_WM_SIZE()
ON_WM_GETMINMAXINFO()
ON_WM_PAINT()
//ON_WM_MOUSEWHEEL()
ON_WM_SETFOCUS()
ON_WM_HELPINFO()
ON_WM_QUERYENDSESSION()
ON_WM_ENDSESSION()
ON_REGISTERED_MESSAGE(gFindReplaceID, OnFindDialogMessage)
ON_COMMAND( IDM_FILE_NEW_ARCHIVE, OnFileNewArchive)
ON_COMMAND( IDM_FILE_OPEN, OnFileOpen)
ON_COMMAND( IDM_FILE_OPEN_VOLUME, OnFileOpenVolume)
ON_UPDATE_COMMAND_UI(IDM_FILE_OPEN_VOLUME, OnUpdateFileOpenVolume)
ON_COMMAND( IDM_FILE_REOPEN, OnFileReopen)
ON_UPDATE_COMMAND_UI(IDM_FILE_REOPEN, OnUpdateFileReopen)
ON_COMMAND( IDM_FILE_SAVE, OnFileSave)
ON_UPDATE_COMMAND_UI(IDM_FILE_SAVE, OnUpdateFileSave)
ON_COMMAND( IDM_FILE_CLOSE, OnFileClose)
ON_UPDATE_COMMAND_UI(IDM_FILE_CLOSE, OnUpdateFileClose)
ON_COMMAND( IDM_FILE_ARCHIVEINFO, OnFileArchiveInfo)
ON_UPDATE_COMMAND_UI(IDM_FILE_ARCHIVEINFO, OnUpdateFileArchiveInfo)
ON_COMMAND( IDM_FILE_PRINT, OnFilePrint)
ON_UPDATE_COMMAND_UI(IDM_FILE_PRINT, OnUpdateFilePrint)
ON_COMMAND( IDM_FILE_EXIT, OnFileExit)
ON_COMMAND( IDM_EDIT_COPY, OnEditCopy)
ON_UPDATE_COMMAND_UI(IDM_EDIT_COPY, OnUpdateEditCopy)
ON_COMMAND( IDM_EDIT_PASTE, OnEditPaste)
ON_UPDATE_COMMAND_UI(IDM_EDIT_PASTE, OnUpdateEditPaste)
ON_COMMAND( IDM_EDIT_PASTE_SPECIAL, OnEditPasteSpecial)
ON_UPDATE_COMMAND_UI(IDM_EDIT_PASTE_SPECIAL, OnUpdateEditPasteSpecial)
ON_COMMAND( IDM_EDIT_FIND, OnEditFind)
ON_UPDATE_COMMAND_UI(IDM_EDIT_FIND, OnUpdateEditFind)
ON_COMMAND( IDM_EDIT_SELECT_ALL, OnEditSelectAll)
ON_UPDATE_COMMAND_UI(IDM_EDIT_SELECT_ALL, OnUpdateEditSelectAll)
ON_COMMAND( IDM_EDIT_INVERT_SELECTION, OnEditInvertSelection)
ON_UPDATE_COMMAND_UI(IDM_EDIT_INVERT_SELECTION, OnUpdateEditInvertSelection)
ON_COMMAND( IDM_EDIT_PREFERENCES, OnEditPreferences)
ON_COMMAND_RANGE( IDM_SORT_PATHNAME, IDM_SORT_ORIGINAL, OnEditSort)
ON_UPDATE_COMMAND_UI_RANGE(IDM_SORT_PATHNAME, IDM_SORT_ORIGINAL, OnUpdateEditSort)
ON_COMMAND( IDM_ACTIONS_VIEW, OnActionsView)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_VIEW, OnUpdateActionsView)
ON_COMMAND( IDM_ACTIONS_ADD_FILES, OnActionsAddFiles)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_ADD_FILES, OnUpdateActionsAddFiles)
ON_COMMAND( IDM_ACTIONS_ADD_DISKS, OnActionsAddDisks)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_ADD_DISKS, OnUpdateActionsAddDisks)
ON_COMMAND( IDM_ACTIONS_CREATE_SUBDIR, OnActionsCreateSubdir)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_CREATE_SUBDIR, OnUpdateActionsCreateSubdir)
ON_COMMAND( IDM_ACTIONS_EXTRACT, OnActionsExtract)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_EXTRACT, OnUpdateActionsExtract)
ON_COMMAND( IDM_ACTIONS_TEST, OnActionsTest)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_TEST, OnUpdateActionsTest)
ON_COMMAND( IDM_ACTIONS_DELETE, OnActionsDelete)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_DELETE, OnUpdateActionsDelete)
ON_COMMAND( IDM_ACTIONS_RENAME, OnActionsRename)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_RENAME, OnUpdateActionsRename)
ON_COMMAND( IDM_ACTIONS_RECOMPRESS, OnActionsRecompress)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_RECOMPRESS, OnUpdateActionsRecompress)
ON_COMMAND( IDM_ACTIONS_OPENASDISK, OnActionsOpenAsDisk)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_OPENASDISK, OnUpdateActionsOpenAsDisk)
ON_COMMAND( IDM_ACTIONS_EDIT_COMMENT, OnActionsEditComment)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_EDIT_COMMENT, OnUpdateActionsEditComment)
ON_COMMAND( IDM_ACTIONS_EDIT_PROPS, OnActionsEditProps)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_EDIT_PROPS, OnUpdateActionsEditProps)
ON_COMMAND( IDM_ACTIONS_RENAME_VOLUME, OnActionsRenameVolume)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_RENAME_VOLUME, OnUpdateActionsRenameVolume)
ON_COMMAND( IDM_ACTIONS_CONV_DISK, OnActionsConvDisk)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_CONV_DISK, OnUpdateActionsConvDisk)
ON_COMMAND( IDM_ACTIONS_CONV_FILE, OnActionsConvFile)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_CONV_FILE, OnUpdateActionsConvFile)
ON_COMMAND( IDM_ACTIONS_CONV_TOWAV, OnActionsConvToWav)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_CONV_TOWAV, OnUpdateActionsConvToWav)
ON_COMMAND( IDM_ACTIONS_CONV_FROMWAV, OnActionsConvFromWav)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_CONV_FROMWAV, OnUpdateActionsConvFromWav)
ON_COMMAND( IDM_ACTIONS_IMPORT_BAS, OnActionsImportBAS)
ON_UPDATE_COMMAND_UI(IDM_ACTIONS_IMPORT_BAS, OnUpdateActionsImportBAS)
ON_COMMAND( IDM_TOOLS_DISKEDIT, OnToolsDiskEdit)
ON_COMMAND( IDM_TOOLS_IMAGECREATOR, OnToolsDiskImageCreator)
ON_COMMAND( IDM_TOOLS_DISKCONV, OnToolsDiskConv)
ON_COMMAND( IDM_TOOLS_BULKDISKCONV, OnToolsBulkDiskConv)
ON_COMMAND( IDM_TOOLS_SST_MERGE, OnToolsSSTMerge)
ON_COMMAND( IDM_TOOLS_VOLUMECOPIER_VOLUME, OnToolsVolumeCopierVolume)
ON_COMMAND( IDM_TOOLS_VOLUMECOPIER_FILE, OnToolsVolumeCopierFile)
ON_COMMAND( IDM_TOOLS_EOLSCANNER, OnToolsEOLScanner)
ON_COMMAND( IDM_TOOLS_TWOIMGPROPS, OnToolsTwoImgProps)
ON_COMMAND( IDM_HELP_CONTENTS, OnHelpContents)
ON_COMMAND( IDM_HELP_WEBSITE, OnHelpWebSite)
ON_COMMAND( IDM_HELP_ORDERING, OnHelpOrdering)
ON_COMMAND( IDM_HELP_ABOUT, OnHelpAbout)
// ON_COMMAND( IDM_RTCLK_DEFAULT, OnRtClkDefault)
/* this is required to allow "Help" button to work in PropertySheets (!) */
// ON_COMMAND(ID_HELP, OnHelp)
ON_COMMAND(ID_HELP_FINDER, CFrameWnd::OnHelpFinder)
ON_COMMAND(ID_HELP, CFrameWnd::OnHelp)
ON_COMMAND(ID_CONTEXT_HELP, CFrameWnd::OnContextHelp)
ON_COMMAND(ID_DEFAULT_HELP, CFrameWnd::OnHelpFinder)
END_MESSAGE_MAP()
/*
* MainWindow constructor. Creates the main window and sets
* its properties.
*/
MainWindow::MainWindow()
{
static const char* kAppName = _T("CiderPress");
fpContentList = nil;
fpOpenArchive = nil;
//fpSelSet = nil;
fpActionProgress = nil;
fpProgressCounter = nil;
fpFindDialog = nil;
fFindDown = true;
fFindMatchCase = false;
fFindMatchWholeWord = false;
fAbortPrinting = false;
fhDevMode = nil;
fhDevNames = nil;
fNeedReopen = false;
CString wndClass = AfxRegisterWndClass(
CS_DBLCLKS /*| CS_HREDRAW | CS_VREDRAW*/,
gMyApp.LoadStandardCursor(IDC_ARROW),
NULL /*(HBRUSH) (COLOR_WINDOW + 1)*/,
gMyApp.LoadIcon(IDR_MAINFRAME) );
Create(wndClass, kAppName, WS_OVERLAPPEDWINDOW /*| WS_CLIPCHILDREN*/,
rectDefault, NULL, MAKEINTRESOURCE(IDR_MAINFRAME));
LoadAccelTable(MAKEINTRESOURCE(IDR_MAINFRAME));
// initialize some OLE garbage
AfxOleInit();
// required by MFC if Rich Edit controls are used
AfxInitRichEdit();
// required??
//AfxEnableControlContainer();
SetCPTitle();
int cc = PostMessage(WMU_LATE_INIT, 0, 0);
ASSERT(cc != 0);
}
/*
* MainWindow destructor. Close the archive if one is open, but don't try
* to shut down any controls in child windows. By this point, Windows has
* already snuffed them.
*/
MainWindow::~MainWindow()
{
WMSG0("~MainWindow\n");
//WMSG0("MainWindow destructor\n");
CloseArchiveWOControls();
int cc;
cc = ::WinHelp(m_hWnd, ::AfxGetApp()->m_pszHelpFilePath, HELP_QUIT, 0);
WMSG1("Turning off WinHelp returned %d\n", cc);
// free stuff used by print dialog
::GlobalFree(fhDevMode);
::GlobalFree(fhDevNames);
fPreferences.SaveToRegistry();
WMSG0("MainWindow destructor complete\n");
}
/*
* Override the pre-create function to tweak the window style.
*/
BOOL
MainWindow::PreCreateWindow(CREATESTRUCT& cs)
{
BOOL res = CFrameWnd::PreCreateWindow(cs);
cs.dwExStyle &= ~(WS_EX_CLIENTEDGE);
return res;
}
/*
* Override GetClientRect so we can factor in the status and tool bars.
*/
void
MainWindow::GetClientRect(LPRECT lpRect) const
{
CRect sizeRect;
int toolBarHeight, statusBarHeight;
fToolBar.GetWindowRect(&sizeRect);
toolBarHeight = sizeRect.bottom - sizeRect.top;
fStatusBar.GetWindowRect(&sizeRect);
statusBarHeight = sizeRect.bottom - sizeRect.top;
//WMSG2("HEIGHTS = %d/%d\n", toolBarHeight, statusBarHeight);
CFrameWnd::GetClientRect(lpRect);
lpRect->top += toolBarHeight;
lpRect->bottom -= statusBarHeight;
}
/*
* Do some idle processing.
*/
void
MainWindow::DoIdle(void)
{
/*
* Make sure that the filename field in the content list is always
* visible, since that what the user clicks on to select things. Would
* be nice to have a way to prevent it, but for now we'll just shove
* things back where they're supposed to be.
*/
if (fpContentList != nil) {
/* get the current column 0 width, with current user adjustments */
fpContentList->ExportColumnWidths();
int width = fPreferences.GetColumnLayout()->GetColumnWidth(0);
if (width >= 0 && width < ColumnLayout::kMinCol0Width) {
/* column is too small, but don't change it until user lets mouse up */
if (::GetAsyncKeyState(VK_LBUTTON) >= 0) {
WMSG0("Resetting column 0 width\n");
fPreferences.GetColumnLayout()->SetColumnWidth(0,
ColumnLayout::kMinCol0Width);
fpContentList->NewColumnWidths();
}
}
}
/*
* Put an asterisk at the end of the title if we have an open archive
* and it has pending modifications. Remove it if nothing is pending.
*/
if (fpOpenArchive != nil) {
CString title;
int len;
GetWindowText(/*ref*/ title);
len = title.GetLength();
if (len > 0 && title.GetAt(len-1) == '*') {
if (!fpOpenArchive->IsModified()) {
/* remove the asterisk and the preceeding space */
title.Delete(len-2, 2);
SetWindowText(title);
}
} else {
if (fpOpenArchive->IsModified()) {
/* add an asterisk */
title += " *";
SetWindowText(title);
}
}
}
}
/*
* Handle command-line arguments.
*
* Usage:
* CiderPress [[-temparc] [-mode {nufx,bin2,disk}] [-dispname name] filename]
*/
void
MainWindow::ProcessCommandLine(void)
{
/*
* Get the command line and break it down into an argument vector.
*/
const char* cmdLine = ::GetCommandLine();
if (cmdLine == nil || strlen(cmdLine) == 0)
return;
char* mangle = strdup(cmdLine);
if (mangle == nil)
return;
WMSG1("Mangling '%s'\n", mangle);
char* argv[8];
int argc = 8;
VectorizeString(mangle, argv, &argc);
WMSG0("Args:\n");
for (int i = 0; i < argc; i++) {
WMSG2(" %d '%s'\n", i, argv[i]);
}
/*
* Figure out what the arguments are.
*/
const char* filename = nil;
const char* dispName = nil;
int filterIndex = kFilterIndexGeneric;
bool temp = false;
for (i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
if (strcasecmp(argv[i], "-mode") == 0) {
if (i == argc-1) {
WMSG0("WARNING: -mode specified without mode\n");
} else
i++;
if (strcasecmp(argv[i], kModeNuFX) == 0)
filterIndex = kFilterIndexNuFX;
else if (strcasecmp(argv[i], kModeBinaryII) == 0)
filterIndex = kFilterIndexBinaryII;
else if (strcasecmp(argv[i], kModeACU) == 0)
filterIndex = kFilterIndexACU;
else if (strcasecmp(argv[i], kModeDiskImage) == 0)
filterIndex = kFilterIndexDiskImage;
else {
WMSG1("WARNING: unrecognized mode '%s'\n", argv[i]);
}
} else if (strcasecmp(argv[i], "-dispname") == 0) {
if (i == argc-1) {
WMSG0("WARNING: -dispname specified without name\n");
} else
i++;
dispName = argv[i];
} else if (strcasecmp(argv[i], "-temparc") == 0) {
temp = true;
} else if (strcasecmp(argv[i], "-install") == 0) {
// see MyApp::InitInstance
WMSG0("Got '-install' flag, doing nothing\n");
} else if (strcasecmp(argv[i], "-uninstall") == 0) {
// see MyApp::InitInstance
WMSG0("Got '-uninstall' flag, doing nothing\n");
} else {
WMSG1("WARNING: unrecognized flag '%s'\n", argv[i]);
}
} else {
/* must be the filename */
if (i != argc-1) {
WMSG1("WARNING: ignoring extra arguments (e.g. '%s')\n",
argv[i+1]);
}
filename = argv[i];
break;
}
}
if (argc != 1 && filename == nil) {
WMSG0("WARNING: args specified but no filename found\n");
}
WMSG0("Argument handling:\n");
WMSG3(" index=%d temp=%d filename='%s'\n",
filterIndex, temp, filename == nil ? "(nil)" : filename);
if (filename != nil) {
PathName path(filename);
CString ext = path.GetExtension();
// drop the leading '.' from the extension
if (ext.Left(1) == ".")
ext.Delete(0, 1);
/* load the archive, mandating read-only if it's a temporary file */
if (LoadArchive(filename, ext, filterIndex, temp, false) == 0) {
/* success, update title bar */
if (temp)
fOpenArchivePathName = path.GetFileName();
else
fOpenArchivePathName = filename;
if (dispName != nil)
fOpenArchivePathName = dispName;
SetCPTitle(fOpenArchivePathName, fpOpenArchive);
}
/* if it's a temporary file, arrange to have it deleted before exit */
if (temp) {
int len = strlen(filename);
if (len > 4 && strcasecmp(filename + (len-4), ".tmp") == 0) {
fDeleteList.Add(filename);
} else {
WMSG1("NOT adding '%s' to DeleteList -- does not end in '.tmp'\n",
filename);
}
}
}
free(mangle);
}
/*
* ===================================
* Command handlers
* ===================================
*/
const int kProgressPane = 1;
/*
* OnCreate handler. Used to add a toolbar and status bar.
*/
int
MainWindow::OnCreate(LPCREATESTRUCT lpcs)
{
WMSG0("Now in OnCreate!\n");
if (CFrameWnd::OnCreate(lpcs) == -1)
return -1;
/*
* Create the tool bar.
*/
#if 0
static UINT buttonList[] = {
IDM_FILE_OPEN,
IDM_FILE_NEW_ARCHIVE,
// spacer
IDM_FILE_PRINT,
};
#endif
fToolBar.Create(this, WS_CHILD | WS_VISIBLE | CBRS_TOP |
CBRS_TOOLTIPS | CBRS_FLYBY);
fToolBar.LoadToolBar(IDR_TOOLBAR1);
/*
* Create the status bar.
*/
static UINT indicators[] = { ID_SEPARATOR, ID_INDICATOR_COMPLETE };
fStatusBar.Create(this);
fStatusBar.SetIndicators(indicators, NELEM(indicators));
//fStatusBar.SetPaneInfo(0, ID_SEPARATOR, SBPS_NOBORDERS | SBPS_STRETCH, 0);
fStatusBar.SetPaneText(kProgressPane, "");
return 0;
}
/*
* Catch a message sent to inspire us to perform one-time initializations of
* preferences and libraries.
*
* We're doing this the long way around because we want to be able to
* put up a dialog box if the version is bad. If we tried to handle this
* in the constructor we'd be acting before the window was fully created.
*/
LONG
MainWindow::OnLateInit(UINT, LONG)
{
CString result;
CString appName;
CString niftyListFile;
appName.LoadString(IDS_MB_APP_NAME);
WMSG0("----- late init begins -----\n");
/*
* Handle all other messages. This gives the framework a chance to dim
* all of the toolbar buttons. This is especially useful when opening
* a file from the command line that doesn't exist, causing an error
* dialog and blocking main window messages.
*/
PeekAndPump();
/*
* Initialize libraries. This includes a version check.
*/
result = NufxArchive::AppInit();
if (!result.IsEmpty())
goto fail;
result = DiskArchive::AppInit();
if (!result.IsEmpty())
goto fail;
result = BnyArchive::AppInit();
if (!result.IsEmpty())
goto fail;
niftyListFile = gMyApp.GetExeBaseName();
niftyListFile += "NList.Data";
if (!NiftyList::AppInit(niftyListFile)) {
CString file2 = niftyListFile + ".TXT";
if (!NiftyList::AppInit(file2)) {
CString msg;
msg.Format(IDS_NLIST_DATA_FAILED, niftyListFile, file2);
MessageBox(msg, appName, MB_OK);
}
}
/*
* Read preferences from registry.
*/
fPreferences.LoadFromRegistry();
/*
* Check to see if we're registered; if we're not, and we've expired, it's
* time to bail out.
*/
MyRegistry::RegStatus regStatus;
//regStatus = gMyApp.fRegistry.CheckRegistration(&result);
regStatus = MyRegistry::kRegValid;
WMSG1("CheckRegistration returned %d\n", regStatus);
switch (regStatus) {
case MyRegistry::kRegNotSet:
case MyRegistry::kRegValid:
ASSERT(result.IsEmpty());
break;
case MyRegistry::kRegExpired:
case MyRegistry::kRegInvalid:
MessageBox(result, appName, MB_OK|MB_ICONINFORMATION);
WMSG0("FORCING REG\n");
#if 0
if (EnterRegDialog::GetRegInfo(this) != 0) {
result = "";
goto fail;
}
#endif
SetCPTitle(); // update title bar with new reg info
break;
case MyRegistry::kRegFailed:
ASSERT(!result.IsEmpty());
goto fail;
default:
ASSERT(false);
CString confused;
confused.Format("Registration check failed. %s", (LPCTSTR) result);
result = confused;
goto fail;
}
/*
* Process command-line options, possibly loading an archive.
*/
ProcessCommandLine();
return 0;
fail:
if (!result.IsEmpty())
ShowFailureMsg(this, result, IDS_FAILED);
int cc = PostMessage(WM_CLOSE, 0, 0);
ASSERT(cc != 0);
return 0;
}
/*
* The system wants to know if we're okay with shutting down.
*
* Return TRUE if it's okay to shut down, FALSE otherwise.
*/
BOOL
MainWindow::OnQueryEndSession(void)
{
WMSG0("Got QueryEndSession\n");
return TRUE;
}
/*
* Notification of shutdown (or not).
*/
void
MainWindow::OnEndSession(BOOL bEnding)
{
WMSG1("Got EndSession (bEnding=%d)\n", bEnding);
if (bEnding) {
CloseArchiveWOControls();
fPreferences.SaveToRegistry();
}
}
/*
* The main window is resizing. We don't automatically redraw on resize,
* so we will need to update the client region. If it's filled with a
* control, the control's resize & redraw function will take care of it.
* If not, we need to explicitly invalidate the client region so the
* window will repaint itself.
*/
void
MainWindow::OnSize(UINT nType, int cx, int cy)
{
CFrameWnd::OnSize(nType, cx, cy);
ResizeClientArea();
}
void
MainWindow::ResizeClientArea(void)
{
CRect sizeRect;
GetClientRect(&sizeRect);
if (fpContentList != NULL)
fpContentList->MoveWindow(sizeRect);
else
Invalidate(false);
}
/*
* Restrict the minimum window size to something reasonable.
*/
void
MainWindow::OnGetMinMaxInfo(MINMAXINFO* pMMI)
{
pMMI->ptMinTrackSize.x = 256;
pMMI->ptMinTrackSize.y = 192;
}
/*
* Repaint the main window.
*/
void
MainWindow::OnPaint(void)
{
CPaintDC dc(this);
CRect clientRect;
GetClientRect(&clientRect);
/*
* If there's no control in the window, fill in the client area with
* what looks like an empty MDI client rect.
*/
if (fpContentList == nil) {
DrawEmptyClientArea(&dc, clientRect);
}
#if 0
CPen pen(PS_SOLID, 1, RGB(255, 0, 0)); // red pen, 1 pixel wide
CPen* pOldPen = dc.SelectObject(&pen);
dc.MoveTo(clientRect.left, clientRect.top);
dc.LineTo(clientRect.right-1, clientRect.top);
dc.LineTo(clientRect.right, clientRect.bottom);
dc.LineTo(clientRect.left, clientRect.bottom-1);
dc.LineTo(clientRect.left, clientRect.top);
dc.SelectObject(pOldPen);
#endif
}
#if 0
afx_msg BOOL
MainWindow::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
{
WMSG0("MOUSE WHEEL\n");
return FALSE;
WPARAM wparam;
LPARAM lparam;
wparam = nFlags | (zDelta << 16);
lparam = pt.x | (pt.y << 16);
if (fpContentList != nil)
fpContentList->SendMessage(WM_MOUSEWHEEL, wparam, lparam);
return CWnd::OnMouseWheel(nFlags, zDelta, pt);
// return TRUE;
}
#endif
/*
* Make sure open controls keep the input focus.
*/
void
MainWindow::OnSetFocus(CWnd* /*pOldWnd*/)
{
if (fpContentList != nil) {
WMSG0("Returning focus to ContentList\n");
fpContentList->SetFocus();
}
}
/*
* User hit F1. We don't currently have context-sensitive help on the main page.
*/
BOOL
MainWindow::OnHelpInfo(HELPINFO* /*lpHelpInfo*/)
{
//WinHelp(0, HELP_FINDER);
WinHelp(HELP_TOPIC_WELCOME, HELP_CONTEXT);
return TRUE; // dunno what this means
}
#if 0
/*
* Catch-all Help handler, necessary to allow CPropertySheet to display a
* "Help" button. (WTF?)
*/
LONG
MainWindow::OnHelp(UINT wParam, LONG lParam)
{
HELPINFO* lpHelpInfo = (HELPINFO*) lParam;
DWORD context = lpHelpInfo->iCtrlId;
WMSG1("MainWindow OnHelp (context=%d)\n", context);
WinHelp(context, HELP_CONTEXTPOPUP);
return TRUE; // yes, we handled it
}
#endif
/*
* Handle Edit->Preferences by popping up a property sheet.
*/
void
MainWindow::OnEditPreferences(void)
{
PrefsSheet ps;
ColumnLayout* pColLayout = fPreferences.GetColumnLayout();
/* pull any user header tweaks out of list so we can configure prefs */
if (fpContentList != nil)
fpContentList->ExportColumnWidths();
/* set up PrefsGeneralPage */
for (int i = 0; i < kNumVisibleColumns; i++) {
ps.fGeneralPage.fColumn[i] = (pColLayout->GetColumnWidth(i) != 0);
}
ps.fGeneralPage.fMimicShrinkIt = fPreferences.GetPrefBool(kPrMimicShrinkIt);
ps.fGeneralPage.fBadMacSHK = fPreferences.GetPrefBool(kPrBadMacSHK);
ps.fGeneralPage.fReduceSHKErrorChecks = fPreferences.GetPrefBool(kPrReduceSHKErrorChecks);
ps.fGeneralPage.fCoerceDOSFilenames = fPreferences.GetPrefBool(kPrCoerceDOSFilenames);
ps.fGeneralPage.fSpacesToUnder = fPreferences.GetPrefBool(kPrSpacesToUnder);
ps.fGeneralPage.fPasteJunkPaths = fPreferences.GetPrefBool(kPrPasteJunkPaths);
ps.fGeneralPage.fBeepOnSuccess = fPreferences.GetPrefBool(kPrBeepOnSuccess);
/* set up PrefsDiskImagePage */
ps.fDiskImagePage.fQueryImageFormat = fPreferences.GetPrefBool(kPrQueryImageFormat);
ps.fDiskImagePage.fOpenVolumeRO = fPreferences.GetPrefBool(kPrOpenVolumeRO);
ps.fDiskImagePage.fOpenVolumePhys0 = fPreferences.GetPrefBool(kPrOpenVolumePhys0);
ps.fDiskImagePage.fProDOSAllowLower = fPreferences.GetPrefBool(kPrProDOSAllowLower);
ps.fDiskImagePage.fProDOSUseSparse = fPreferences.GetPrefBool(kPrProDOSUseSparse);
/* set up PrefsCompressionPage */
ps.fCompressionPage.fCompressType = fPreferences.GetPrefLong(kPrCompressionType);
/* set up PrefsFviewPage */
ps.fFviewPage.fMaxViewFileSizeKB =
(fPreferences.GetPrefLong(kPrMaxViewFileSize) + 1023) / 1024;
ps.fFviewPage.fNoWrapText = fPreferences.GetPrefBool(kPrNoWrapText);
ps.fFviewPage.fHighlightHexDump = fPreferences.GetPrefBool(kPrHighlightHexDump);
ps.fFviewPage.fHighlightBASIC = fPreferences.GetPrefBool(kPrHighlightBASIC);
ps.fFviewPage.fConvDisasmOneByteBrkCop = fPreferences.GetPrefBool(kPrDisasmOneByteBrkCop);
ps.fFviewPage.fConvHiResBlackWhite = fPreferences.GetPrefBool(kPrConvHiResBlackWhite);
ps.fFviewPage.fConvDHRAlgorithm = fPreferences.GetPrefLong(kPrConvDHRAlgorithm);
ps.fFviewPage.fRelaxGfxTypeCheck = fPreferences.GetPrefBool(kPrRelaxGfxTypeCheck);
// ps.fFviewPage.fEOLConvRaw = fPreferences.GetPrefBool(kPrEOLConvRaw);
// ps.fFviewPage.fConvHighASCII = fPreferences.GetPrefBool(kPrConvHighASCII);
ps.fFviewPage.fConvTextEOL_HA = fPreferences.GetPrefBool(kPrConvTextEOL_HA);
ps.fFviewPage.fConvCPMText = fPreferences.GetPrefBool(kPrConvCPMText);
ps.fFviewPage.fConvPascalText = fPreferences.GetPrefBool(kPrConvPascalText);
ps.fFviewPage.fConvPascalCode = fPreferences.GetPrefBool(kPrConvPascalCode);
ps.fFviewPage.fConvApplesoft = fPreferences.GetPrefBool(kPrConvApplesoft);
ps.fFviewPage.fConvInteger = fPreferences.GetPrefBool(kPrConvInteger);
ps.fFviewPage.fConvGWP = fPreferences.GetPrefBool(kPrConvGWP);
ps.fFviewPage.fConvText8 = fPreferences.GetPrefBool(kPrConvText8);
ps.fFviewPage.fConvAWP = fPreferences.GetPrefBool(kPrConvAWP);
ps.fFviewPage.fConvADB = fPreferences.GetPrefBool(kPrConvADB);
ps.fFviewPage.fConvASP = fPreferences.GetPrefBool(kPrConvASP);
ps.fFviewPage.fConvSCAssem = fPreferences.GetPrefBool(kPrConvSCAssem);
ps.fFviewPage.fConvDisasm = fPreferences.GetPrefBool(kPrConvDisasm);
ps.fFviewPage.fConvHiRes = fPreferences.GetPrefBool(kPrConvHiRes);
ps.fFviewPage.fConvDHR = fPreferences.GetPrefBool(kPrConvDHR);
ps.fFviewPage.fConvSHR = fPreferences.GetPrefBool(kPrConvSHR);
ps.fFviewPage.fConvPrintShop = fPreferences.GetPrefBool(kPrConvPrintShop);
ps.fFviewPage.fConvMacPaint = fPreferences.GetPrefBool(kPrConvMacPaint);
ps.fFviewPage.fConvProDOSFolder = fPreferences.GetPrefBool(kPrConvProDOSFolder);
ps.fFviewPage.fConvResources = fPreferences.GetPrefBool(kPrConvResources);
/* set up PrefsFilesPage */
ps.fFilesPage.fTempPath = fPreferences.GetPrefString(kPrTempPath);
ps.fFilesPage.fExtViewerExts = fPreferences.GetPrefString(kPrExtViewerExts);
if (ps.DoModal() == IDOK)
ApplyNow(&ps);
}
/*
* Apply a change from the preferences sheet.
*/
void
MainWindow::ApplyNow(PrefsSheet* pPS)
{
bool mustReload = false;
//WMSG0("APPLY CHANGES\n");
ColumnLayout* pColLayout = fPreferences.GetColumnLayout();
if (pPS->fGeneralPage.fDefaultsPushed) {
/* reset all sizes to defaults, then factor in checkboxes */
WMSG0(" Resetting all widths to defaults\n");
/* copy defaults over */
for (int i = 0; i < kNumVisibleColumns; i++)
pColLayout->SetColumnWidth(i, ColumnLayout::kWidthDefaulted);
}
/* handle column checkboxes */
for (int i = 0; i < kNumVisibleColumns; i++) {
if (pColLayout->GetColumnWidth(i) == 0 &&
pPS->fGeneralPage.fColumn[i])
{
/* restore column */
WMSG1(" Column %d restored\n", i);
pColLayout->SetColumnWidth(i, ColumnLayout::kWidthDefaulted);
} else if (pColLayout->GetColumnWidth(i) != 0 &&
!pPS->fGeneralPage.fColumn[i])
{
/* disable column */
WMSG1(" Column %d hidden\n", i);
pColLayout->SetColumnWidth(i, 0);
}
}
if (fpContentList != nil)
fpContentList->NewColumnWidths();
fPreferences.SetPrefBool(kPrMimicShrinkIt,
pPS->fGeneralPage.fMimicShrinkIt != 0);
fPreferences.SetPrefBool(kPrBadMacSHK, pPS->fGeneralPage.fBadMacSHK != 0);
fPreferences.SetPrefBool(kPrReduceSHKErrorChecks,
pPS->fGeneralPage.fReduceSHKErrorChecks != 0);
if (fPreferences.GetPrefBool(kPrCoerceDOSFilenames)!=
(pPS->fGeneralPage.fCoerceDOSFilenames != 0))
{
WMSG1("DOS filename coercion pref now %d\n",
pPS->fGeneralPage.fCoerceDOSFilenames);
fPreferences.SetPrefBool(kPrCoerceDOSFilenames,
pPS->fGeneralPage.fCoerceDOSFilenames != 0);
mustReload = true;
}
if (fPreferences.GetPrefBool(kPrSpacesToUnder) !=
(pPS->fGeneralPage.fSpacesToUnder != 0))
{
WMSG1("Spaces-to-underscores now %d\n", pPS->fGeneralPage.fSpacesToUnder);
fPreferences.SetPrefBool(kPrSpacesToUnder, pPS->fGeneralPage.fSpacesToUnder != 0);
mustReload = true;
}
fPreferences.SetPrefBool(kPrPasteJunkPaths, pPS->fGeneralPage.fPasteJunkPaths != 0);
fPreferences.SetPrefBool(kPrBeepOnSuccess, pPS->fGeneralPage.fBeepOnSuccess != 0);
if (pPS->fGeneralPage.fOurAssociations != nil) {
WMSG0("NEW ASSOCIATIONS!\n");
for (int assoc = 0; assoc < gMyApp.fRegistry.GetNumFileAssocs(); assoc++)
{
gMyApp.fRegistry.SetFileAssoc(assoc,
pPS->fGeneralPage.fOurAssociations[assoc]);
}
/* delete them so, if they hit "apply" again, we only update once */
delete[] pPS->fGeneralPage.fOurAssociations;
pPS->fGeneralPage.fOurAssociations = nil;
}
fPreferences.SetPrefBool(kPrQueryImageFormat, pPS->fDiskImagePage.fQueryImageFormat != 0);
fPreferences.SetPrefBool(kPrOpenVolumeRO, pPS->fDiskImagePage.fOpenVolumeRO != 0);
fPreferences.SetPrefBool(kPrOpenVolumePhys0, pPS->fDiskImagePage.fOpenVolumePhys0 != 0);
fPreferences.SetPrefBool(kPrProDOSAllowLower, pPS->fDiskImagePage.fProDOSAllowLower != 0);
fPreferences.SetPrefBool(kPrProDOSUseSparse, pPS->fDiskImagePage.fProDOSUseSparse != 0);
fPreferences.SetPrefLong(kPrCompressionType, pPS->fCompressionPage.fCompressType);
fPreferences.SetPrefLong(kPrMaxViewFileSize, pPS->fFviewPage.fMaxViewFileSizeKB * 1024);
fPreferences.SetPrefBool(kPrNoWrapText, pPS->fFviewPage.fNoWrapText != 0);
fPreferences.SetPrefBool(kPrHighlightHexDump, pPS->fFviewPage.fHighlightHexDump != 0);
fPreferences.SetPrefBool(kPrHighlightBASIC, pPS->fFviewPage.fHighlightBASIC != 0);
fPreferences.SetPrefBool(kPrDisasmOneByteBrkCop, pPS->fFviewPage.fConvDisasmOneByteBrkCop != 0);
fPreferences.SetPrefBool(kPrConvHiResBlackWhite, pPS->fFviewPage.fConvHiResBlackWhite != 0);
fPreferences.SetPrefLong(kPrConvDHRAlgorithm, pPS->fFviewPage.fConvDHRAlgorithm);
fPreferences.SetPrefBool(kPrRelaxGfxTypeCheck, pPS->fFviewPage.fRelaxGfxTypeCheck != 0);
// fPreferences.SetPrefBool(kPrEOLConvRaw, pPS->fFviewPage.fEOLConvRaw != 0);
// fPreferences.SetPrefBool(kPrConvHighASCII, pPS->fFviewPage.fConvHighASCII != 0);
fPreferences.SetPrefBool(kPrConvTextEOL_HA, pPS->fFviewPage.fConvTextEOL_HA != 0);
fPreferences.SetPrefBool(kPrConvCPMText, pPS->fFviewPage.fConvCPMText != 0);
fPreferences.SetPrefBool(kPrConvPascalText, pPS->fFviewPage.fConvPascalText != 0);
fPreferences.SetPrefBool(kPrConvPascalCode, pPS->fFviewPage.fConvPascalCode != 0);
fPreferences.SetPrefBool(kPrConvApplesoft, pPS->fFviewPage.fConvApplesoft != 0);
fPreferences.SetPrefBool(kPrConvInteger, pPS->fFviewPage.fConvInteger != 0);
fPreferences.SetPrefBool(kPrConvGWP, pPS->fFviewPage.fConvGWP != 0);
fPreferences.SetPrefBool(kPrConvText8, pPS->fFviewPage.fConvText8 != 0);
fPreferences.SetPrefBool(kPrConvAWP, pPS->fFviewPage.fConvAWP != 0);
fPreferences.SetPrefBool(kPrConvADB, pPS->fFviewPage.fConvADB != 0);
fPreferences.SetPrefBool(kPrConvASP, pPS->fFviewPage.fConvASP != 0);
fPreferences.SetPrefBool(kPrConvSCAssem, pPS->fFviewPage.fConvSCAssem != 0);
fPreferences.SetPrefBool(kPrConvDisasm, pPS->fFviewPage.fConvDisasm != 0);
fPreferences.SetPrefBool(kPrConvHiRes, pPS->fFviewPage.fConvHiRes != 0);
fPreferences.SetPrefBool(kPrConvDHR, pPS->fFviewPage.fConvDHR != 0);
fPreferences.SetPrefBool(kPrConvSHR, pPS->fFviewPage.fConvSHR != 0);
fPreferences.SetPrefBool(kPrConvPrintShop, pPS->fFviewPage.fConvPrintShop != 0);
fPreferences.SetPrefBool(kPrConvMacPaint, pPS->fFviewPage.fConvMacPaint != 0);
fPreferences.SetPrefBool(kPrConvProDOSFolder, pPS->fFviewPage.fConvProDOSFolder != 0);
fPreferences.SetPrefBool(kPrConvResources, pPS->fFviewPage.fConvResources != 0);
fPreferences.SetPrefString(kPrTempPath, pPS->fFilesPage.fTempPath);
WMSG1("--- Temp path now '%s'\n", fPreferences.GetPrefString(kPrTempPath));
fPreferences.SetPrefString(kPrExtViewerExts, pPS->fFilesPage.fExtViewerExts);
// if ((pPS->fGeneralPage.fShowToolbarText != 0) != fPreferences.GetShowToolbarText()) {
// fPreferences.SetShowToolbarText(pPS->fGeneralPage.fShowToolbarText != 0);
// //SetToolbarTextMode();
// ResizeClientArea();
// }
/* allow open archive to track changes to preferences */
if (fpOpenArchive != nil)
fpOpenArchive->PreferencesChanged();
if (mustReload) {
WMSG0("Preferences apply requesting GA/CL reload\n");
if (fpOpenArchive != nil)
fpOpenArchive->Reload();
if (fpContentList != nil)
fpContentList->Reload();
}
/* export to registry */
fPreferences.SaveToRegistry();
//Invalidate();
}
/*
* Handle IDM_EDIT_FIND.
*/
void
MainWindow::OnEditFind(void)
{
DWORD flags = 0;
if (fpFindDialog != nil)
return;
if (fFindDown)
flags |= FR_DOWN;
if (fFindMatchCase)
flags |= FR_MATCHCASE;
if (fFindMatchWholeWord)
flags |= FR_WHOLEWORD;
fpFindDialog = new CFindReplaceDialog;
fpFindDialog->Create(TRUE, // "find" only
fFindLastStr, // default string to search for
NULL, // default string to replace
flags, // flags
this); // parent
}
void
MainWindow::OnUpdateEditFind(CCmdUI* pCmdUI)
{
pCmdUI->Enable(fpOpenArchive != nil);
}
/*
* Handle activity in the modeless "find" dialog.
*/
LRESULT
MainWindow::OnFindDialogMessage(WPARAM wParam, LPARAM lParam)
{
assert(fpFindDialog != nil);
fFindDown = (fpFindDialog->SearchDown() != 0);
fFindMatchCase = (fpFindDialog->MatchCase() != 0);
fFindMatchWholeWord = (fpFindDialog->MatchWholeWord() != 0);
if (fpFindDialog->IsTerminating()) {
fpFindDialog = nil;
return 0;
}
if (fpFindDialog->FindNext()) {
fFindLastStr = fpFindDialog->GetFindString();
fpContentList->FindNext(fFindLastStr, fFindDown, fFindMatchCase,
fFindMatchWholeWord);
} else {
WMSG0("Unexpected find dialog activity\n");
}
return 0;
}
/*
* Handle IDM_SORT_*.
*
* The "sort" enu item should really only be active if we have a file open.
*/
void
MainWindow::OnEditSort(UINT id)
{
WMSG1("EDIT SORT %d\n", id);
ASSERT(id >= IDM_SORT_PATHNAME && id <= IDM_SORT_ORIGINAL);
fPreferences.GetColumnLayout()->SetSortColumn(id - IDM_SORT_PATHNAME);
fPreferences.GetColumnLayout()->SetAscending(true);
if (fpContentList != nil)
fpContentList->NewSortOrder();
}
void
MainWindow::OnUpdateEditSort(CCmdUI* pCmdUI)
{
unsigned int column = fPreferences.GetColumnLayout()->GetSortColumn();
pCmdUI->SetCheck(pCmdUI->m_nID - IDM_SORT_PATHNAME == column);
}
/*
* Open the help file.
*/
void
MainWindow::OnHelpContents(void)
{
WinHelp(0, HELP_FINDER);
}
/*
* Go to the faddenSoft web site.
*/
void
MainWindow::OnHelpWebSite(void)
{
int err;
err = (int) ::ShellExecute(m_hWnd, _T("open"), kWebSiteURL, NULL, NULL,
SW_SHOWNORMAL);
if (err <= 32) {
CString msg;
if (err == ERROR_FILE_NOT_FOUND) {
msg = "Windows call failed: web browser not found. (Sometimes"
" it mistakenly reports this when IE is not the default"
" browser.)";
ShowFailureMsg(this, msg, IDS_FAILED);
} else {
msg.Format("Unable to launch web browser (err=%d).", err);
ShowFailureMsg(this, msg, IDS_FAILED);
}
}
}
/*
* Show ordering info (ka-ching!).
*/
void
MainWindow::OnHelpOrdering(void)
{
WinHelp(HELP_TOPIC_ORDERING_INFO, HELP_CONTEXT);
}
/*
* Pop up the About box.
*/
void
MainWindow::OnHelpAbout(void)
{
int result;
AboutDialog dlg(this);
result = dlg.DoModal();
WMSG1("HelpAbout returned %d\n", result);
/*
* User could've changed registration. If we're showing the registered
* user name in the title bar, update it.
*/
if (fpOpenArchive == nil)
SetCPTitle();
}
/*
* Create a new SHK archive, using a "save as" dialog to select the name.
*/
void
MainWindow::OnFileNewArchive(void)
{
CString filename, saveFolder, errStr;
GenericArchive* pOpenArchive;
CString errMsg;
CFileDialog dlg(FALSE, _T("shk"), NULL,
OFN_OVERWRITEPROMPT|OFN_NOREADONLYRETURN|OFN_HIDEREADONLY,
"ShrinkIt Archives (*.shk)|*.shk||", this);
dlg.m_ofn.lpstrTitle = "New Archive";
dlg.m_ofn.lpstrInitialDir = fPreferences.GetPrefString(kPrOpenArchiveFolder);
if (dlg.DoModal() != IDOK)
goto bail;
saveFolder = dlg.m_ofn.lpstrFile;
saveFolder = saveFolder.Left(dlg.m_ofn.nFileOffset);
fPreferences.SetPrefString(kPrOpenArchiveFolder, saveFolder);
filename = dlg.GetPathName();
WMSG1("NEW FILE '%s'\n", filename);
/* remove file if it already exists */
errMsg = RemoveFile(filename);
if (!errMsg.IsEmpty()) {
ShowFailureMsg(this, errMsg, IDS_FAILED);
goto bail;
}
pOpenArchive = new NufxArchive;
errStr = pOpenArchive->New(filename, nil);
if (!errStr.IsEmpty()) {
CString failed;
failed.LoadString(IDS_FAILED);
MessageBox(errStr, failed, MB_ICONERROR);
delete pOpenArchive;
} else {
SwitchContentList(pOpenArchive);
fOpenArchivePathName = dlg.GetPathName();
SetCPTitle(fOpenArchivePathName, fpOpenArchive);
}
bail:
WMSG0("--- OnFileNewArchive done\n");
}
/*
* Handle request to open an archive or disk image.
*/
void
MainWindow::OnFileOpen(void)
{
CString openFilters;
CString saveFolder;
/* set up filters; the order is significant */
openFilters = kOpenNuFX;
openFilters += kOpenBinaryII;
openFilters += kOpenACU;
openFilters += kOpenDiskImage;
openFilters += kOpenAll;
openFilters += kOpenEnd;
CFileDialog dlg(TRUE, "shk", NULL,
OFN_FILEMUSTEXIST, openFilters, this);
dlg.m_ofn.nFilterIndex = fPreferences.GetPrefLong(kPrLastOpenFilterIndex);
dlg.m_ofn.lpstrInitialDir = fPreferences.GetPrefString(kPrOpenArchiveFolder);
if (dlg.DoModal() != IDOK)
goto bail;
fPreferences.SetPrefLong(kPrLastOpenFilterIndex, dlg.m_ofn.nFilterIndex);
saveFolder = dlg.m_ofn.lpstrFile;
saveFolder = saveFolder.Left(dlg.m_ofn.nFileOffset);
fPreferences.SetPrefString(kPrOpenArchiveFolder, saveFolder);
DoOpenArchive(dlg.GetPathName(), dlg.GetFileExt(),
dlg.m_ofn.nFilterIndex, dlg.GetReadOnlyPref() != 0);
bail:
WMSG0("--- OnFileOpen done\n");
}
/*
* Handle request to open a raw disk volume.
*/
void
MainWindow::OnFileOpenVolume(void)
{
WMSG0("--- OnFileOpenVolume\n");
int result;
OpenVolumeDialog dlg(this);
result = dlg.DoModal();
if (result != IDOK)
goto bail;
//DiskImg::SetAllowWritePhys0(fPreferences.GetPrefBool(kPrOpenVolumePhys0));
DoOpenVolume(dlg.fChosenDrive, dlg.fReadOnly != 0);
bail:
return;
}
void
MainWindow::OnUpdateFileOpenVolume(CCmdUI* pCmdUI)
{
// don't really need this function
pCmdUI->Enable(TRUE);
}
/*
* Open an archive.
*/
void
MainWindow::DoOpenArchive(const char* pathName, const char* ext,
int filterIndex, bool readOnly)
{
if (LoadArchive(pathName, ext, filterIndex, readOnly, false) == 0) {
/* success, update title bar */
fOpenArchivePathName = pathName;
SetCPTitle(fOpenArchivePathName, fpOpenArchive);
} else {
/* some failures will close an open archive */
//if (fpOpenArchive == nil)
// SetCPTitle();
}
}
/*
* Save any pending changes.
*
* This may be called directly from tools, so don't assume that the
* conditions checked for in OnUpdateFileSave hold here.
*/
void
MainWindow::OnFileReopen(void)
{
ReopenArchive();
}
void
MainWindow::OnUpdateFileReopen(CCmdUI* pCmdUI)
{
pCmdUI->Enable(fpOpenArchive != nil);
}
/*
* Save any pending changes.
*
* This may be called directly from tools, so don't assume that the
* conditions checked for in OnUpdateFileSave hold here.
*/
void
MainWindow::OnFileSave(void)
{
CString errMsg;
if (fpOpenArchive == nil)
return;
{
CWaitCursor waitc;
errMsg = fpOpenArchive->Flush();
}
if (!errMsg.IsEmpty())
ShowFailureMsg(this, errMsg, IDS_FAILED);
// update the title bar
DoIdle();
}
void
MainWindow::OnUpdateFileSave(CCmdUI* pCmdUI)
{
pCmdUI->Enable(fpOpenArchive != nil && fpOpenArchive->IsModified());
}
/*
* Close current archive or disk image.
*/
void
MainWindow::OnFileClose(void)
{
CloseArchive();
//SetCPTitle();
WMSG0("--- OnFileClose done\n");
}
void
MainWindow::OnUpdateFileClose(CCmdUI* pCmdUI)
{
pCmdUI->Enable(fpOpenArchive != nil);
}
/*
* Show detailed information on the current archive.
*/
void
MainWindow::OnFileArchiveInfo(void)
{
ArchiveInfoDialog* pDlg = nil;
ASSERT(fpOpenArchive != nil);
switch (fpOpenArchive->GetArchiveKind()) {
case GenericArchive::kArchiveNuFX:
pDlg = new NufxArchiveInfoDialog((NufxArchive*) fpOpenArchive, this);
break;
case GenericArchive::kArchiveDiskImage:
pDlg = new DiskArchiveInfoDialog((DiskArchive*) fpOpenArchive, this);
break;
case GenericArchive::kArchiveBNY:
pDlg = new BnyArchiveInfoDialog((BnyArchive*) fpOpenArchive, this);
break;
case GenericArchive::kArchiveACU:
pDlg = new AcuArchiveInfoDialog((AcuArchive*) fpOpenArchive, this);
break;
default:
WMSG1("Unexpected archive type %d\n", fpOpenArchive->GetArchiveKind());
ASSERT(false);
return;
};
pDlg->DoModal();
delete pDlg;
}
void
MainWindow::OnUpdateFileArchiveInfo(CCmdUI* pCmdUI)
{
pCmdUI->Enable(fpContentList != nil);
}
/*
* Print the contents of the current archive.
*/
void
MainWindow::OnFilePrint(void)
{
PrintListing(fpContentList);
}
void
MainWindow::OnUpdateFilePrint(CCmdUI* pCmdUI)
{
pCmdUI->Enable(fpContentList != nil && fpContentList->GetItemCount() > 0);
}
/*
* Print a ContentList.
*/
void
MainWindow::PrintListing(const ContentList* pContentList)
{
CPrintDialog dlg(FALSE); // use CPrintDialogEx for Win2K? CPageSetUpDialog?
PrintContentList pcl;
CDC dc;
int itemCount, numPages;
itemCount = pContentList->GetItemCount();
numPages = (itemCount + (pcl.GetLinesPerPage()-1)) / pcl.GetLinesPerPage();
dlg.m_pd.nFromPage = dlg.m_pd.nMinPage = 1;
dlg.m_pd.nToPage = dlg.m_pd.nMaxPage = numPages;
dlg.m_pd.hDevMode = fhDevMode;
dlg.m_pd.hDevNames = fhDevNames;
dlg.m_pd.Flags |= PD_USEDEVMODECOPIESANDCOLLATE;
dlg.m_pd.Flags &= ~(PD_NOPAGENUMS);
if (dlg.DoModal() != IDOK)
return;
if (dc.Attach(dlg.GetPrinterDC()) != TRUE) {
CString msg;
msg.LoadString(IDS_PRINTER_NOT_USABLE);
ShowFailureMsg(this, msg, IDS_FAILED);
return;
}
pcl.Setup(&dc, this);
if (dlg.m_pd.Flags & PD_PAGENUMS)
pcl.Print(pContentList, dlg.m_pd.nFromPage, dlg.m_pd.nToPage);
else
pcl.Print(pContentList);
fhDevMode = dlg.m_pd.hDevMode;
fhDevNames = dlg.m_pd.hDevNames;
}
/*
* Handle Exit item by sending a close request.
*/
void
MainWindow::OnFileExit(void)
{
SendMessage(WM_CLOSE, 0, 0);
}
/*
* Select everything in the content list.
*/
void
MainWindow::OnEditSelectAll(void)
{
ASSERT(fpContentList != nil);
fpContentList->SelectAll();
}
void
MainWindow::OnUpdateEditSelectAll(CCmdUI* pCmdUI)
{
pCmdUI->Enable(fpContentList != nil);
}
/*
* Invert the content list selection.
*/
void
MainWindow::OnEditInvertSelection(void)
{
ASSERT(fpContentList != nil);
fpContentList->InvertSelection();
}
void
MainWindow::OnUpdateEditInvertSelection(CCmdUI* pCmdUI)
{
pCmdUI->Enable(fpContentList != nil);
}
/*
* Get the one selected item from the current display. Primarily useful
* for the double-click handler, but also used for "action" menu items
* that insist on operating on a single menu item (edit prefs, create subdir).
*
* Returns nil if the item couldn't be found or if more than one item was
* selected.
*/
GenericEntry*
MainWindow::GetSelectedItem(ContentList* pContentList)
{
if (pContentList->GetSelectedCount() != 1)
return nil;
POSITION posn;
posn = pContentList->GetFirstSelectedItemPosition();
if (posn == nil) {
ASSERT(false);
return nil;
}
int num = pContentList->GetNextSelectedItem(/*ref*/ posn);
GenericEntry* pEntry = (GenericEntry*) pContentList->GetItemData(num);
if (pEntry == nil) {
WMSG1(" Glitch: couldn't find entry %d\n", num);
ASSERT(false);
}
return pEntry;
}
/*
* Handle a double-click.
*
* Individual items get special treatment, multiple items just get handed off
* to the file viewer.
*/
void
MainWindow::HandleDoubleClick(void)
{
bool handled = false;
ASSERT(fpContentList != nil);
if (fpContentList->GetSelectedCount() == 0) {
/* nothing selected, they double-clicked outside first column */
WMSG0("Double-click but nothing selected\n");
return;
}
if (fpContentList->GetSelectedCount() != 1) {
/* multiple items, just bring up viewer */
HandleView();
return;
}
/*
* Find the GenericEntry that corresponds to this item.
*/
GenericEntry* pEntry = GetSelectedItem(fpContentList);
if (pEntry == nil)
return;
WMSG1(" Double-click GOT '%s'\n", pEntry->GetPathName());
const char* ext;
long fileType, auxType;
ext = FindExtension(pEntry->GetPathName(), pEntry->GetFssep());
fileType = pEntry->GetFileType();
auxType = pEntry->GetAuxType();
/* // unit tests for MatchSemicolonList
MatchSemicolonList("gif; jpeg; jpg", "jpeg");
MatchSemicolonList("gif; jpeg; jpg", "jpg");
MatchSemicolonList("gif; jpeg; jpg", "gif");
MatchSemicolonList("gif;jpeg;jpg", "gif;");
MatchSemicolonList("gif; jpeg; jpg", "jpe");
MatchSemicolonList("gif; jpeg; jpg", "jpegx");
MatchSemicolonList("gif; jpeg; jpg", "jp");
MatchSemicolonList("gif; jpeg; jpg", "jpgx");
MatchSemicolonList("gif; jpeg; jpg", "if");
MatchSemicolonList("gif; jpeg; jpg", "gifs");
MatchSemicolonList("gif, jpeg; jpg", "jpeg");
MatchSemicolonList("", "jpeg");
MatchSemicolonList(";", "jpeg");
MatchSemicolonList("gif, jpeg; jpg", "");
*/
/*
* Figure out what to do with it.
*/
CString extViewerExts;
extViewerExts = fPreferences.GetPrefString(kPrExtViewerExts);
if (ext != nil && MatchSemicolonList(extViewerExts, ext+1)) {
WMSG1(" Launching external viewer for '%s'\n", ext);
TmpExtractForExternal(pEntry);
handled = true;
} else if (pEntry->GetRecordKind() == GenericEntry::kRecordKindFile) {
if ((ext != nil && (
stricmp(ext, ".shk") == 0 ||
stricmp(ext, ".sdk") == 0 ||
stricmp(ext, ".bxy") == 0 )) ||
(fileType == 0xe0 && auxType == 0x8002))
{
WMSG0(" Guessing NuFX\n");
TmpExtractAndOpen(pEntry, GenericEntry::kDataThread, kModeNuFX);
handled = true;
} else
if ((ext != nil && (
stricmp(ext, ".bny") == 0 ||
stricmp(ext, ".bqy") == 0 )) ||
(fileType == 0xe0 && auxType == 0x8000))
{
WMSG0(" Guessing Binary II\n");
TmpExtractAndOpen(pEntry, GenericEntry::kDataThread, kModeBinaryII);
handled = true;
} else
if ((ext != nil && (
stricmp(ext, ".acu") == 0 )) ||
(fileType == 0xe0 && auxType == 0x8001))
{
WMSG0(" Guessing ACU\n");
TmpExtractAndOpen(pEntry, GenericEntry::kDataThread, kModeACU);
handled = true;
} else
if (fileType == 0x64496d67 && auxType == 0x64437079 &&
pEntry->GetUncompressedLen() == 819284)
{
/* type is dImg, creator is dCpy, length is 800K + DC stuff */
WMSG0(" Looks like a disk image\n");
TmpExtractAndOpen(pEntry, GenericEntry::kDataThread, kModeDiskImage);
handled = true;
}
} else if (pEntry->GetRecordKind() == GenericEntry::kRecordKindDisk) {
WMSG0(" Opening archived disk image\n");
TmpExtractAndOpen(pEntry, GenericEntry::kDiskImageThread, kModeDiskImage);
handled = true;
}
if (!handled) {
// standard viewer
HandleView();
}
/* set "/t" temp flag and delete afterward, warning user (?) */
}
/*
* Extract a record to the temp folder and open it with a new instance of
* CiderPress. We might want to extract disk images as 2MG files to take
* the mystery out of opening them, but since they're coming out of a
* ShrinkIt archive they're pretty un-mysterious anyway.
*
* We tell the new instance to open it read-only, and flag it for
* deletion on exit.
*
* Returns 0 on success, nonzero error status on failure.
*/
int
MainWindow::TmpExtractAndOpen(GenericEntry* pEntry, int threadKind,
const char* modeStr)
{
CString dispName;
bool mustDelete = false;
/*
* Get the name to display in the title bar. Double quotes will
* screw it up, so we have to replace them. (We could escape them,
* but then we'd also have to escape the escape char.)
*/
dispName = pEntry->GetFileName();
dispName.Replace('"', '_');
char nameBuf[MAX_PATH];
UINT unique;
unique = GetTempFileName(fPreferences.GetPrefString(kPrTempPath),
"CPfile", 0, nameBuf);
if (unique == 0) {
DWORD dwerr = ::GetLastError();
WMSG2("GetTempFileName failed on '%s' (err=%ld)\n",
fPreferences.GetPrefString(kPrTempPath), dwerr);
return dwerr;
}
mustDelete = true;
/*
* Open the temp file and extract the data into it.
*/
CString errMsg;
int result;
FILE* fp;
fp = fopen(nameBuf, "wb");
if (fp != nil) {
WMSG2("Extracting to '%s' (unique=%d)\n", nameBuf, unique);
result = pEntry->ExtractThreadToFile(threadKind, fp,
GenericEntry::kConvertEOLOff, GenericEntry::kConvertHAOff,
&errMsg);
fclose(fp);
if (result == IDOK) {
/* success */
CString parameters;
parameters.Format("-mode %s -dispname \"%s\" -temparc \"%s\"",
modeStr, dispName, nameBuf);
int err;
err = (int) ::ShellExecute(m_hWnd, _T("open"),
gMyApp.GetExeFileName(), parameters, NULL,
SW_SHOWNORMAL);
if (err <= 32) {
CString msg;
msg.Format("Unable to launch CiderPress (err=%d).", err);
ShowFailureMsg(this, msg, IDS_FAILED);
} else {
/* during dev, "missing DLL" causes false-positive success */
WMSG0("Successfully launched CiderPress\n");
mustDelete = false; // up to newly-launched app
}
} else {
ShowFailureMsg(this, errMsg, IDS_FAILED);
}
} else {
CString msg;
msg.Format("Unable to open temp file '%s'.", nameBuf);
::ShowFailureMsg(this, msg, IDS_FAILED);
}
if (mustDelete) {
WMSG1("Deleting '%s'\n", nameBuf);
unlink(nameBuf);
}
return 0;
}
/*
* Extract a record to the temp folder and open it with an external viewer.
* The file must be created with the correct extension so ShellExecute
* does the right thing.
*
* The files will be added to the "delete on exit" list, so that they will
* be cleaned up when CiderPress exits (assuming the external viewer no longer
* has them open).
*
* The GetTempFileName function creates a uniquely-named temp file. We
* create a file that has that name plus an extension. To ensure that we
* don't try to use the same temp filename twice, we have to hold off on
* deleting the unused .tmp files until we're ready to delete the
* corresponding .gif (or whatever) files. Thus, each invocation of this
* function creates two files and two entries in the delete-on-exit set.
*
* Returns 0 on success, nonzero error status on failure.
*/
int
MainWindow::TmpExtractForExternal(GenericEntry* pEntry)
{
const char* ext;
ext = FindExtension(pEntry->GetPathName(), pEntry->GetFssep());
char nameBuf[MAX_PATH];
UINT unique;
unique = GetTempFileName(fPreferences.GetPrefString(kPrTempPath),
"CPfile", 0, nameBuf);
if (unique == 0) {
DWORD dwerr = ::GetLastError();
WMSG2("GetTempFileName failed on '%s' (err=%ld)\n",
fPreferences.GetPrefString(kPrTempPath), dwerr);
return dwerr;
}
fDeleteList.Add(nameBuf); // file is created by GetTempFileName
strcat(nameBuf, ext);
/*
* Open the temp file and extract the data into it.
*/
CString errMsg;
int result;
FILE* fp;
fp = fopen(nameBuf, "wb");
if (fp != nil) {
fDeleteList.Add(nameBuf); // second file created by fopen
WMSG2("Extracting to '%s' (unique=%d)\n", nameBuf, unique);
result = pEntry->ExtractThreadToFile(GenericEntry::kDataThread, fp,
GenericEntry::kConvertEOLOff, GenericEntry::kConvertHAOff,
&errMsg);
fclose(fp);
if (result == IDOK) {
/* success */
int err;
err = (int) ::ShellExecute(m_hWnd, _T("open"), nameBuf, NULL,
NULL, SW_SHOWNORMAL);
if (err <= 32) {
CString msg;
msg.Format("Unable to launch external viewer (err=%d).", err);
ShowFailureMsg(this, msg, IDS_FAILED);
} else {
WMSG0("Successfully launched external viewer\n");
}
} else {
ShowFailureMsg(this, errMsg, IDS_FAILED);
}
} else {
CString msg;
msg.Format("Unable to open temp file '%s'.", nameBuf);
ShowFailureMsg(this, msg, IDS_FAILED);
}
return 0;
}
#if 0
/*
* Handle a "default action" selection from the right-click menu. The
* action only applies to the record that was clicked on, so we need to
* retrieve that from the control.
*/
void
MainWindow::OnRtClkDefault(void)
{
int idx;
ASSERT(fpContentList != nil);
idx = fpContentList->GetRightClickItem();
ASSERT(idx != -1);
WMSG1("OnRtClkDefault %d\n", idx);
fpContentList->ClearRightClickItem();
}
#endif
/*
* ===================================
* Progress meter
* ===================================
*/
/*
* There are two different mechanisms for reporting progress: ActionProgress
* dialogs (for adding/extracting files) and a small box in the lower
* right-hand corner (for opening archives). These functions will set
* the progress in the active action progress dialog if it exists, or
* will set the percentage in the window frame if not.
*/
void
MainWindow::SetProgressBegin(void)
{
if (fpActionProgress != nil)
fpActionProgress->SetProgress(0);
else
fStatusBar.SetPaneText(kProgressPane, "--%");
//WMSG0(" Complete: BEGIN\n");
/* redraw stuff with the changes */
(void) PeekAndPump();
}
int
MainWindow::SetProgressUpdate(int percent, const char* oldName,
const char* newName)
{
int status = IDOK;
if (fpActionProgress != nil) {
status = fpActionProgress->SetProgress(percent);
if (oldName != nil)
fpActionProgress->SetArcName(oldName);
if (newName != nil)
fpActionProgress->SetFileName(newName);
} else {
char buf[8];
sprintf(buf, "%d%%", percent);
fStatusBar.SetPaneText(kProgressPane, buf);
//WMSG1(" Complete: %s\n", buf);
}
if (!PeekAndPump()) {
WMSG0("SetProgressUpdate: shutdown?!\n");
}
//EventPause(10); // DEBUG DEBUG
return status;
}
void
MainWindow::SetProgressEnd(void)
{
if (fpActionProgress != nil)
fpActionProgress->SetProgress(100);
else
fStatusBar.SetPaneText(kProgressPane, "");
// EventPause(100); // DEBUG DEBUG
//WMSG0(" Complete: END\n");
}
/*
* Set a number in the "progress counter". Useful for loading large archives
* where we're not sure how much stuff is left, so showing a percentage is
* hard.
*
* Pass in -1 to erase the counter.
*
* Returns "true" if we'd like things to continue.
*/
bool
MainWindow::SetProgressCounter(const char* str, long val)
{
/* if the main window is enabled, user could activate menus */
ASSERT(!IsWindowEnabled());
if (fpProgressCounter != nil) {
//WMSG2("SetProgressCounter '%s' %d\n", str, val);
CString msg;
if (str != nil)
fpProgressCounter->SetCounterFormat(str);
fpProgressCounter->SetCount((int) val);
} else {
if (val < 0) {
fStatusBar.SetPaneText(kProgressPane, "");
} else {
CString tmpStr;
tmpStr.Format("%ld", val);
fStatusBar.SetPaneText(kProgressPane, tmpStr);
}
}
if (!PeekAndPump()) {
WMSG0("SetProgressCounter: shutdown?!\n");
}
//EventPause(10); // DEBUG DEBUG
if (fpProgressCounter != nil)
return !fpProgressCounter->GetCancel();
else
return true;
}
/*
* Allow events to flow through the message queue whenever the
* progress meter gets updated. This will allow us to redraw with
* reasonable frequency.
*
* Calling this can result in other code being called, such as Windows
* message handlers, which can lead to reentrancy problems. Make sure
* you're adequately semaphored before calling here.
*
* Returns TRUE if all is well, FALSE if we're trying to quit.
*/
BOOL
MainWindow::PeekAndPump(void)
{
MSG msg;
while (::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
if (!AfxGetApp()->PumpMessage()) {
::PostQuitMessage(0);
return FALSE;
}
}
LONG lIdle = 0;
while (AfxGetApp()->OnIdle(lIdle++))
;
return TRUE;
}
/*
* Go to sleep for a little bit, waking up 100x per second to check
* the idle loop.
*/
void
MainWindow::EventPause(int duration)
{
int count = duration / 10;
for (int i = 0; i < count; i++) {
PeekAndPump();
::Sleep(10);
}
}
/*
* Printer abort procedure; allows us to abort a print job. The DC
* SetAbortProc() function calls here periodically. The return value from
* this function determine whether or not printing halts.
*
* This checks a global "print cancel" variable, which is set by our print
* cancel button dialog.
*
* If this returns TRUE, printing continues; FALSE, and printing aborts.
*/
/*static*/ BOOL CALLBACK
MainWindow::PrintAbortProc(HDC hDC, int nCode)
{
MainWindow* pMain = (MainWindow*)::AfxGetMainWnd();
pMain->PeekAndPump();
if (pMain->GetAbortPrinting()) {
WMSG0("PrintAbortProc returning FALSE (abort printing)\n");
return FALSE;
}
WMSG0(" PrintAbortProc returning TRUE (continue printing)\n");
return TRUE;
}
/*
* ===================================
* Support functions
* ===================================
*/
/*
* Draw what looks like an empty client area.
*/
void
MainWindow::DrawEmptyClientArea(CDC* pDC, const CRect& clientRect)
{
CBrush brush;
brush.CreateSolidBrush(::GetSysColor(COLOR_APPWORKSPACE)); // dk gray
CBrush* pOldBrush = pDC->SelectObject(&brush);
pDC->FillRect(&clientRect, &brush);
pDC->SelectObject(pOldBrush);
CPen penWH(PS_SOLID, 1, ::GetSysColor(COLOR_3DHIGHLIGHT)); // white
CPen penLG(PS_SOLID, 1, ::GetSysColor(COLOR_3DLIGHT)); // lt gray
CPen penDG(PS_SOLID, 1, ::GetSysColor(COLOR_3DSHADOW)); // dk gray
CPen penBL(PS_SOLID, 1, ::GetSysColor(COLOR_3DDKSHADOW)); // near-black
CPen* pOldPen = pDC->SelectObject(&penWH);
//pDC->SelectObject(&penWH);
pDC->MoveTo(clientRect.right-1, clientRect.top);
pDC->LineTo(clientRect.right-1, clientRect.bottom-1);
pDC->LineTo(clientRect.left-1, clientRect.bottom-1);
pDC->SelectObject(&penBL);
pDC->MoveTo(clientRect.right-3, clientRect.top+1);
pDC->LineTo(clientRect.left+1, clientRect.top+1);
pDC->LineTo(clientRect.left+1, clientRect.bottom-2);
pDC->SelectObject(&penLG);
pDC->MoveTo(clientRect.right-2, clientRect.top+1);
pDC->LineTo(clientRect.right-2, clientRect.bottom-2);
pDC->LineTo(clientRect.left, clientRect.bottom-2);
pDC->SelectObject(&penDG);
pDC->MoveTo(clientRect.right-2, clientRect.top);
pDC->LineTo(clientRect.left, clientRect.top);
pDC->LineTo(clientRect.left, clientRect.bottom-1);
pDC->SelectObject(pOldPen);
}
/*
* Load an archive, using the appropriate GenericArchive subclass. If
* "createFile" is "true", a new archive file will be created (and must
* not already exist!).
*
* "filename" is the full path to the file, "extension" is the
* filetype component of the name (without the leading '.'), "filterIndex"
* is the offset into the set of filename filters used in the standard
* file dialog, "readOnly" reflects the state of the stdfile dialog
* checkbox, and "createFile" is set to true by the "New Archive" command.
*
* Returns 0 on success, nonzero on failure.
*/
int
MainWindow::LoadArchive(const char* fileName, const char* extension,
int filterIndex, bool readOnly, bool createFile)
{
GenericArchive::OpenResult openResult;
int result = -1;
GenericArchive* pOpenArchive = nil;
int origFilterIndex = filterIndex;
CString errStr, appName;
appName.LoadString(IDS_MB_APP_NAME);
WMSG3("LoadArchive: '%s' ro=%d idx=%d\n", fileName, readOnly, filterIndex);
/* close any existing archive to avoid weirdness from re-open */
CloseArchive();
/*
* If they used the "All Files (*.*)" filter, we have to guess based
* on the file type.
*
* IDEA: change the current "filterIndex ==" stuff to a type-specific
* model, then do type-scanning here. Code later on takes the type
* and opens it. That way we can do the trivial "it must be" handling
* up here, and maybe do a little "open it up and see" stuff as well.
* In general, though, if we don't recognize the extension, it's
* probably a disk image.
*/
if (filterIndex == kFilterIndexGeneric) {
int i;
for (i = 0; i < NELEM(gExtensionToIndex); i++) {
if (strcasecmp(extension, gExtensionToIndex[i].extension) == 0) {
filterIndex = gExtensionToIndex[i].idx;
break;
}
}
if (i == NELEM(gExtensionToIndex))
filterIndex = kFilterIndexDiskImage;
}
try_again:
if (filterIndex == kFilterIndexBinaryII) {
/* try Binary II and nothing else */
ASSERT(!createFile);
WMSG0(" Trying Binary II\n");
pOpenArchive = new BnyArchive;
openResult = pOpenArchive->Open(fileName, readOnly, &errStr);
if (openResult != GenericArchive::kResultSuccess) {
if (!errStr.IsEmpty())
ShowFailureMsg(this, errStr, IDS_FAILED);
result = -1;
goto bail;
}
} else
if (filterIndex == kFilterIndexACU) {
/* try ACU and nothing else */
ASSERT(!createFile);
WMSG0(" Trying ACU\n");
pOpenArchive = new AcuArchive;
openResult = pOpenArchive->Open(fileName, readOnly, &errStr);
if (openResult != GenericArchive::kResultSuccess) {
if (!errStr.IsEmpty())
ShowFailureMsg(this, errStr, IDS_FAILED);
result = -1;
goto bail;
}
} else
if (filterIndex == kFilterIndexDiskImage) {
/* try various disk image formats */
ASSERT(!createFile);
WMSG0(" Trying disk images\n");
pOpenArchive = new DiskArchive;
openResult = pOpenArchive->Open(fileName, readOnly, &errStr);
if (openResult == GenericArchive::kResultCancel) {
result = -1;
goto bail;
} else if (openResult == GenericArchive::kResultFileArchive) {
delete pOpenArchive;
pOpenArchive = nil;
if (strcasecmp(extension, "zip") == 0) {
errStr = "ZIP archives with multiple files are not supported.";
MessageBox(errStr, appName, MB_OK|MB_ICONINFORMATION);
result = -1;
goto bail;
} else {
/* assume some variation of a ShrinkIt archive */
// msg.LoadString(IDS_OPEN_AS_NUFX); <-- with MB_OKCANCEL
filterIndex = kFilterIndexNuFX;
goto try_again;
}
} else if (openResult != GenericArchive::kResultSuccess) {
if (filterIndex != origFilterIndex) {
/*
* Kluge: assume we guessed disk image and were wrong.
*/
errStr = "File doesn't appear to be a valid archive"
" or disk image.";
}
if (!errStr.IsEmpty())
ShowFailureMsg(this, errStr, IDS_FAILED);
result = -1;
goto bail;
}
} else
if (filterIndex == kFilterIndexNuFX) {
/* try NuFX (including its embedded-in-BNY form) */
WMSG0(" Trying NuFX\n");
pOpenArchive = new NufxArchive;
openResult = pOpenArchive->Open(fileName, readOnly, &errStr);
if (openResult != GenericArchive::kResultSuccess) {
if (!errStr.IsEmpty())
ShowFailureMsg(this, errStr, IDS_FAILED);
result = -1;
goto bail;
}
} else {
ASSERT(FALSE);
result = -1;
goto bail;
}
SwitchContentList(pOpenArchive);
pOpenArchive = nil;
result = 0;
bail:
if (pOpenArchive != nil) {
ASSERT(result != 0);
delete pOpenArchive;
}
return result;
}
/*
* Open a raw disk volume. Useful for ProDOS-formatted 1.44MB floppy disks
* and CFFA flash cards.
*
* Assume it's a disk image -- it'd be a weird place for a ShrinkIt archive.
* CFFA cards can actually hold multiple volumes, but that's all taken care
* of inside the diskimg DLL.
*
* Returns 0 on success, nonzero on failure.
*/
int
MainWindow::DoOpenVolume(CString drive, bool readOnly)
{
int result = -1;
ASSERT(drive.GetLength() > 0);
CString errStr;
//char filename[4] = "_:\\";
//filename[0] = driveLetter;
WMSG2("FileOpenVolume '%s' %d\n", (const char*)drive, readOnly);
/* close existing archive */
CloseArchive();
GenericArchive* pOpenArchive = nil;
pOpenArchive = new DiskArchive;
{
CWaitCursor waitc;
GenericArchive::OpenResult openResult;
openResult = pOpenArchive->Open(drive, readOnly, &errStr);
if (openResult == GenericArchive::kResultCancel) {
// this bubbles out of the format confirmation dialog
goto bail;
} else if (openResult != GenericArchive::kResultSuccess) {
if (!errStr.IsEmpty())
ShowFailureMsg(this, errStr, IDS_FAILED);
goto bail;
}
}
// success!
SwitchContentList(pOpenArchive);
pOpenArchive = nil;
fOpenArchivePathName = drive;
result = 0;
fOpenArchivePathName = drive;
SetCPTitle(fOpenArchivePathName, fpOpenArchive);
bail:
if (pOpenArchive != nil) {
ASSERT(result != 0);
delete pOpenArchive;
}
return result;
}
/*
* Close and re-open the current archive.
*/
void
MainWindow::ReopenArchive(void)
{
if (fpOpenArchive == nil) {
ASSERT(false);
return;
}
/* clear the flag, regardless of success or failure */
fNeedReopen = false;
GenericArchive* pOpenArchive = nil;
CString pathName = fpOpenArchive->GetPathName();
bool readOnly = fpOpenArchive->IsReadOnly();
GenericArchive::ArchiveKind archiveKind = fpOpenArchive->GetArchiveKind();
GenericArchive::OpenResult openResult;
CString errStr;
/* if the open fails we *don't* want to leave the previous content up */
WMSG3("Reopening '%s' ro=%d kind=%d\n", pathName, readOnly, archiveKind);
CloseArchive();
switch (archiveKind) {
case GenericArchive::kArchiveDiskImage:
pOpenArchive = new DiskArchive;
break;
case GenericArchive::kArchiveNuFX:
pOpenArchive = new NufxArchive;
break;
case GenericArchive::kArchiveBNY:
pOpenArchive = new BnyArchive;
break;
default:
ASSERT(false);
return;
}
openResult = pOpenArchive->Open(pathName, readOnly, &errStr);
if (openResult == GenericArchive::kResultCancel) {
// this bubbles out of the format confirmation dialog
goto bail;
} else if (openResult != GenericArchive::kResultSuccess) {
if (!errStr.IsEmpty())
ShowFailureMsg(this, errStr, IDS_FAILED);
goto bail;
}
WMSG0(" Reopen was successful\n");
SwitchContentList(pOpenArchive);
pOpenArchive = nil;
SetCPTitle(pathName, fpOpenArchive);
bail:
delete pOpenArchive;
}
/*
* Determine whether "path" matches the pathname of the currently open archive.
*/
bool
MainWindow::IsOpenPathName(const char* path)
{
if (fpOpenArchive == nil)
return false;
if (stricmp(path, fpOpenArchive->GetPathName()) == 0)
return true;
return false;
}
/*
* Switch the content list to a new archive, closing the previous if one
* was already open.
*/
void
MainWindow::SwitchContentList(GenericArchive* pOpenArchive)
{
assert(pOpenArchive != nil);
/*
* We've got an archive opened successfully. If we already had one
* open, shut it. (This assumes that closing an archive is a simple
* matter of closing files and freeing storage. If we needed to do
* something that might fail, like flush changes, we should've done
* that before getting this far to avoid confusion.)
*/
if (fpOpenArchive != nil)
CloseArchive();
ASSERT(fpOpenArchive == nil);
ASSERT(fpContentList == nil);
/*
* Without this we get an assertion failure in CImageList::Attach if we
* call here from ReopenArchive. I think Windows needs to do some
* cleanup, though I don't understand how the reopen case differs from
* the usual case. Maybe there's more stuff pending in the "reopen"
* case? In any event, this seems to work, which is all you can hope
* for from MFC. It does, however, make the screen flash, which it
* didn't do before.
*
* UPDATE: this tripped once while I was debugging, even with this. The
* PeekAndPump function does force the idle loop to run, so I'm not sure
* why it failed, unless the debugger somehow affected the idle
* processing. Yuck.
*
* The screen flash bugged me so I took it back out. And the assert
* didn't hit. I really, really love Windows.
*/
//PeekAndPump();
fpContentList = new ContentList(pOpenArchive,
fPreferences.GetColumnLayout());
CRect sizeRect;
GetClientRect(&sizeRect);
fpContentList->Create(WS_CHILD | WS_VISIBLE | WS_VSCROLL,
sizeRect, this, IDC_CONTENT_LIST);
fpOpenArchive = pOpenArchive;
}
/*
* Close the existing archive file, but don't try to shut down the child
* windows. This should really only be used from the destructor.
*/
void
MainWindow::CloseArchiveWOControls(void)
{
if (fpOpenArchive != nil) {
//fpOpenArchive->Close();
WMSG0("Deleting OpenArchive\n");
delete fpOpenArchive;
fpOpenArchive = nil;
}
}
/*
* Close the existing archive file, and throw out the control we're
* using to display it.
*/
void
MainWindow::CloseArchive(void)
{
CWaitCursor waitc; // closing large compressed archive can be slow
// destroy the ContentList
if (fpContentList != nil) {
WMSG0("Destroying ContentList\n");
fpContentList->DestroyWindow(); // auto-cleanup invokes "delete"
fpContentList = nil;
}
// destroy the GenericArchive
CloseArchiveWOControls();
// reset the title bar
SetCPTitle();
}
/*
* Set the title bar on the main window.
*
* "pathname" is often different from pOpenArchive->GetPathName(), especially
* when we were launched from another instance of CiderPress and handed a
* temp file whose name we're trying to conceal.
*/
void
MainWindow::SetCPTitle(const char* pathname, GenericArchive* pOpenArchive)
{
ASSERT(pathname != nil);
CString title;
CString archiveDescription;
CString appName;
appName.LoadString(IDS_MB_APP_NAME);
pOpenArchive->GetDescription(&archiveDescription);
title.Format(_T("%s - %s (%s)"), appName, pathname, archiveDescription);
if (fpOpenArchive->IsReadOnly()) {
CString readOnly;
readOnly.LoadString(IDS_READONLY);
title += _T(" ");
title += readOnly;
}
SetWindowText(title);
}
/*
* Set the title bar to something boring when nothing is open.
*/
void
MainWindow::SetCPTitle(void)
{
CString appName, regName, title;
CString user, company, reg, versions, expire;
#if 0
if (gMyApp.fRegistry.GetRegistration(&user, &company, &reg, &versions,
&expire) == 0)
{
if (reg.IsEmpty()) {
regName += _T(" (unregistered)");
} else {
regName += _T(" (registered to ");
regName += user;
regName += _T(")");
// include company?
}
}
#endif
appName.LoadString(IDS_MB_APP_NAME);
title = appName + regName;
SetWindowText(title);
}
/*
* Come up with a title to put at the top of a printout. This is essentially
* the same as the window title, but without some flags (e.g. "read-only").
*/
CString
MainWindow::GetPrintTitle(void)
{
CString title;
CString archiveDescription;
CString appName;
if (fpOpenArchive == nil) {
ASSERT(false);
return title;
}
appName.LoadString(IDS_MB_APP_NAME);
fpOpenArchive->GetDescription(&archiveDescription);
title.Format(_T("%s - %s (%s)"),
appName, fOpenArchivePathName, archiveDescription);
return title;
}
/*
* After successful completion of a command, make a happy noise (but only
* if we're configured to do so).
*/
void
MainWindow::SuccessBeep(void)
{
const Preferences* pPreferences = GET_PREFERENCES();
if (pPreferences->GetPrefBool(kPrBeepOnSuccess)) {
WMSG0("<happy-beep>\n");
::MessageBeep(MB_OK);
}
}
/*
* If something fails, make noise if we're configured for loudness.
*/
void
MainWindow::FailureBeep(void)
{
const Preferences* pPreferences = GET_PREFERENCES();
if (pPreferences->GetPrefBool(kPrBeepOnSuccess)) {
WMSG0("<failure-beep>\n");
::MessageBeep(MB_ICONEXCLAMATION); // maybe MB_ICONHAND?
}
}
/*
* Remove a file. Returns a helpful error string on failure.
*
* The absence of the file is not considered an error.
*/
CString
MainWindow::RemoveFile(const char* fileName)
{
CString errMsg;
int cc;
cc = unlink(fileName);
if (cc < 0 && errno != ENOENT) {
int err = errno;
WMSG2("Failed removing file '%s', errno=%d\n", fileName, err);
errMsg.Format("Unable to remove '%s': %s.",
fileName, strerror(err));
if (err == EACCES)
errMsg += "\n\n(Make sure the file isn't open.)";
}
return errMsg;
}
/*
* Configure a ReformatHolder based on the current preferences.
*/
/*static*/ void
MainWindow::ConfigureReformatFromPreferences(ReformatHolder* pReformat)
{
const Preferences* pPreferences = GET_PREFERENCES();
pReformat->SetReformatAllowed(ReformatHolder::kReformatRaw, true);
pReformat->SetReformatAllowed(ReformatHolder::kReformatHexDump, true);
pReformat->SetReformatAllowed(ReformatHolder::kReformatTextEOL_HA,
pPreferences->GetPrefBool(kPrConvTextEOL_HA));
pReformat->SetReformatAllowed(ReformatHolder::kReformatResourceFork,
pPreferences->GetPrefBool(kPrConvResources));
pReformat->SetReformatAllowed(ReformatHolder::kReformatProDOSDirectory,
pPreferences->GetPrefBool(kPrConvProDOSFolder));
pReformat->SetReformatAllowed(ReformatHolder::kReformatPascalText,
pPreferences->GetPrefBool(kPrConvPascalText));
pReformat->SetReformatAllowed(ReformatHolder::kReformatPascalCode,
pPreferences->GetPrefBool(kPrConvPascalCode));
pReformat->SetReformatAllowed(ReformatHolder::kReformatCPMText,
pPreferences->GetPrefBool(kPrConvCPMText));
pReformat->SetReformatAllowed(ReformatHolder::kReformatApplesoft,
pPreferences->GetPrefBool(kPrConvApplesoft));
pReformat->SetReformatAllowed(ReformatHolder::kReformatApplesoft_Hilite,
pPreferences->GetPrefBool(kPrConvApplesoft));
pReformat->SetReformatAllowed(ReformatHolder::kReformatInteger,
pPreferences->GetPrefBool(kPrConvInteger));
pReformat->SetReformatAllowed(ReformatHolder::kReformatInteger_Hilite,
pPreferences->GetPrefBool(kPrConvInteger));
pReformat->SetReformatAllowed(ReformatHolder::kReformatSCAssem,
pPreferences->GetPrefBool(kPrConvSCAssem));
pReformat->SetReformatAllowed(ReformatHolder::kReformatMerlin,
pPreferences->GetPrefBool(kPrConvSCAssem));
pReformat->SetReformatAllowed(ReformatHolder::kReformatLISA2,
pPreferences->GetPrefBool(kPrConvSCAssem));
pReformat->SetReformatAllowed(ReformatHolder::kReformatLISA3,
pPreferences->GetPrefBool(kPrConvSCAssem));
pReformat->SetReformatAllowed(ReformatHolder::kReformatLISA4,
pPreferences->GetPrefBool(kPrConvSCAssem));
pReformat->SetReformatAllowed(ReformatHolder::kReformatMonitor8,
pPreferences->GetPrefBool(kPrConvDisasm));
pReformat->SetReformatAllowed(ReformatHolder::kReformatDisasmMerlin8,
pPreferences->GetPrefBool(kPrConvDisasm));
pReformat->SetReformatAllowed(ReformatHolder::kReformatMonitor16Long,
pPreferences->GetPrefBool(kPrConvDisasm));
pReformat->SetReformatAllowed(ReformatHolder::kReformatMonitor16Short,
pPreferences->GetPrefBool(kPrConvDisasm));
pReformat->SetReformatAllowed(ReformatHolder::kReformatDisasmOrcam16,
pPreferences->GetPrefBool(kPrConvDisasm));
pReformat->SetReformatAllowed(ReformatHolder::kReformatAWGS_WP,
pPreferences->GetPrefBool(kPrConvGWP));
pReformat->SetReformatAllowed(ReformatHolder::kReformatTeach,
pPreferences->GetPrefBool(kPrConvGWP));
pReformat->SetReformatAllowed(ReformatHolder::kReformatGWP,
pPreferences->GetPrefBool(kPrConvGWP));
pReformat->SetReformatAllowed(ReformatHolder::kReformatMagicWindow,
pPreferences->GetPrefBool(kPrConvText8));
pReformat->SetReformatAllowed(ReformatHolder::kReformatAWP,
pPreferences->GetPrefBool(kPrConvAWP));
pReformat->SetReformatAllowed(ReformatHolder::kReformatAWP,
pPreferences->GetPrefBool(kPrConvAWP));
pReformat->SetReformatAllowed(ReformatHolder::kReformatADB,
pPreferences->GetPrefBool(kPrConvADB));
pReformat->SetReformatAllowed(ReformatHolder::kReformatASP,
pPreferences->GetPrefBool(kPrConvASP));
pReformat->SetReformatAllowed(ReformatHolder::kReformatHiRes,
pPreferences->GetPrefBool(kPrConvHiRes));
pReformat->SetReformatAllowed(ReformatHolder::kReformatHiRes_BW,
pPreferences->GetPrefBool(kPrConvHiRes));
pReformat->SetReformatAllowed(ReformatHolder::kReformatDHR_Latched,
pPreferences->GetPrefBool(kPrConvDHR));
pReformat->SetReformatAllowed(ReformatHolder::kReformatDHR_BW,
pPreferences->GetPrefBool(kPrConvDHR));
pReformat->SetReformatAllowed(ReformatHolder::kReformatDHR_Plain140,
pPreferences->GetPrefBool(kPrConvDHR));
pReformat->SetReformatAllowed(ReformatHolder::kReformatDHR_Window,
pPreferences->GetPrefBool(kPrConvDHR));
pReformat->SetReformatAllowed(ReformatHolder::kReformatSHR_PIC,
pPreferences->GetPrefBool(kPrConvSHR));
pReformat->SetReformatAllowed(ReformatHolder::kReformatSHR_JEQ,
pPreferences->GetPrefBool(kPrConvSHR));
pReformat->SetReformatAllowed(ReformatHolder::kReformatSHR_Paintworks,
pPreferences->GetPrefBool(kPrConvSHR));
pReformat->SetReformatAllowed(ReformatHolder::kReformatSHR_Packed,
pPreferences->GetPrefBool(kPrConvSHR));
pReformat->SetReformatAllowed(ReformatHolder::kReformatSHR_APF,
pPreferences->GetPrefBool(kPrConvSHR));
pReformat->SetReformatAllowed(ReformatHolder::kReformatSHR_3200,
pPreferences->GetPrefBool(kPrConvSHR));
pReformat->SetReformatAllowed(ReformatHolder::kReformatSHR_3201,
pPreferences->GetPrefBool(kPrConvSHR));
pReformat->SetReformatAllowed(ReformatHolder::kReformatSHR_DG256,
pPreferences->GetPrefBool(kPrConvSHR));
pReformat->SetReformatAllowed(ReformatHolder::kReformatSHR_DG3200,
pPreferences->GetPrefBool(kPrConvSHR));
pReformat->SetReformatAllowed(ReformatHolder::kReformatPrintShop,
pPreferences->GetPrefBool(kPrConvPrintShop));
pReformat->SetReformatAllowed(ReformatHolder::kReformatMacPaint,
pPreferences->GetPrefBool(kPrConvMacPaint));
pReformat->SetOption(ReformatHolder::kOptHiliteHexDump,
pPreferences->GetPrefBool(kPrHighlightHexDump));
pReformat->SetOption(ReformatHolder::kOptHiliteBASIC,
pPreferences->GetPrefBool(kPrHighlightBASIC));
pReformat->SetOption(ReformatHolder::kOptHiResBW,
pPreferences->GetPrefBool(kPrConvHiResBlackWhite));
pReformat->SetOption(ReformatHolder::kOptDHRAlgorithm,
pPreferences->GetPrefLong(kPrConvDHRAlgorithm));
pReformat->SetOption(ReformatHolder::kOptRelaxGfxTypeCheck,
pPreferences->GetPrefBool(kPrRelaxGfxTypeCheck));
pReformat->SetOption(ReformatHolder::kOptOneByteBrkCop,
pPreferences->GetPrefBool(kPrDisasmOneByteBrkCop));
}
/*
* Convert a DiskImg format spec into a ReformatHolder SourceFormat.
*/
/*static*/ ReformatHolder::SourceFormat
MainWindow::ReformatterSourceFormat(DiskImg::FSFormat format)
{
if (DiskImg::UsesDOSFileStructure(format))
return ReformatHolder::kSourceFormatDOS;
else if (format == DiskImg::kFormatCPM)
return ReformatHolder::kSourceFormatCPM;
else
return ReformatHolder::kSourceFormatGeneric;
}