Subversion Repositories autosfx

unit ZipMstr19;

(*

  ZipMstr19.pas - main component

  TZipMaster19 VCL by Chris Vleghert and Eric W. Engler

  v1.9

  Copyright (C) 2009, 2010  Russell Peters

  This library is free software; you can redistribute it and/or

  modify it under the terms of the GNU Lesser General Public

  License as published by the Free Software Foundation; either

  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  Lesser General Public License (licence.txt) for more details.

  You should have received a copy of the GNU Lesser General Public License

  along with this library; if not, write to the Free Software Foundation, Inc.,

  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

  contact: problems AT delphizip DOT org

  updates: http://www.delphizip.org

  modified 2010-08-06

---------------------------------------------------------------------------*)

{$I '.\ZipVers19.inc'}

{$I '.\ZMConfig19.inc'}

interface

uses

  Classes, SysUtils, Graphics, Dialogs, Windows, Controls,

  ZMXcpt19, ZMStructs19;

const

  ZIPMASTERBUILD: String =  '1.9.0.0102';

  ZIPMASTERDATE: String  =  '11/09/2010';

  ZIPMASTERPRIV: Integer = 1900102;

  DELZIPVERSION          = 190;

const

  ZMReentry_Error: Integer = $4000000;

const

  ZMPWLEN = 80;

type

{$IFDEF UNICODE}

  TZMString     = String; // unicode

  TZMWideString = String;

  TZMRawBytes = RawByteString;

{$ELSE}

  {$IFNDEF VERD6up}

  UTF8String    = type String;

  {$ENDIF}

  TZMString     = AnsiString;  // Ansi/UTF8 depending upon UseUTF8

  TZMWideString = WideString;

  TZMRawBytes =  AnsiString;        

{$ENDIF}

type

  TZMStates = (zsDisabled, zsIdle, zsBusy);

  // options when editing a zip

  TZMAddOptsEnum = (AddDirNames, AddRecurseDirs, AddMove, AddFreshen, AddUpdate,

    AddHiddenFiles, AddArchiveOnly, AddResetArchive, AddEncrypt, AddEmptyDirs,

//    AddNoSeparateDirs, renamed and inverted - was AddSeparateDirs

    AddVolume, AddFromDate, AddSafe, AddVersion, AddNTFS);

  TZMAddOpts     = set of TZMAddOptsEnum;

  //the EncodeAs values (writing) -

  // zeoUPATH - convert to Ansi but have UTF8 proper name in data

  // zeoUTF  - convert to UTF8

  // zeoOEM  - convert to OEM

  // zeoNone - store 'as is' (Ansi on Windows)

  // 'default' (zeoAuto) - [in order of preference]

  //      is Ansi - use zeoNone

  //      can be converted to Ansi - use zeoUPath (unless comment also extended)

  //      use zeoUTF8

  //Encoded (reading)

  // zeoUPATH- use UPATH if available

  // zeoUTF  - assume name is UTF8 - convert to Ansi/Unicode

  // zeoOEM  - assume name is OEM - convert to Ansi/Unicode

  // zeoNone - assume name is Ansi - convert to Ansi/Unicode

  // zeoAuto - unless flags/versions say otherwise, or it has UTF8 name in data,

  //             treat it as OEM (FAT) / Ansi (NTFS)

  TZMEncodingOpts = (zeoAuto, zeoNone, zeoOEM, zeoUTF8, zeoUPath);

  // When changing this enum also change the pointer array in the function AddSuffix,

  // and the initialisation of ZipMaster.

  TZMAddStoreSuffixEnum = (assGIF, assPNG, assZ, assZIP, assZOO, assARC,

    assLZH, assARJ, assTAZ, assTGZ, assLHA, assRAR,

    assACE, assCAB, assGZ, assGZIP, assJAR, assEXE, assEXT,

    assJPG, assJPEG, ass7Zp, assMP3, assWMV, assWMA, assDVR, assAVI);

  TZMAddStoreExts = set of TZMAddStoreSuffixEnum;

  TZMSpanOptsEnum = (spNoVolumeName, spCompatName, spWipeFiles,

    spTryFormat, spAnyTime, spExactName);

  TZMSpanOpts     = set of TZMSpanOptsEnum;

  // options for when reading a zip file

  TZMExtrOptsEnum = (ExtrDirNames, ExtrOverWrite, ExtrFreshen, ExtrUpdate,

    ExtrTest, ExtrForceDirs, ExtrNTFS);

  TZMExtrOpts     = set of TZMExtrOptsEnum;

  // options for when writing a zip file

  TZMWriteOptsEnum = (zwoDiskSpan, zwoZipTime, zwoForceDest);

  TZMWriteOpts = set of TZMWriteOptsEnum;

  // other options

  TZMMergeOpts = (zmoConfirm, zmoAlways, zmoNewer, zmoOlder, zmoNever);

  TZMOvrOpts   = (ovrAlways, ovrNever, ovrConfirm);

  TZMReplaceOpts = (rplConfirm, rplAlways, rplNewer, rplNever);

  TZMDeleteOpts = (htdFinal, htdAllowUndo);

  TZMRenameOpts = (htrDefault, htrOnce, htrFull);

  TZMSkipTypes = (stOnFreshen, stNoOverwrite, stFileExists, stBadPassword,

    stBadName, stCompressionUnknown, stUnknownZipHost, stZipFileFormatWrong,

    stGeneralExtractError, stUser, stCannotDo, stNotFound,

    // opening files  (Zip)

    stNoShare, stNoAccess, stNoOpen, stDupName, stReadError, stSizeChange

    );

  TZMSkipAborts = set of TZMSkipTypes;

  TZMZipDiskStatusEnum = (zdsEmpty, zdsHasFiles, zdsPreviousDisk, zdsSameFileName,

    zdsNotEnoughSpace);

  TZMZipDiskStatus     = set of TZMZipDiskStatusEnum;

  TZMDiskAction        = (zdaYesToAll, zdaOk, zdaErase, zdaReject, zdaCancel);

  TZMDeflates = (zmStore, zmStoreEncrypt, zmDeflate, zmDeflateEncrypt);

