mirror of
https://github.com/fadden/ciderpress.git
synced 2024-11-26 17:49:21 +00:00
814872966e
The previous code was a stickler for only opening files whose type
matched what was selected in the filter pop-up. The original goal
was to allow you to choose whether a BXY or SDK file was interpreted
as Binary II, ShrinkIt, or disk image, since they could go either
way. Unfortunately, its refusal to consider types other than what
was selected made it kind of annoying.
The new code will start by trying to open the file with the selected
filter, so that it's still possible to choose how SDK and BXY files
are opened. However, it now continues on, trying all other types
before finally giving up.
If the generic ("*.*") filter is selected, CiderPress will start by
trying to open the file as a disk image.
This seems to produce good results with a variety of known and
unknown files.
417 lines
14 KiB
C++
417 lines
14 KiB
C++
/*
|
|
* CiderPress
|
|
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
|
|
* See the file LICENSE for distribution terms.
|
|
*/
|
|
/*
|
|
* Disk image "archive" support.
|
|
*/
|
|
#ifndef APP_DISKARCHIVE_H
|
|
#define APP_DISKARCHIVE_H
|
|
|
|
#include "GenericArchive.h"
|
|
#include "../diskimg/DiskImg.h"
|
|
|
|
class RenameEntryDialog;
|
|
|
|
|
|
/*
|
|
* One file in a disk image.
|
|
*/
|
|
class DiskEntry : public GenericEntry {
|
|
public:
|
|
DiskEntry(A2File* pFile) : fpFile(pFile)
|
|
{}
|
|
virtual ~DiskEntry(void) {}
|
|
|
|
virtual int ExtractThreadToBuffer(int which, char** ppText, long* pLength,
|
|
CString* pErrMsg) const override;
|
|
virtual int ExtractThreadToFile(int which, FILE* outfp, ConvertEOL conv,
|
|
ConvertHighASCII convHA, CString* pErrMsg) const override;
|
|
|
|
virtual long GetSelectionSerial(void) const override
|
|
{ return -1; } // idea: T/S block number
|
|
|
|
/*
|
|
* Figure out whether or not we're allowed to change a file's type and
|
|
* aux type.
|
|
*/
|
|
virtual bool GetFeatureFlag(Feature feature) const override;
|
|
|
|
// return the underlying FS format for this file
|
|
virtual DiskImg::FSFormat GetFSFormat(void) const {
|
|
ASSERT(fpFile != NULL);
|
|
return fpFile->GetFSFormat();
|
|
}
|
|
|
|
A2File* GetA2File(void) const { return fpFile; }
|
|
void SetA2File(A2File* pFile) { fpFile = pFile; }
|
|
|
|
private:
|
|
/*
|
|
* Copy data from the open A2File to outfp, possibly converting EOL along
|
|
* the way.
|
|
*/
|
|
DIError CopyData(A2FileDescr* pOpenFile, FILE* outfp, ConvertEOL conv,
|
|
ConvertHighASCII convHA, CString* pMsg) const;
|
|
|
|
A2File* fpFile;
|
|
};
|
|
|
|
|
|
/*
|
|
* Disk image add-ons to GenericArchive.
|
|
*/
|
|
class DiskArchive : public GenericArchive {
|
|
public:
|
|
DiskArchive(void) : fpPrimaryDiskFS(NULL), fIsReadOnly(false),
|
|
fpAddDataHead(NULL), fpAddDataTail(NULL)
|
|
{}
|
|
virtual ~DiskArchive(void) { (void) Close(); }
|
|
|
|
/* pass this as the "options" value to the New() function */
|
|
typedef struct {
|
|
DiskImgLib::DiskImg::FSFormat format;
|
|
DiskImgLib::DiskImg::SectorOrder sectorOrder;
|
|
} NewOptionsBase;
|
|
typedef union {
|
|
NewOptionsBase base;
|
|
|
|
struct {
|
|
NewOptionsBase base;
|
|
long numBlocks;
|
|
} blank;
|
|
struct {
|
|
NewOptionsBase base;
|
|
const WCHAR* volName;
|
|
long numBlocks;
|
|
} prodos;
|
|
struct {
|
|
NewOptionsBase base;
|
|
const WCHAR* volName;
|
|
long numBlocks;
|
|
} pascalfs; // "pascal" is reserved token in MSVC++
|
|
struct {
|
|
NewOptionsBase base;
|
|
const WCHAR* volName;
|
|
long numBlocks;
|
|
} hfs;
|
|
struct {
|
|
NewOptionsBase base;
|
|
int volumeNum;
|
|
long numTracks;
|
|
int numSectors;
|
|
bool allocDOSTracks;
|
|
} dos;
|
|
} NewOptions;
|
|
|
|
/*
|
|
* Perform one-time initialization of the DiskLib library.
|
|
*/
|
|
static CString AppInit(void);
|
|
|
|
/*
|
|
* Perform one-time cleanup of DiskImgLib at shutdown time.
|
|
*/
|
|
static void AppCleanup(void);
|
|
|
|
/*
|
|
* Finish instantiating a DiskArchive object by opening an existing file.
|
|
*/
|
|
virtual OpenResult Open(const WCHAR* filename, bool readOnly,
|
|
CString* pErrMsg) override;
|
|
|
|
/*
|
|
* Finish instantiating a DiskArchive object by creating a new archive.
|
|
*
|
|
* Returns an error string on failure, or "" on success.
|
|
*/
|
|
virtual CString New(const WCHAR* filename, const void* options) override;
|
|
|
|
/*
|
|
* Flush the DiskArchive object.
|
|
*
|
|
* Most of the stuff we do with disk images goes straight through, but in
|
|
* the case of compressed disks we don't normally re-compress them until
|
|
* it's time to close them. This forces us to update the copy on disk.
|
|
*
|
|
* Returns an empty string on success, or an error message on failure.
|
|
*/
|
|
virtual CString Flush(void) override;
|
|
|
|
/*
|
|
* Reload the stuff from the underlying DiskFS.
|
|
*
|
|
* This also does a "lite" flush of the disk data. For files that are
|
|
* essentially being written as we go, this does little more than clear
|
|
* the "dirty" flag. Files that need to be recompressed or have some
|
|
* other slow operation remain dirty.
|
|
*
|
|
* We don't need to do the flush as part of the reload -- we can load the
|
|
* contents with everything in a perfectly dirty state. We don't need to
|
|
* do it at all. We do it to keep the "dirty" flag clear when nothing is
|
|
* really dirty, and we do it here because almost all of our functions call
|
|
* "reload" after making changes, which makes it convenient to call from here.
|
|
*/
|
|
virtual CString Reload(void) override;
|
|
|
|
/*
|
|
* Returns true if the archive has un-flushed modifications pending.
|
|
*/
|
|
virtual bool IsModified(void) const override;
|
|
|
|
/*
|
|
* Return an description of the disk archive, suitable for display in the
|
|
* main title bar.
|
|
*/
|
|
virtual CString GetDescription() const override;
|
|
|
|
virtual bool BulkAdd(ActionProgressDialog* pActionProgress,
|
|
const AddFilesDialog* pAddOpts) override;
|
|
virtual bool AddDisk(ActionProgressDialog* pActionProgress,
|
|
const AddFilesDialog* pAddOpts) override
|
|
{ ASSERT(false); return false; }
|
|
virtual bool CreateSubdir(CWnd* pMsgWnd, GenericEntry* pParentEntry,
|
|
const WCHAR* newName) override;
|
|
virtual bool TestSelection(CWnd* pMsgWnd, SelectionSet* pSelSet) override
|
|
{ ASSERT(false); return false; }
|
|
virtual bool DeleteSelection(CWnd* pMsgWnd, SelectionSet* pSelSet) override;
|
|
virtual bool RenameSelection(CWnd* pMsgWnd, SelectionSet* pSelSet) override;
|
|
virtual CString TestPathName(const GenericEntry* pGenericEntry,
|
|
const CString& basePath, const CString& newName,
|
|
char newFssep) const override;
|
|
virtual bool RenameVolume(CWnd* pMsgWnd, DiskFS* pDiskFS,
|
|
const WCHAR* newName) override;
|
|
virtual CString TestVolumeName(const DiskFS* pDiskFS,
|
|
const WCHAR* newName) const override;
|
|
virtual bool RecompressSelection(CWnd* pMsgWnd, SelectionSet* pSelSet,
|
|
const RecompressOptionsDialog* pRecompOpts) override
|
|
{ ASSERT(false); return false; }
|
|
virtual bool GetComment(CWnd* pMsgWnd, const GenericEntry* pEntry,
|
|
CString* pStr) override
|
|
{ ASSERT(false); return false; }
|
|
virtual bool SetComment(CWnd* pMsgWnd, GenericEntry* pEntry,
|
|
const CString& str) override
|
|
{ ASSERT(false); return false; }
|
|
virtual bool DeleteComment(CWnd* pMsgWnd, GenericEntry* pEntry) override
|
|
{ ASSERT(false); return false; }
|
|
virtual bool SetProps(CWnd* pMsgWnd, GenericEntry* pEntry,
|
|
const FileProps* pProps) override;
|
|
|
|
/*
|
|
* User has updated their preferences. Take note.
|
|
*
|
|
* Setting preferences in a DiskFS causes those prefs to be pushed down
|
|
* to all sub-volumes.
|
|
*/
|
|
virtual void PreferencesChanged(void) override;
|
|
|
|
virtual long GetCapability(Capability cap) override;
|
|
virtual XferStatus XferSelection(CWnd* pMsgWnd, SelectionSet* pSelSet,
|
|
ActionProgressDialog* pActionProgress,
|
|
const XferFileOptions* pXferOpts) override;
|
|
|
|
virtual bool IsReadOnly(void) const { return fIsReadOnly; }
|
|
const DiskImg* GetDiskImg(void) const { return &fDiskImg; }
|
|
DiskFS* GetDiskFS(void) const { return fpPrimaryDiskFS; }
|
|
|
|
/*
|
|
* Progress update callback, called from DiskImgLib during read/write
|
|
* operations.
|
|
*
|
|
* Returns "true" if we should continue;
|
|
*/
|
|
static bool ProgressCallback(DiskImgLib::A2FileDescr* pFile,
|
|
DiskImgLib::di_off_t max, DiskImgLib::di_off_t current, void* state);
|
|
|
|
private:
|
|
/*
|
|
* Close the DiskArchive ojbect.
|
|
*/
|
|
virtual CString Close(void);
|
|
|
|
virtual void XferPrepare(const XferFileOptions* pXferOpts) override;
|
|
virtual CString XferFile(LocalFileDetails* pDetails, uint8_t** pDataBuf,
|
|
long dataLen, uint8_t** pRsrcBuf, long rsrcLen) override;
|
|
virtual void XferAbort(CWnd* pMsgWnd) override;
|
|
virtual void XferFinish(CWnd* pMsgWnd) override;
|
|
|
|
/*
|
|
* Progress update callback, called from DiskImgLib while scanning a volume
|
|
* during Open().
|
|
*
|
|
* "str" must not contain a '%'. (TODO: fix that)
|
|
*
|
|
* Returns "true" if we should continue.
|
|
*/
|
|
static bool ScanProgressCallback(void* cookie, const char* str,
|
|
int count);
|
|
|
|
|
|
/*
|
|
* Internal class used to keep track of files we're adding.
|
|
*/
|
|
class FileAddData {
|
|
public:
|
|
FileAddData(const LocalFileDetails* pDetails, char* fsNormalPathMOR) {
|
|
fDetails = *pDetails;
|
|
|
|
fFSNormalPathMOR = fsNormalPathMOR;
|
|
fpOtherFork = NULL;
|
|
fpNext = NULL;
|
|
}
|
|
virtual ~FileAddData(void) {}
|
|
|
|
FileAddData* GetNext(void) const { return fpNext; }
|
|
void SetNext(FileAddData* pNext) { fpNext = pNext; }
|
|
FileAddData* GetOtherFork(void) const { return fpOtherFork; }
|
|
void SetOtherFork(FileAddData* pData) { fpOtherFork = pData; }
|
|
|
|
const LocalFileDetails* GetDetails(void) const { return &fDetails; }
|
|
|
|
/*
|
|
* Get the "FS-normal" path, i.e. exactly what we want to appear
|
|
* on the disk image. This has the result of any conversions, so
|
|
* we need to store it as a narrow Mac OS Roman string.
|
|
*/
|
|
const char* GetFSNormalPath(void) const { return fFSNormalPathMOR; }
|
|
|
|
private:
|
|
LocalFileDetails fDetails;
|
|
|
|
// The DiskFS-normalized version of the storage name. This is the
|
|
// name as it will appear on the Apple II disk image.
|
|
CStringA fFSNormalPathMOR;
|
|
|
|
FileAddData* fpOtherFork;
|
|
FileAddData* fpNext;
|
|
};
|
|
|
|
virtual ArchiveKind GetArchiveKind(void) override { return kArchiveDiskImage; }
|
|
virtual NuError DoAddFile(const AddFilesDialog* pAddOpts,
|
|
LocalFileDetails* pDetails) override;
|
|
|
|
/*
|
|
* Reload the contents of the archive, showing an error message if the
|
|
* reload fails.
|
|
*
|
|
* Returns 0 on success, -1 on failure.
|
|
*/
|
|
int InternalReload(CWnd* pMsgWnd);
|
|
|
|
/*
|
|
* Compare DiskEntry display names in descending order (Z-A).
|
|
*/
|
|
static int CompareDisplayNamesDesc(const void* ventry1, const void* ventry2);
|
|
|
|
/*
|
|
* Load the contents of a "disk archive". Returns 0 on success.
|
|
*/
|
|
int LoadContents(void);
|
|
|
|
/*
|
|
* Load the contents of a DiskFS.
|
|
*
|
|
* Recursively handle sub-volumes. "volName" holds the name of the
|
|
* sub-volume as it should appear in the list.
|
|
*/
|
|
int LoadDiskFSContents(DiskFS* pDiskFS, const WCHAR* volName);
|
|
|
|
void DowncaseSubstring(CString* pStr, int startPos, int endPos,
|
|
bool prevWasSpace);
|
|
|
|
/*
|
|
* Handle a debug message from the DiskImg library.
|
|
*/
|
|
static void DebugMsgHandler(const char* file, int line, const char* msg);
|
|
|
|
/*
|
|
* A file we're adding clashes with an existing file. Decide what to do
|
|
* about it.
|
|
*
|
|
* Returns one of the following:
|
|
* kNuOverwrite - overwrite the existing file
|
|
* kNuSkip - skip adding the existing file
|
|
* kNuRename - user wants to rename the file
|
|
* kNuAbort - cancel out of the entire add process
|
|
*
|
|
* Side effects:
|
|
* Sets fOverwriteExisting and fOverwriteNoAsk if a "to all" button is hit
|
|
* Replaces pDetails->storageName if the user elects to rename
|
|
*/
|
|
NuResult HandleReplaceExisting(const A2File* pExisting,
|
|
LocalFileDetails* pDetails);
|
|
|
|
/*
|
|
* Process the list of pending file adds.
|
|
*
|
|
* This is where the rubber (finally!) meets the road.
|
|
*/
|
|
CString ProcessFileAddData(DiskFS* pDiskFS, int addOptsConvEOL);
|
|
|
|
/*
|
|
* Load a file into a buffer, possibly converting EOL markers and setting
|
|
* "high ASCII" along the way.
|
|
*
|
|
* Returns a pointer to a newly-allocated buffer (new[]) and the data length.
|
|
* If the file is empty, no buffer will be allocated.
|
|
*
|
|
* Returns an empty string on success, or an error message on failure.
|
|
*/
|
|
CString LoadFile(const WCHAR* pathName, uint8_t** pBuf, long* pLen,
|
|
GenericEntry::ConvertEOL conv, GenericEntry::ConvertHighASCII convHA) const;
|
|
|
|
/*
|
|
* Add a file with the supplied data to the disk image.
|
|
*
|
|
* Forks that exist but are empty have a length of zero. Forks that don't
|
|
* exist have a length of -1.
|
|
*
|
|
* Called by XferFile and ProcessFileAddData.
|
|
*/
|
|
DIError AddForksToDisk(DiskFS* pDiskFS, const DiskFS::CreateParms* pParms,
|
|
const uint8_t* dataBuf, long dataLen,
|
|
const uint8_t* rsrcBuf, long rsrcLen) const;
|
|
|
|
/*
|
|
* Add an entry to the end of the FileAddData list.
|
|
*
|
|
* If "storageName" (the Windows filename with type goodies stripped, but
|
|
* without filesystem normalization) matches an entry already in the list,
|
|
* we check to see if these are forks of the same file. If they are
|
|
* different forks and we don't already have both forks, we put the
|
|
* pointer into the "fork pointer" of the existing file rather than adding
|
|
* it to the end of the list.
|
|
*/
|
|
void AddToAddDataList(FileAddData* pData);
|
|
|
|
/*
|
|
* Free all entries in the FileAddData list.
|
|
*/
|
|
void FreeAddDataList(void);
|
|
|
|
/*
|
|
* Set up a RenameEntryDialog for the entry in "*pEntry".
|
|
*
|
|
* Returns true on success, false on failure.
|
|
*/
|
|
bool SetRenameFields(CWnd* pMsgWnd, DiskEntry* pEntry,
|
|
RenameEntryDialog* pDialog);
|
|
|
|
DiskImg fDiskImg; // DiskImg object for entire disk
|
|
DiskFS* fpPrimaryDiskFS; // outermost DiskFS
|
|
bool fIsReadOnly;
|
|
|
|
/* active state while adding files */
|
|
FileAddData* fpAddDataHead;
|
|
FileAddData* fpAddDataTail;
|
|
bool fOverwriteExisting;
|
|
bool fOverwriteNoAsk;
|
|
|
|
/* state during xfer */
|
|
//CString fXferStoragePrefix;
|
|
DiskFS* fpXferTargetFS;
|
|
};
|
|
|
|
#endif /*APP_DISKARCHIVE_H*/
|