// Borland C++ Builder
// Copyright (c) 1995, 2002 by Borland Software Corporation
// All rights reserved

// (DO NOT EDIT: machine generated header) 'ahmshelloperator.pas' rev: 6.00

#ifndef ahmshelloperatorHPP
#define ahmshelloperatorHPP

#pragma delphiheader begin
#pragma option push -w-
#pragma option push -Vx
#include <ahmshellclass.hpp>	// Pascal unit
#include <ahmshellconst.hpp>	// Pascal unit
#include <ShellAPI.hpp>	// Pascal unit
#include <SysUtils.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <SysInit.hpp>	// Pascal unit
#include <System.hpp>	// Pascal unit

//-- user supplied -----------------------------------------------------------

namespace Ahmshelloperator
{
//-- type declarations -------------------------------------------------------
#pragma option push -b-
enum TAHMFileFlag { opAllowUndo, opConfirmMouse, opFilesOnly, opMultiDestFiles, opNoConfirmation, opNoConfirmMkDir, opRenameOnCollision, opSilent, opSimpleProgress, opWantMappingHandle };
#pragma option pop

typedef Set<TAHMFileFlag, opAllowUndo, opWantMappingHandle>  TAHMFileFlags;

typedef void __fastcall (__closure *TAHMFileOperationEvent)(System::TObject* Sender, int Result);

class DELPHICLASS TAHMBaseFileOperator;
class PASCALIMPLEMENTATION TAHMBaseFileOperator : public Ahmshellclass::TAHMShellComponent 
{
	typedef Ahmshellclass::TAHMShellComponent inherited;
	
private:
	TAHMFileOperationEvent fOnFailure;
	Classes::TNotifyEvent fAfterExecute;
	Classes::TNotifyEvent fOnSuccess;
	Classes::TNotifyEvent fBeforeExecute;
	AnsiString fProgressTitle;
	#pragma pack(push, 1)
	_SHFILEOPSTRUCTA fShellFileOp;
	#pragma pack(pop)
	
	TAHMFileFlags __fastcall GetFlags(void);
	void __fastcall SetFlags(const TAHMFileFlags Value);
	void __fastcall SetOperationFlag(unsigned aFlag, bool aDoSet);
	
protected:
	virtual int __fastcall DoExecute(void);
	__property _SHFILEOPSTRUCTA ShellFileOp = {read=fShellFileOp};
	
public:
	__fastcall virtual TAHMBaseFileOperator(Classes::TComponent* AOwner);
	bool __fastcall Execute(void);
	
__published:
	__property AnsiString ProgressTitle = {read=fProgressTitle, write=fProgressTitle};
	__property TAHMFileFlags Flags = {read=GetFlags, write=SetFlags, default=33};
	__property Classes::TNotifyEvent OnSuccess = {read=fOnSuccess, write=fOnSuccess};
	__property TAHMFileOperationEvent OnFailure = {read=fOnFailure, write=fOnFailure};
	__property Classes::TNotifyEvent BeforeExecute = {read=fBeforeExecute, write=fBeforeExecute};
	__property Classes::TNotifyEvent AfterExecute = {read=fAfterExecute, write=fAfterExecute};
public:
	#pragma option push -w-inl
	/* TComponent.Destroy */ inline __fastcall virtual ~TAHMBaseFileOperator(void) { }
	#pragma option pop
	
};


class DELPHICLASS TAHMFileCopier;
class PASCALIMPLEMENTATION TAHMFileCopier : public TAHMBaseFileOperator 
{
	typedef TAHMBaseFileOperator inherited;
	
private:
	Classes::TStrings* fFrom;
	AnsiString fToPath;
	bool fDoMove;
	void __fastcall SetFrom(const Classes::TStrings* Value);
	
protected:
	virtual int __fastcall DoExecute(void);
	
public:
	__fastcall virtual TAHMFileCopier(Classes::TComponent* AOwner);
	__fastcall virtual ~TAHMFileCopier(void);
	bool __fastcall DiskCopy(void);
	
__published:
	__property Classes::TStrings* From = {read=fFrom, write=SetFrom};
	__property AnsiString ToPath = {read=fToPath, write=fToPath};
	__property bool DoMove = {read=fDoMove, write=fDoMove, default=0};
};


class DELPHICLASS TAHMFileEraser;
class PASCALIMPLEMENTATION TAHMFileEraser : public TAHMBaseFileOperator 
{
	typedef TAHMBaseFileOperator inherited;
	
private:
	Classes::TStrings* fFrom;
	void __fastcall SetFrom(const Classes::TStrings* Value);
	
protected:
	virtual int __fastcall DoExecute(void);
	
public:
	__fastcall virtual TAHMFileEraser(Classes::TComponent* AOwner);
	__fastcall virtual ~TAHMFileEraser(void);
	
__published:
	__property Classes::TStrings* From = {read=fFrom, write=SetFrom};
};


typedef void __fastcall (__closure *TAHMGetNewNameEvent)(System::TObject* Sender, AnsiString &aFileName);

class DELPHICLASS TAHMFileRenamer;
class PASCALIMPLEMENTATION TAHMFileRenamer : public TAHMBaseFileOperator 
{
	typedef TAHMBaseFileOperator inherited;
	
private:
	Classes::TStrings* fFrom;
	TAHMGetNewNameEvent fOnGetNewName;
	void __fastcall SetFrom(const Classes::TStrings* Value);
	
protected:
	virtual int __fastcall DoExecute(void);
	
public:
	__fastcall virtual TAHMFileRenamer(Classes::TComponent* AOwner);
	__fastcall virtual ~TAHMFileRenamer(void);
	
__published:
	__property Classes::TStrings* From = {read=fFrom, write=SetFrom};
	__property TAHMGetNewNameEvent OnGetNewName = {read=fOnGetNewName, write=fOnGetNewName};
};


//-- var, const, procedure ---------------------------------------------------

}	/* namespace Ahmshelloperator */
using namespace Ahmshelloperator;
#pragma option pop	// -w-
#pragma option pop	// -Vx

#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif	// ahmshelloperator