type

  TZMSFXOpt = (

    soAskCmdLine,     // allow user to prevent execution of the command line

    soAskFiles,       // allow user to prevent certain files from extraction

    soHideOverWriteBox, // do not allow user to choose the overwrite mode

    soAutoRun,        // start extraction + evtl. command line automatically

    //                  only if sfx filename starts with "!" or is "setup.exe"

    soNoSuccessMsg,   // don't show success message after extraction

    soExpandVariables, // expand environment variables in path/cmd line...

    soInitiallyHideFiles, // dont show file listview on startup

    soForceHideFiles, // do not allow user to show files list

    //                (no effect if shfInitiallyShowFiles is set)

    soCheckAutoRunFileName, // can only autorun if !... or setup.exe

    soCanBeCancelled, // extraction can be cancelled

    soCreateEmptyDirs, // recreate empty directories

    soSuccessAlways   // always give success message even if soAutoRun or soNoSuccessMsg

    );

  // set of TSFXOption

  TZMSFXOpts = set of TZMSFXOpt;

type

  TZMProgressType = (NewFile, ProgressUpdate, EndOfBatch, TotalFiles2Process,

    TotalSize2Process, NewExtra, ExtraUpdate);

type

  TZMProgressDetails = class(TObject)

  protected

    function GetBytesWritten: Int64; virtual; abstract;

    function GetDelta: Int64; virtual; abstract;

    function GetItemName: TZMString; virtual; abstract;

    function GetItemNumber: Integer; virtual; abstract;

    function GetItemPerCent: Integer;

    function GetItemPosition: Int64; virtual; abstract;

    function GetItemSize: Int64; virtual; abstract;

    function GetOrder: TZMProgressType; virtual; abstract;

    function GetTotalCount: Int64; virtual; abstract;

    function GetTotalPerCent: Integer;

    function GetTotalPosition: Int64; virtual; abstract;

    function GetTotalSize: Int64; virtual; abstract;

  public

    property BytesWritten: Int64 read GetBytesWritten;

    property Delta: Int64 read GetDelta;

    property ItemName: TZMString read GetItemName;

    property ItemNumber: Integer read GetItemNumber;

    property ItemPerCent: Integer Read GetItemPerCent;

    property ItemPosition: Int64 read GetItemPosition;

    property ItemSize: Int64 read GetItemSize;

    property Order: TZMProgressType read GetOrder;

    property TotalCount: Int64 read GetTotalCount;

    property TotalPerCent: Integer Read GetTotalPerCent;

    property TotalPosition: Int64 read GetTotalPosition;

    property TotalSize: Int64 read GetTotalSize;

  end;

// ZipDirEntry status bit constants

const

  zsbDirty    = $1;

  zsbSelected = $2;

  zsbSkipped  = $4;

  zsbIgnore   = $8;

  zsbDirOnly  = $10;

  zsbInvalid  = $20;

  zsbError    = $40;  // processing error

const

  DefNoSkips{: TZMSkipAborts} = [stDupName, stReadError];

  ZMInitialCRC = $FFFFFFFF;

type

  // abstract class representing a zip central record

  TZMDirEntry = class

  private

    function GetIsDirOnly: boolean;

  protected

    function GetCompressedSize: Int64; virtual; abstract;

    function GetCompressionMethod: Word; virtual; abstract;

    function GetCRC32: Cardinal; virtual; abstract;

    function GetDateStamp: TDateTime;

    function GetDateTime: Cardinal; virtual; abstract;

    function GetEncoded: TZMEncodingOpts; virtual; abstract;

    function GetEncrypted: Boolean; virtual; abstract;

    function GetExtFileAttrib: Longword; virtual; abstract;

    function GetExtraData(Tag: Word): TZMRawBytes; virtual;

    function GetExtraField: TZMRawBytes; virtual; abstract;

    function GetExtraFieldLength: Word; virtual; abstract;

    function GetFileComment: TZMString; virtual; abstract;

    function GetFileCommentLen: Word; virtual; abstract;

    function GetFileName: TZMString; virtual; abstract;

    function GetFileNameLength: Word; virtual; abstract;

    function GetFlag: Word; virtual; abstract;

    function GetHeaderName: TZMRawBytes; virtual; abstract;

    function GetIntFileAttrib: Word; virtual; abstract;

    function GetRelOffLocalHdr: Int64; virtual; abstract;

    function GetStartOnDisk: Word; virtual; abstract;

    function GetStatusBits: Cardinal; virtual; abstract;

    function GetUncompressedSize: Int64; virtual; abstract;

    function GetVersionMadeBy: Word; virtual; abstract;

    function GetVersionNeeded: Word; virtual; abstract;

    function XData(const x: TZMRawBytes; Tag: Word; var idx, size: Integer):

        Boolean;

  public

    property CompressedSize: Int64 Read GetCompressedSize;

    property CompressionMethod: Word Read GetCompressionMethod;

    property CRC32: Cardinal Read GetCRC32;

    property DateStamp: TDateTime Read GetDateStamp;

    property DateTime: Cardinal Read GetDateTime;

    property Encoded: TZMEncodingOpts Read GetEncoded;

    property Encrypted: Boolean Read GetEncrypted;

    property ExtFileAttrib: Longword Read GetExtFileAttrib;

    property ExtraData[Tag: Word]: TZMRawBytes read GetExtraData;

    property ExtraField: TZMRawBytes read GetExtraField;

    property ExtraFieldLength: Word Read GetExtraFieldLength;

    property FileComment: TZMString Read GetFileComment;

    property FileCommentLen: Word Read GetFileCommentLen;

    property FileName: TZMString Read GetFileName;

    property FileNameLength: Word Read GetFileNameLength;

    property Flag: Word Read GetFlag;

    property HeaderName: TZMRawBytes Read GetHeaderName;

    property IntFileAttrib: Word Read GetIntFileAttrib;

    property IsDirOnly: boolean read GetIsDirOnly;

    property RelOffLocalHdr: Int64 Read GetRelOffLocalHdr;

    property StartOnDisk: Word Read GetStartOnDisk;

    property StatusBits: Cardinal Read GetStatusBits;

    property UncompressedSize: Int64 Read GetUncompressedSize;

    property VersionMadeBy: Word read GetVersionMadeBy;

    property VersionNeeded: Word Read GetVersionNeeded;

  end;

  TZMDirRec = class(TZMDirEntry)

  public

    function ChangeAttrs(nAttr: Cardinal): Integer; virtual; abstract;

    function ChangeComment(const ncomment: TZMString): Integer; virtual; abstract;

    function ChangeData(ndata: TZMRawBytes): Integer; virtual; abstract;

    function ChangeDate(ndosdate: Cardinal): Integer; virtual; abstract;

    function ChangeEncoding: Integer; virtual; abstract;

    function ChangeName(const nname: TZMString): Integer; virtual; abstract;

    function ChangeStamp(ndate: TDateTime): Integer;

  end;

type

  TZMForEachFunction = function(rec: TZMDirEntry; var Data): Integer;

  TZMChangeFunction = function(rec: TZMDirRec; var Data): Integer;

type

  TZMRenameRec = record

    Source: String;

    Dest: String;

    Comment: String;

    DateTime: Integer;

  end;

  PZMRenameRec = ^TZMRenameRec;

// structure used to 'identify' streams

type

  TZMSStats = packed record

    Size:  Int64;

    Date:  Cardinal;

    Attrs: Cardinal;

  end;

  PZMSStats = ^TZMSStats;

type

  TZMStreamOp = (zsoIdentify, zsoOpen, zsoClose);

type

  TZMCheckTerminateEvent = procedure(Sender: TObject; var abort: Boolean) of object;

  TZMCopyZippedOverwriteEvent = procedure(Sender: TObject;

    src, dst: TZMDirEntry; var DoOverwrite: Boolean) of object;

  TZMCRC32ErrorEvent = procedure(Sender: TObject; const ForFile: TZMString;

    FoundCRC, ExpectedCRC: Longword; var DoExtract: Boolean) of object;

  TZMExtractOverwriteEvent = procedure(Sender: TObject; const ForFile: TZMString;

    IsOlder: Boolean; var DoOverwrite: Boolean; DirIndex: Integer) of object;

  TZMSkippedEvent = procedure(Sender: TObject; const ForFile: TZMString;

    SkipType: TZMSkipTypes; var ExtError: Integer) of object;

  TZMFileCommentEvent = procedure(Sender: TObject; const ForFile: TZMString;

    var FileComment: TZMString; var IsChanged: Boolean) of object;

  TZMFileExtraEvent = procedure(Sender: TObject; const ForFile: TZMString;

    var Data: TZMRawBytes; var IsChanged: Boolean) of object;

  TZMGetNextDiskEvent = procedure(Sender: TObject; DiskSeqNo, DiskTotal: Integer;

    Drive: String; var AbortAction: Boolean) of object;

  TZMLoadStrEvent = procedure(Ident: Integer; var DefStr: String) of object;

  TZMMessageEvent = procedure(Sender: TObject; ErrCode: Integer;

    const ErrMsg: TZMString) of object;

  // new signiture

  TZMNewNameEvent = procedure(Sender: TObject; SeqNo: Integer) of object;

  TZMPasswordErrorEvent = procedure(Sender: TObject; IsZipAction: Boolean;

    var NewPassword: String; const ForFile: TZMString; var RepeatCount: Longword;

    var Action: TMsgDlgBtn) of object;

  TZMProgressEvent = procedure(Sender: TObject; details: TZMProgressDetails) of object;

  TZMSetAddNameEvent = procedure(Sender: TObject; var FileName: TZMString;

    const ExtName: TZMString; var IsChanged: Boolean) of object;

  TZMSetExtNameEvent = procedure(Sender: TObject; var FileName: TZMString;

    const BaseDir: TZMString; var IsChanged: Boolean) of object;

  TZMStatusDiskEvent = procedure(Sender: TObject; PreviousDisk: Integer;

    PreviousFile: String; Status: TZMZipDiskStatus;

    var Action: TZMDiskAction) of object;

  TZMTickEvent   = procedure(Sender: TObject) of object;

  TZMDialogEvent = procedure(Sender: TObject; const title: String;

    var msg: String; var Result: Integer; btns: TMsgDlgButtons) of object;

  TZMSetCompLevel = procedure(Sender: TObject; const ForFile: TZMString;

    var level: Integer; var IsChanged: Boolean) of object;

  TZMStreamEvent = procedure(Sender: TObject; opr: TZMStreamOp; snumber: integer;

    var strm: TStream; var stat: TZMSStats; var done: Boolean) of object;

  TZMStateChange = procedure(Sender: TObject; state: TZMStates;

        var NoCursor: boolean) of object;

type

  TZMPipe = class

  protected

    function GetAttributes: Cardinal; virtual; abstract;

    function GetDOSDate: Cardinal; virtual; abstract;

    function GetFileName: string; virtual; abstract;

    function GetOwnsStream: boolean; virtual; abstract;

    function GetSize: Integer; virtual; abstract;

    function GetStream: TStream; virtual; abstract;

    procedure SetAttributes(const Value: Cardinal); virtual; abstract;

    procedure SetDOSDate(const Value: Cardinal); virtual; abstract;

    procedure SetFileName(const Value: string); virtual; abstract;

    procedure SetOwnsStream(const Value: boolean); virtual; abstract;

    procedure SetSize(const Value: Integer); virtual; abstract;

    procedure SetStream(const Value: TStream); virtual; abstract;

  public

    property Attributes: Cardinal read GetAttributes write SetAttributes;

    property DOSDate: Cardinal read GetDOSDate write SetDOSDate;

    property FileName: string read GetFileName write SetFileName;

    property OwnsStream: boolean read GetOwnsStream write SetOwnsStream;

    property Size: Integer read GetSize write SetSize;

    property Stream: TStream read GetStream write SetStream;

  end;

  TZMPipeList = class

  protected

    function GetCount: Integer; virtual; abstract;

    function GetPipe(Index: Integer): TZMPipe; virtual; abstract;

    procedure SetCount(const Value: Integer); virtual; abstract;

    procedure SetPipe(Index: Integer; const Value: TZMPipe); virtual; abstract;

  public

    function Add(aStream: TStream; const FileName: string; Own: boolean): integer;

        virtual; abstract;

    procedure Clear; virtual; abstract;

    property Count: Integer read GetCount write SetCount;

    property Pipe[Index: Integer]: TZMPipe read GetPipe write SetPipe; default;

  end;

type

{$IFDEF VERD2005up}

  TCustomZipMaster19 = class;

  TZipMasterEnumerator = class

    private

      FIndex: Integer;

      FOwner: TCustomZipMaster19;

    public

      constructor Create(AMaster: TCustomZipMaster19);

      function GetCurrent: TZMDirEntry;

      function MoveNext: Boolean;

      property Current: TZMDirEntry read GetCurrent;

  end;

{$ENDIF}

  // the main component

  TCustomZipMaster19 = class(TComponent)

  private

    { Private versions of property variables }

    BusyFlag:      Integer;

    fActive:       Integer;

    fAddCompLevel: Integer;

    fAddStoreSuffixes: TZMAddStoreExts;

    fConfirmErase: Boolean;

    FCurWaitCount: Integer;

    fDelaying:     Integer;

    fDLLDirectory: String;

    fDLLLoad:      Boolean;

    FEncodeAs: TZMEncodingOpts;

    fEncoding:     TZMEncodingOpts;

    fEncoding_CP:  Cardinal;

    fEncrypt:      Boolean;

    fExtAddStoreSuffixes: String;

    fExtrBaseDir:  String;

    fExtrOptions:  TZMExtrOpts;

    fFreeOnAllDisks: Cardinal;

    fFreeOnDisk1:  Cardinal;

    fFromDate:     TDateTime;

    FFSpecArgs: TStrings;

    fFSpecArgsExcl: TStrings;

    fHandle:       HWND;

    fHowToDelete:  TZMDeleteOpts;

    FLanguage: String;

    fMaxVolumeSize: Integer;

    FMaxVolumeSizeKb: Integer;

    fMinFreeVolSize: Integer;

    FNoReadAux: Boolean;

    FNoSkipping: TZMSkipAborts;

    fNotMainThread: Boolean;

    fOnCheckTerminate: TZMCheckTerminateEvent;

    fOnCopyZippedOverwrite: TZMCopyZippedOverwriteEvent;

    fOnCRC32Error: TZMCRC32ErrorEvent;

    fOnDirUpdate:  TNotifyEvent;

    fOnExtractOverwrite: TZMExtractOverwriteEvent;

    FOnSkipped: TZMSkippedEvent;

    fOnFileComment: TZMFileCommentEvent;

    fOnFileExtra:  TZMFileExtraEvent;

    fOnGetNextDisk: TZMGetNextDiskEvent;

    fOnMessage:    TZMMessageEvent;

    fOnNewName:    TZMNewNameEvent;

    fOnPasswordError: TZMPasswordErrorEvent;

    fOnProgress: TZMProgressEvent;

    fOnSetAddName: TZMSetAddNameEvent;

    fOnSetCompLevel: TZMSetCompLevel;

    fOnSetExtName: TZMSetExtNameEvent;

    fOnStateChange: TZMStateChange;

    fOnStatusDisk: TZMStatusDiskEvent;

    fOnStream:     TZMStreamEvent;

    fOnTick:       TZMTickEvent;

    fOnZipDialog:  TZMDialogEvent;

    FPassword: String;

    fPasswordReqCount: Longword;

    FPipes: TZMPipeList;

    fReentry:      Boolean;

    FSFXRegFailPath: String;

    fRootDir:      String;

    FSaveCursor: TCursor;

    FSFXCaption: TZMString;

    FSFXCommandLine: TZMString;

    FSFXDefaultDir: String;

    FSFXMessage: TZMString;

    FSFXOptions: TZMSFXOpts;

    FSFXOverwriteMode: TZMOvrOpts;

    FSFXPath: String;

    FSpanOptions: TZMSpanOpts;

    fTempDir:      String;

    fTrace:        Boolean;

    fUnattended:   Boolean;

    fUseDelphiBin: Boolean;

    FUseDirOnlyEntries: Boolean;

{$IFNDEF UNICODE}

    FUseUTF8: Boolean;

{$ENDIF}

    fVerbose:      Boolean;

    FWriteOptions: TZMWriteOpts;

//    fWorker:       TObject;

    FZipComment:   AnsiString;

    fZipFileName:  String;

    procedure AuxWasChanged;

    function GetActive: Boolean;

    function GetBuild: Integer;

    { Property get/set functions }

    function GetBusy: Boolean;

    function GetCancel: Boolean;

    function GetCount: Integer;

    function GetDirEntry(idx: Integer): TZMDirEntry;

    function GetDirOnlyCnt: Integer;

    function GetDLL_Build: Integer;

    function GetDLL_Load: Boolean;

    function GetDLL_Path: String;

    function GetDLL_Version: String;

    function GetDLL_Version1(load: boolean): String;

    function GetErrCode: Integer;

    function GetErrMessage: TZMString;

    function GetDllErrCode: Integer;

    function GetIsSpanned: Boolean;

    function GetLanguage: string;

    class function GetLanguageInfo(Idx: Integer; info: Cardinal): String;

    function GetNoReadAux: Boolean;

    function GetOnLoadStr: TZMLoadStrEvent;

    function GetSFXOffset: Integer;

    function GetSuccessCnt: Integer;

    function GetTotalSizeToProcess: Int64;

    function GetVersion: String;

    function GetZipComment: String;

    function GetZipEOC: Int64;

    function GetZipFileSize: Int64;

    function GetZipSOC: Int64;

    function GetZipStream: TMemoryStream;

    procedure SetActive(Value: Boolean);

    procedure SetCancel(Value: Boolean);

    procedure SetDLL_Load(const Value: Boolean);

    procedure SetEncodeAs(const Value: TZMEncodingOpts);

    procedure SetEncoding(const Value: TZMEncodingOpts);

    procedure SetEncoding_CP(Value: Cardinal);

    procedure SetErrCode(Value: Integer);

    procedure SetFSpecArgs(const Value: TStrings);

    procedure SetFSpecArgsExcl(const Value: TStrings);

    procedure SetLanguage(const Value: string);

    procedure SetNoReadAux(const Value: Boolean);

    procedure SetOnLoadStr(const Value: TZMLoadStrEvent);

    procedure SetPassword(const Value: String);

    procedure SetPasswordReqCount(Value: Longword);

    procedure SetPipes(const Value: TZMPipeList);

    procedure SetSFXCaption(const Value: TZMString);

    procedure SetSFXCommandLine(const Value: TZMString);

    procedure SetSFXDefaultDir(const Value: String);

    procedure SetSFXIcon(Value: TIcon);

    procedure SetSFXMessage(const Value: TZMString);

    procedure SetSFXOptions(const Value: TZMSFXOpts);

    procedure SetSFXOverwriteMode(const Value: TZMOvrOpts);

    procedure SetSFXRegFailPath(const Value: String);

    procedure SetSpanOptions(const Value: TZMSpanOpts);

    procedure SetUseDirOnlyEntries(const Value: Boolean);

{$IFNDEF UNICODE}

    procedure SetUseUTF8(const Value: Boolean);

{$ENDIF}

    procedure SetVersion(const Value: String);

    procedure SetWriteOptions(const Value: TZMWriteOpts);

    procedure SetZipComment(const Value: String);

    procedure SetZipFileName(const Value: String);

  protected

    FAddOptions: TZMAddOpts;

    FAuxChanged: Boolean;

    fSFXIcon:    TIcon;

    fWorker:     TObject;

    function CanStart: Boolean;

    procedure DoDelays;

    procedure Done(Good: Boolean = True);

    procedure DoneBad(E: Exception);

    function IsActive: boolean;

    procedure Loaded; override;

    function Permitted: Boolean;

    procedure ReEntered;

    procedure Start;

    procedure StartNoDll;

    procedure StartWaitCursor;

    procedure StateChanged(newState: TZMStates);

    function Stopped: Boolean;

    procedure StopWaitCursor;

  public

    procedure AbortDLL;

    function Add: Integer;

    function AddStreamToFile(const FileName: String;

      FileDate, FileAttr: Dword): Integer;

    function AddStreamToStream(InStream: TMemoryStream): TMemoryStream;

    function AddZippedFiles(SrcZipMaster: TCustomZipMaster19;

      merge: TZMMergeOpts): Integer;

    procedure AfterConstruction; override;

    function AppendSlash(const sDir: String): String;

    procedure BeforeDestruction; override;

    function ChangeFileDetails(func: TZMChangeFunction; var Data): Integer;

    procedure Clear;

    function ConvertToSFX: Integer;

    function ConvertToSpanSFX(const OutFile: String): Integer;

    function ConvertToZIP: Integer;

    function CopyZippedFiles(DestZipMaster: TCustomZipMaster19; DeleteFromSource:

        Boolean; OverwriteDest: TZMMergeOpts): Integer; overload;

    function Copy_File(const InFileName, OutFileName: String): Integer;

    function Deflate(OutStream, InStream: TStream; Length: Int64; var Method:

        TZMDeflates; var CRC: Cardinal): Integer;

    function Delete: Integer;

    function EraseFile(const FName: String; How: TZMDeleteOpts): Integer;

    function Extract: Integer;

    function ExtractFileToStream(const FileName: String): TMemoryStream;

    function ExtractStreamToStream(InStream: TMemoryStream; OutSize: Longword):

        TMemoryStream;

    function Find(const fspec: TZMString; var idx: Integer): TZMDirEntry;

    function ForEach(func: TZMForEachFunction; var Data): Integer;

    function FullVersionString: String;

    function GetAddPassword: String; overload;

    function GetAddPassword(var Response: TmsgDlgBtn): String; overload;

{$IFDEF VERD2005up}

    function GetEnumerator: TZipMasterEnumerator;

{$ENDIF}

    function GetExtrPassword: String; overload;

    function GetExtrPassword(var Response: TmsgDlgBtn): String; overload;

    function GetPassword(const DialogCaption, MsgTxt: String;

      pwb: TmsgDlgButtons; var ResultStr: String): TmsgDlgBtn;

    function IndexOf(const FName: TZMString): Integer;

    function IsZipSFX(const SFXExeName: String): Integer;

    function List: Integer;

    function MakeTempFileName(const Prefix, Extension: String): String;

    function QueryZip(const FName: TFileName): Integer;

    function ReadSpan(const InFileName: String; var OutFilePath: String): Integer;

    function Rename(RenameList: TList; DateTime: Integer; How: TZMRenameOpts =

        htrDefault): Integer;

    procedure ShowExceptionError(const ZMExcept: EZMException);

    procedure ShowZipFmtMessage(Id: Integer; const Args: array of const);

    procedure ShowZipMessage(Ident: Integer; const UserStr: String);

    function TheErrorCode(errCode: Integer): Integer;

    function Undeflate(OutStream, InStream: TStream; Length: Int64; var Method:

        TZMDeflates; var CRC: Cardinal): Integer;

    function WriteSpan(const InFileName, OutFileName: String): Integer;

    function ZipLoadStr(Id: Integer): string;

    //  published

    property Active: Boolean Read GetActive Write SetActive default True;

    property AddCompLevel: Integer Read fAddCompLevel Write fAddCompLevel default 9;

    property AddFrom: TDateTime Read fFromDate Write fFromDate;

    property AddOptions: TZMAddOpts read FAddOptions write FAddOptions;

    property AddStoreSuffixes: TZMAddStoreExts

      Read fAddStoreSuffixes Write fAddStoreSuffixes;

    property Build: Integer Read GetBuild;

    property Busy: Boolean Read GetBusy;

    property Cancel: Boolean Read GetCancel Write SetCancel;

    property ConfirmErase: Boolean Read fConfirmErase Write fConfirmErase default True;

    property Count: Integer Read GetCount;

    property DirEntry[idx: Integer]: TZMDirEntry Read GetDirEntry; default;

    property DirOnlyCnt: Integer Read GetDirOnlyCnt;

    property DLLDirectory: String Read fDLLDirectory Write fDLLDirectory;

    property DLL_Build: Integer Read GetDLL_Build;

    property DLL_Load: Boolean Read GetDLL_Load Write SetDLL_Load;

    property DLL_Path: String Read GetDLL_Path;

    property DLL_Version: String Read GetDLL_Version;

    property EncodeAs: TZMEncodingOpts read FEncodeAs write SetEncodeAs;

    //1 Filename and comment character encoding

    property Encoding: TZMEncodingOpts Read fEncoding Write SetEncoding default zeoAuto;

    //1 codepage to use to decode filename

    property Encoding_CP: Cardinal Read fEncoding_CP Write SetEncoding_CP;

    property ErrCode: Integer Read GetErrCode Write SetErrCode;

    property ErrMessage: TZMString Read GetErrMessage;

    property ExtAddStoreSuffixes: String Read fExtAddStoreSuffixes

      Write fExtAddStoreSuffixes;

    property ExtrBaseDir: String Read fExtrBaseDir Write fExtrBaseDir;

    property ExtrOptions: TZMExtrOpts Read fExtrOptions Write fExtrOptions;

    property FSpecArgs: TStrings read FFSpecArgs write SetFSpecArgs;

    property FSpecArgsExcl: TStrings Read fFSpecArgsExcl Write SetFSpecArgsExcl;

    property DllErrCode: Integer read GetDllErrCode;

    property Handle: HWND Read fHandle Write fHandle;

    property HowToDelete: TZMDeleteOpts

      Read fHowToDelete Write fHowToDelete default htdAllowUndo;

    property IsSpanned: Boolean Read GetIsSpanned;

    property KeepFreeOnAllDisks: Cardinal Read fFreeOnAllDisks Write fFreeOnAllDisks;

    property KeepFreeOnDisk1: Cardinal Read fFreeOnDisk1 Write fFreeOnDisk1;

    property Language: string read GetLanguage write SetLanguage;

    property LanguageInfo[Idx: Integer; info: Cardinal]: String Read GetLanguageInfo;

    property MaxVolumeSize: Integer Read fMaxVolumeSize Write fMaxVolumeSize;

    property MaxVolumeSizeKb: Integer read FMaxVolumeSizeKb write FMaxVolumeSizeKb;

    property MinFreeVolumeSize: Integer Read fMinFreeVolSize

      Write fMinFreeVolSize default 65536;

    property NoReadAux: Boolean read GetNoReadAux write SetNoReadAux;

    property NoSkipping: TZMSkipAborts read FNoSkipping write FNoSkipping default

        DefNoSkips;

    property NotMainThread: Boolean Read fNotMainThread Write fNotMainThread;

    property Password: String read FPassword write SetPassword;

    property PasswordReqCount: Longword Read fPasswordReqCount

      Write SetPasswordReqCount default 1;

    property Pipes: TZMPipeList read FPipes write SetPipes;

    property RootDir: String Read fRootDir Write fRootDir;

    property SFXCaption: TZMString read FSFXCaption write SetSFXCaption;

    property SFXCommandLine: TZMString read FSFXCommandLine write SetSFXCommandLine;

    property SFXDefaultDir: String read FSFXDefaultDir write SetSFXDefaultDir;

    property SFXIcon: TIcon Read fSFXIcon Write SetSFXIcon;

    property SFXMessage: TZMString read FSFXMessage write SetSFXMessage;

    property SFXOffset: Integer Read GetSFXOffset;

    property SFXOptions: TZMSFXOpts read FSFXOptions write SetSFXOptions;

    property SFXOverwriteMode: TZMOvrOpts read FSFXOverwriteMode write

        SetSFXOverwriteMode default ovrConfirm;

    property SFXPath: String read FSFXPath write FSFXPath;

    property SFXRegFailPath: String read FSFXRegFailPath write SetSFXRegFailPath;

    property SpanOptions: TZMSpanOpts read FSpanOptions write SetSpanOptions;

    property SuccessCnt: Integer Read GetSuccessCnt;

    property TempDir: String Read fTempDir Write fTempDir;

    property TotalSizeToProcess: Int64 Read GetTotalSizeToProcess;

    property Trace: Boolean Read fTrace Write fTrace;

    property Unattended: Boolean Read fUnattended Write fUnattended;

    property UseDirOnlyEntries: Boolean read FUseDirOnlyEntries write

        SetUseDirOnlyEntries default False;

{$IFNDEF UNICODE}

    property UseUTF8: Boolean read FUseUTF8 write SetUseUTF8;