// CodeGear C++Builder
// Copyright (c) 1995, 2015 by Embarcadero Technologies, Inc.
// All rights reserved

// (DO NOT EDIT: machine generated header) 'hyieutils.pas' rev: 30.00 (Windows)

#ifndef HyieutilsHPP
#define HyieutilsHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member 
#pragma pack(push,8)
#include <System.hpp>
#include <SysInit.hpp>
#include <Winapi.Windows.hpp>
#include <Winapi.Messages.hpp>
#include <Vcl.Forms.hpp>
#include <System.Classes.hpp>
#include <Vcl.StdCtrls.hpp>
#include <Vcl.Graphics.hpp>
#include <Vcl.Controls.hpp>
#include <System.Contnrs.hpp>
#include <System.SysUtils.hpp>
#include <hyiedefs.hpp>
#include <iewords.hpp>
#include <ievision.hpp>
#include <iegdiplus.hpp>
#include <Vcl.Dialogs.hpp>
#include <System.UITypes.hpp>
#include <System.Types.hpp>

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

namespace Hyieutils
{
//-- forward type declarations -----------------------------------------------
struct TTIFFColor;
struct TTIFFHeader;
struct TTIFFTAG;
struct TBigTIFFTAG;
class DELPHICLASS TIETIFFIFDReader;
class DELPHICLASS TIETIFFIFDWriter;
class DELPHICLASS THash1Item;
class DELPHICLASS THash1;
class DELPHICLASS TImageEnPaletteDialog;
class DELPHICLASS TIEScrollBarParams;
class DELPHICLASS TIEMouseWheelParams;
class DELPHICLASS TIEByteArray;
class DELPHICLASS TNulStream;
class DELPHICLASS TIEList;
class DELPHICLASS TIEDoubleList;
class DELPHICLASS TIEIntegerList;
class DELPHICLASS TIERecordList;
class DELPHICLASS TIEMarkerList;
struct TIPTCInfo;
class DELPHICLASS TIEIPTCInfoList;
class DELPHICLASS TIEBaseBitmap;
class DELPHICLASS TIETemporaryFileStream;
class DELPHICLASS TIEWideFileStream;
struct TIEFileBufferItem;
class DELPHICLASS TIEFileBuffer;
class DELPHICLASS TIEHashStream;
class DELPHICLASS TIEMemStream;
struct IE_PROFILE;
class DELPHICLASS TIEICC;
class DELPHICLASS TIEVirtualBitmapProvider;
class DELPHICLASS TIEBitmap;
class DELPHICLASS TIEMask;
struct TIEVirtualImageInfo;
struct TIEVirtualToReleaseBmp;
struct TIEVirtualFreeBlock;
class DELPHICLASS TIEVirtualImageList;
class DELPHICLASS TIEDibbitmap;
struct OIAN_MARK_ATTRIBUTES;
class DELPHICLASS TIEImagingObject;
class DELPHICLASS TIEImagingAnnot;
class DELPHICLASS TIEImageEnAnnot;
class DELPHICLASS TIEWorkBitmap;
class DELPHICLASS TIETIFTagsReader;
struct TIEEXIFMakerNoteDeviceInfo;
class DELPHICLASS TIETagsHandler;
class DELPHICLASS TIETagsHandlerRelocator;
class DELPHICLASS TIETIFFHandler;
class DELPHICLASS TIEGraphicBase;
class DELPHICLASS TIEBufferedReadStream;
class DELPHICLASS TIEBufferedWriteStream;
class DELPHICLASS TIETIFFImage;
class DELPHICLASS TIEGIFImage;
class DELPHICLASS TIEJpegImage;
class DELPHICLASS TIEPCXImage;
class DELPHICLASS TIEBMPImage;
class DELPHICLASS TIEICOImage;
class DELPHICLASS TIEPNGImage;
class DELPHICLASS TIETGAImage;
class DELPHICLASS TIEPXMImage;
class DELPHICLASS TIEJP2Image;
class DELPHICLASS TIEJ2KImage;
class DELPHICLASS TIEPSDImage;
class DELPHICLASS TIEPDFObject;
class DELPHICLASS TIEPDFRefObject;
class DELPHICLASS TIEPDFBooleanObject;
class DELPHICLASS TIEPDFNumericObject;
class DELPHICLASS TIEPDFStringObject;
class DELPHICLASS TIEPDFNameObject;
class DELPHICLASS TIEPDFArrayObject;
class DELPHICLASS TIEPDFDictionaryObject;
class DELPHICLASS TIEPDFStreamObject;
struct TIEDicomTag;
class DELPHICLASS TIEDicomTags;
class DELPHICLASS TIEWideStrings;
class DELPHICLASS TIEDirContent;
class DELPHICLASS TIEThreadPool;
class DELPHICLASS TIEResourceBookmark;
class DELPHICLASS TIEResourceExtractor;
class DELPHICLASS EIERFBError;
class DELPHICLASS TIERFBMessageThread;
class DELPHICLASS TIEClientSocket;
class DELPHICLASS TIERFBClient;
class DELPHICLASS TIE3DES;
class DELPHICLASS TIERandomGenerator;
class DELPHICLASS TIEImageListItem;
class DELPHICLASS TIEImageList;
class DELPHICLASS TIEEquirectangularRenderer;
__interface IIELoadPicture;
typedef System::DelphiInterface<IIELoadPicture> _di_IIELoadPicture;
class DELPHICLASS TIESlippyMapQueueItem;
class DELPHICLASS TIESlippyMap;
class DELPHICLASS TIEDictionaryValueWideString;
class DELPHICLASS TIEDictionaryValueInteger;
class DELPHICLASS TIEDictionaryValueDouble;
class DELPHICLASS TIEDictionaryValueBoolean;
class DELPHICLASS TIEDictionaryBucket;
class DELPHICLASS TIEStrStrEnumerator;
class DELPHICLASS TIEDictionary;
class DELPHICLASS TIEDictionaryParser;
class DELPHICLASS TIEVCLStreamProvider;
//-- type declarations -------------------------------------------------------
typedef int __fastcall (__closure *TIECompareFunction)(int Index1, int Index2);

typedef void __fastcall (__closure *TIESwapFunction)(int Index1, int Index2);

typedef void __fastcall (*TIEDialogCenter)(HWND Wnd);

enum DECLSPEC_DENUM TIEMTruncSide : unsigned char { iemtsLeft, iemtsRight };

enum DECLSPEC_DENUM TIEQuality : unsigned char { ieLow, ieMedium, ieHigh };

#pragma pack(push,1)
struct DECLSPEC_DRECORD TTIFFColor
{
public:
	System::Word R;
	System::Word G;
	System::Word B;
};
#pragma pack(pop)


typedef System::StaticArray<TTIFFColor, 134217728> TTIFFRGBArray;

typedef TTIFFRGBArray *PTIFFRGBArray;

#pragma pack(push,1)
struct DECLSPEC_DRECORD TTIFFHeader
{
public:
	System::Word Id;
	System::Word Ver;
	unsigned PosIFD;
};
#pragma pack(pop)


typedef TTIFFHeader *PTIFFHeader;

#pragma pack(push,1)
struct DECLSPEC_DRECORD TTIFFTAG
{
public:
	System::Word IdTag;
	System::Word DataType;
	int DataNum;
	unsigned DataPos;
};
#pragma pack(pop)


typedef TTIFFTAG *PTIFFTAG;

#pragma pack(push,1)
struct DECLSPEC_DRECORD TBigTIFFTAG
{
public:
	System::Word IdTag;
	System::Word DataType;
	__int64 DataNum;
	__int64 DataPos;
};
#pragma pack(pop)


typedef System::StaticArray<TTIFFTAG, 134217728> TIFD;

typedef TIFD *PIFD;

typedef System::StaticArray<TBigTIFFTAG, 67108864> TBigIFD;

typedef TBigIFD *PBigIFD;

class PASCALIMPLEMENTATION TIETIFFIFDReader : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	bool LittleEndian;
	System::Classes::TStream* Stream;
	TIFD *IFD;
	TBigIFD *BigIFD;
	int NumTags;
	__int64 StreamBase;
	bool IsBigTIFF;
	int DataPosSize;
	__fastcall TIETIFFIFDReader(void);
	__fastcall virtual ~TIETIFFIFDReader(void);
	bool __fastcall ReadIFD(int ImageIndex, __int64 Offset, int &ImageCount);
	void __fastcall Assign(TIETIFFIFDReader* Source);
	void __fastcall Clear(void);
	__int64 __fastcall GetDataNum(int tagIndex);
	System::Word __fastcall GetDataType(int tagIndex);
	__int64 __fastcall GetDataPos(int tagIndex);
	__int64 __fastcall GetItem(int tagIndex, __int64 dataIndex);
	__int64 __fastcall GetDataLengthInBytes(int tagIndex);
	int __fastcall FindTAG(System::Word tagID);
	__int64 __fastcall ReadInteger(System::Word tagID, __int64 idx, __int64 def);
	double __fastcall ReadRational(System::Word tagID, int idx, double defaultValue);
	int __fastcall ReadArrayIntegers(Hyiedefs::pint64array &ar, System::Word tagID);
	Hyiedefs::TIEArrayOfByte __fastcall ReadRawDataAsArrayOfByte(System::Word tagID);
	void * __fastcall ReadRawData(System::Word tagID, int &Size);
	System::AnsiString __fastcall ReadString(System::Word tagID, bool truncToEZ = true);
	System::WideString __fastcall ReadWideString(System::Word tagID);
};


#pragma pack(push,4)
class PASCALIMPLEMENTATION TIETIFFIFDWriter : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::Classes::TList* Items;
	int __fastcall GetCount(void);
	PTIFFTAG __fastcall GetTag(int Index);
	
public:
	__fastcall TIETIFFIFDWriter(void);
	__fastcall virtual ~TIETIFFIFDWriter(void);
	void __fastcall AddTag(System::Word IdTag, System::Word DataType, int DataNum, unsigned DataPos);
	void __fastcall ReorderTags(void);
	void __fastcall WriteSingleLong(int tag, int val);
	void __fastcall WriteSingleUndefined(int tag, unsigned val, System::Classes::TList* writeIfInList = (System::Classes::TList*)(0x0));
	void __fastcall WriteMiniString(int tag, System::AnsiString ss);
	void __fastcall WriteMiniByteString(int tag, System::AnsiString ss);
	void __fastcall WriteSingleShort(int tag, System::Word val, System::Classes::TList* writeIfInList = (System::Classes::TList*)(0x0));
	void __fastcall WriteSingleByte(int tag, System::Byte val);
	void __fastcall WriteSingleRational(System::Classes::TStream* Stream, int tag, double value, bool &Aborting, System::Classes::TList* writeIfInList = (System::Classes::TList*)(0x0));
	void __fastcall WriteMultiRational(System::Classes::TStream* Stream, int tag, double *values, const int values_High, bool &Aborting);
	void __fastcall WriteString(System::Classes::TStream* Stream, int tag, System::AnsiString ss, bool &Aborting);
	void __fastcall WriteWideString(System::Classes::TStream* Stream, int tag, System::WideString ss, bool &Aborting);
	void __fastcall WriteArrayOfByte(System::Classes::TStream* Stream, System::Word Tag, System::Word DataType, Hyiedefs::TIEArrayOfByte Buffer, bool &Aborting);
	void __fastcall WriteMultiLongEx(System::Classes::TStream* Stream, int tag, unsigned *arr, const int arr_High, int arraylen, bool &Aborting);
	void __fastcall WriteMultiShort(System::Classes::TStream* Stream, int tag, System::Word const *vals, const int vals_High, bool &Aborting);
	__property int Count = {read=GetCount, nodefault};
	__property PTIFFTAG Tag[int Index] = {read=GetTag};
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION THash1Item : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	int key;
	THash1Item* nextitem;
	int value;
public:
	/* TObject.Create */ inline __fastcall THash1Item(void) : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~THash1Item(void) { }
	
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION THash1 : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::Classes::TList* fMainKeys;
	System::Classes::TList* fMainKeysUse;
	System::Classes::TList* fMainKeysValue;
	int fHbits;
	int fHdim;
	int fIteratePtr1;
	THash1Item* fIteratePtr2;
	int __fastcall HashFunc(int kk);
	
public:
	int nkeys;
	__fastcall THash1(int Hbits);
	__fastcall virtual ~THash1(void);
	bool __fastcall Insert(int kk);
	bool __fastcall KeyPresent(int kk);
	bool __fastcall Insert2(int kk, int &ptr1, THash1Item* &ptr2);
	void __fastcall SetValue(int ptr1, THash1Item* ptr2, int Value);
	int __fastcall GetValue(int ptr1, THash1Item* ptr2);
	bool __fastcall IterateBegin(void);
	bool __fastcall IterateNext(void);
	int __fastcall IterateGetValue(void);
};

#pragma pack(pop)

enum DECLSPEC_DENUM TIEOpSys : unsigned char { ieosWin95, ieosWin98, ieosWinME, ieosWinNT4, ieosWin2000, ieosWinXP, ieosWin2003, ieosWinVista, ieosWin7, ieosWin8, ieosUnknown };

class PASCALIMPLEMENTATION TImageEnPaletteDialog : public Vcl::Forms::TForm
{
	typedef Vcl::Forms::TForm inherited;
	
private:
	int MouseCol;
	Hyiedefs::RGBROW *fPalette;
	int fNumCol;
	void __fastcall FormPaint(System::TObject* Sender);
	void __fastcall FormMouseMove(System::TObject* Sender, System::Classes::TShiftState Shift, int x, int y);
	void __fastcall FormClick(System::TObject* Sender);
	
public:
	Vcl::Stdctrls::TButton* ButtonCancel;
	System::Uitypes::TColor SelCol;
	__property int NumCol = {read=MouseCol, nodefault};
	__fastcall virtual TImageEnPaletteDialog(System::Classes::TComponent* AOwner);
	void __fastcall SetPalette(Hyiedefs::TRGB *Palette, const int Palette_High, int NumCol);
	bool __fastcall Execute(void);
public:
	/* TCustomForm.CreateNew */ inline __fastcall virtual TImageEnPaletteDialog(System::Classes::TComponent* AOwner, int Dummy) : Vcl::Forms::TForm(AOwner, Dummy) { }
	/* TCustomForm.Destroy */ inline __fastcall virtual ~TImageEnPaletteDialog(void) { }
	
public:
	/* TWinControl.CreateParented */ inline __fastcall TImageEnPaletteDialog(HWND ParentWindow) : Vcl::Forms::TForm(ParentWindow) { }
	
};


#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEScrollBarParams : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	int fLineStep;
	int fPageStep;
	bool fTracking;
	
public:
	__fastcall TIEScrollBarParams(void);
	__fastcall virtual ~TIEScrollBarParams(void);
	__property int LineStep = {read=fLineStep, write=fLineStep, nodefault};
	__property int PageStep = {read=fPageStep, write=fPageStep, nodefault};
	__property bool Tracking = {read=fTracking, write=fTracking, nodefault};
};

#pragma pack(pop)

enum DECLSPEC_DENUM TIEMouseWheelParamsAction : unsigned char { iemwNone, iemwVScroll, iemwZoom, iemwNavigate };

enum DECLSPEC_DENUM TIEMouseWheelParamsVariation : unsigned char { iemwAbsolute, iemwPercentage };

enum DECLSPEC_DENUM TIEMouseWheelParamsZoomPosition : unsigned char { iemwCenter, iemwMouse };

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEMouseWheelParams : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	bool InvertDirection;
	TIEMouseWheelParamsAction Action;
	TIEMouseWheelParamsVariation Variation;
	int Value;
	TIEMouseWheelParamsZoomPosition ZoomPosition;
	__fastcall TIEMouseWheelParams(TIEMouseWheelParamsAction DefaultAction);
	__fastcall virtual ~TIEMouseWheelParams(void);
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEByteArray : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	int fSize;
	int fRSize;
	int fBlockSize;
	void __fastcall SetSize(int v);
	
public:
	System::Sysutils::TByteArray *Data;
	__fastcall TIEByteArray(int InitBlockSize);
	__fastcall virtual ~TIEByteArray(void);
	void __fastcall AddByte(System::Byte v);
	__property int Size = {read=fSize, write=SetSize, nodefault};
	__property int BlockSize = {read=fBlockSize, write=fBlockSize, nodefault};
	void __fastcall Clear(void);
	int __fastcall AppendFromStream(System::Classes::TStream* Stream, int Count);
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TNulStream : public System::Classes::TStream
{
	typedef System::Classes::TStream inherited;
	
private:
	int fposition;
	int fsize;
	
public:
	__fastcall TNulStream(void);
	__fastcall virtual ~TNulStream(void);
	virtual int __fastcall Read(void *Buffer, int Count)/* overload */;
	virtual int __fastcall Write(const void *Buffer, int Count)/* overload */;
	virtual int __fastcall Seek(int Offset, System::Word Origin)/* overload */;
	/* Hoisted overloads: */
	
public:
	inline int __fastcall  Read(System::DynamicArray<System::Byte> Buffer, int Offset, int Count){ return System::Classes::TStream::Read(Buffer, Offset, Count); }
	inline int __fastcall  Read(System::DynamicArray<System::Byte> &Buffer, int Count){ return System::Classes::TStream::Read(Buffer, Count); }
	inline int __fastcall  Write(const System::DynamicArray<System::Byte> Buffer, int Offset, int Count){ return System::Classes::TStream::Write(Buffer, Offset, Count); }
	inline int __fastcall  Write(const System::DynamicArray<System::Byte> Buffer, int Count){ return System::Classes::TStream::Write(Buffer, Count); }
	inline __int64 __fastcall  Seek(const __int64 Offset, System::Classes::TSeekOrigin Origin){ return System::Classes::TStream::Seek(Offset, Origin); }
	inline __int64 __fastcall  Seek _DEPRECATED_ATTRIBUTE0 (const __int64 Offset, System::Word Origin){ return System::Classes::TStream::Seek(Offset, Origin); }
	
};

#pragma pack(pop)

enum DECLSPEC_DENUM Hyieutils__01 : unsigned char { ielItems, ielRange, ielCurrentValue };

typedef System::Set<Hyieutils__01, Hyieutils__01::ielItems, Hyieutils__01::ielCurrentValue> TIEListChanges;

typedef void __fastcall (__closure *TIEListCurrentValueEvent)(System::TObject* Sender, void * Value);

class PASCALIMPLEMENTATION TIEList : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	int fCapacity;
	int fCount;
	TIEListCurrentValueEvent fOnGetCurrentValue;
	TIEListCurrentValueEvent fOnSetCurrentValue;
	
protected:
	int fItemSize;
	void *fData;
	TIEListChanges fChanged;
	virtual void __fastcall SetCount(int v);
	int __fastcall AddItem(void * v);
	void __fastcall InsertItem(int idx, void * v);
	int __fastcall IndexOfItem(void * v);
	void * __fastcall BaseGetItem(int idx);
	void __fastcall BaseSetItem(int idx, void * v);
	void __fastcall DoGetCurrentValue(void * value);
	void __fastcall DoSetCurrentValue(void * value);
	
public:
	__fastcall virtual TIEList(TIEListCurrentValueEvent OnGetCurrentValue, TIEListCurrentValueEvent OnSetCurrentValue);
	__fastcall virtual ~TIEList(void);
	virtual void __fastcall Delete(int idx);
	__property int Count = {read=fCount, write=SetCount, nodefault};
	virtual void __fastcall Clear(void);
	virtual void __fastcall Assign(TIEList* Source);
	__property TIEListChanges Changed = {read=fChanged, write=fChanged, nodefault};
};


class PASCALIMPLEMENTATION TIEDoubleList : public TIEList
{
	typedef TIEList inherited;
	
public:
	double operator[](int idx) { return Items[idx]; }
	
private:
	double fRangeMin;
	double fRangeMax;
	double fRangeStep;
	double fCurrentValue;
	double __fastcall GetItem(int idx);
	void __fastcall SetItem(int idx, double v);
	void __fastcall SetRangeMax(double v);
	void __fastcall SetRangeMin(double v);
	void __fastcall SetRangeStep(double v);
	void __fastcall SetCurrentValue(double v);
	double __fastcall GetCurrentValue(void);
	
public:
	int __fastcall Add(double v);
	void __fastcall Insert(int idx, double v);
	virtual void __fastcall Clear(void);
	int __fastcall IndexOf(double v);
	__property double RangeMin = {read=fRangeMin, write=SetRangeMin};
	__property double RangeMax = {read=fRangeMax, write=SetRangeMax};
	__property double RangeStep = {read=fRangeStep, write=SetRangeStep};
	__property double Items[int idx] = {read=GetItem, write=SetItem/*, default*/};
	virtual void __fastcall Assign(TIEList* Source);
	__property double CurrentValue = {read=GetCurrentValue, write=SetCurrentValue};
public:
	/* TIEList.Create */ inline __fastcall virtual TIEDoubleList(TIEListCurrentValueEvent OnGetCurrentValue, TIEListCurrentValueEvent OnSetCurrentValue) : TIEList(OnGetCurrentValue, OnSetCurrentValue) { }
	/* TIEList.Destroy */ inline __fastcall virtual ~TIEDoubleList(void) { }
	
};


class PASCALIMPLEMENTATION TIEIntegerList : public TIEList
{
	typedef TIEList inherited;
	
public:
	int operator[](int idx) { return Items[idx]; }
	
private:
	int fRangeMin;
	int fRangeMax;
	int fRangeStep;
	int fCurrentValue;
	int __fastcall GetItem(int idx);
	void __fastcall SetItem(int idx, int v);
	void __fastcall SetRangeMax(int v);
	void __fastcall SetRangeMin(int v);
	void __fastcall SetRangeStep(int v);
	void __fastcall SetCurrentValue(int v);
	int __fastcall GetCurrentValue(void);
	
public:
	int __fastcall Add(int v);
	void __fastcall Insert(int idx, int v);
	virtual void __fastcall Clear(void);
	int __fastcall IndexOf(int v);
	__property int RangeMin = {read=fRangeMin, write=SetRangeMin, nodefault};
	__property int RangeMax = {read=fRangeMax, write=SetRangeMax, nodefault};
	__property int RangeStep = {read=fRangeStep, write=SetRangeStep, nodefault};
	__property int Items[int idx] = {read=GetItem, write=SetItem/*, default*/};
	virtual void __fastcall Assign(TIEList* Source);
	__property int CurrentValue = {read=GetCurrentValue, write=SetCurrentValue, nodefault};
public:
	/* TIEList.Create */ inline __fastcall virtual TIEIntegerList(TIEListCurrentValueEvent OnGetCurrentValue, TIEListCurrentValueEvent OnSetCurrentValue) : TIEList(OnGetCurrentValue, OnSetCurrentValue) { }
	/* TIEList.Destroy */ inline __fastcall virtual ~TIEIntegerList(void) { }
	
};


class PASCALIMPLEMENTATION TIERecordList : public TIEList
{
	typedef TIEList inherited;
	
public:
	void * operator[](int idx) { return Items[idx]; }
	
private:
	void * __fastcall GetItem(int idx);
	void __fastcall SetItem(int idx, void * v);
	
public:
	int __fastcall Add(void * v);
	void __fastcall Insert(int idx, void * v);
	int __fastcall IndexOf(void * v);
	__property void * Items[int idx] = {read=GetItem, write=SetItem/*, default*/};
	__fastcall TIERecordList(int RecordSize);
public:
	/* TIEList.Create */ inline __fastcall virtual TIERecordList(TIEListCurrentValueEvent OnGetCurrentValue, TIEListCurrentValueEvent OnSetCurrentValue) : TIEList(OnGetCurrentValue, OnSetCurrentValue) { }
	/* TIEList.Destroy */ inline __fastcall virtual ~TIERecordList(void) { }
	
};


#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEMarkerList : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::Classes::TList* fData;
	System::Classes::TList* fType;
	int __fastcall GetCount(void);
	char * __fastcall GetMarkerData(int idx);
	System::Classes::TStream* __fastcall GetMarkerStream(int idx);
	System::Byte __fastcall GetMarkerType(int idx);
	System::Word __fastcall GetMarkerLength(int idx);
	int __fastcall SortCompare(int Index1, int Index2);
	void __fastcall SortSwap(int Index1, int Index2);
	
public:
	__fastcall TIEMarkerList(void);
	__fastcall virtual ~TIEMarkerList(void);
	int __fastcall AddMarker(System::Byte marker, char * data, System::Word datalen);
	void __fastcall SetMarker(int idx, System::Byte marker, char * data, System::Word datalen);
	void __fastcall InsertMarker(int idx, char * data, System::Byte marker, System::Word datalen);
	void __fastcall Clear(void);
	__property char * MarkerData[int idx] = {read=GetMarkerData};
	__property System::Classes::TStream* MarkerStream[int idx] = {read=GetMarkerStream};
	__property System::Word MarkerLength[int idx] = {read=GetMarkerLength};
	__property System::Byte MarkerType[int idx] = {read=GetMarkerType};
	int __fastcall IndexOf(System::Byte marker);
	void __fastcall SaveToStream(System::Classes::TStream* Stream);
	void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	void __fastcall DeleteMarker(int idx);
	void __fastcall DeleteMarkerInstances(System::Byte markerType);
	__property int Count = {read=GetCount, nodefault};
	void __fastcall Assign(TIEMarkerList* Source);
	void __fastcall Sort(void);
};

#pragma pack(pop)

#pragma pack(push,1)
struct DECLSPEC_DRECORD TIPTCInfo
{
public:
	int fRecord;
	int fDataSet;
	int fLength;
};
#pragma pack(pop)


typedef TIPTCInfo *PIPTCInfo;

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEIPTCInfoList : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::Classes::TList* fBuffer;
	System::Classes::TList* fInfo;
	bool fUserChanged;
	System::UnicodeString __fastcall GetStrings(int idx);
	void __fastcall SetStrings(int idx, System::UnicodeString Value);
	int __fastcall GetRecordNumber(int idx);
	void __fastcall SetRecordNumber(int idx, int Value);
	int __fastcall GetDataSet(int idx);
	void __fastcall SetDataSet(int idx, int Value);
	int __fastcall GetCount(void);
	
public:
	__fastcall TIEIPTCInfoList(void);
	__fastcall virtual ~TIEIPTCInfoList(void);
	__property System::UnicodeString StringItem[int idx] = {read=GetStrings, write=SetStrings};
	__property int RecordNumber[int idx] = {read=GetRecordNumber, write=SetRecordNumber};
	__property int DataSet[int idx] = {read=GetDataSet, write=SetDataSet};
	int __fastcall AddStringItem(int ARecordNumber, int ADataSet, System::AnsiString Value);
	int __fastcall AddBufferItem(int ARecordNumber, int ADataSet, void * Buffer, int BufferLength);
	void __fastcall InsertStringItem(int idx, int ARecordNumber, int ADataSet, System::AnsiString Value);
	void __fastcall Clear(void);
	int __fastcall IndexOf(int ARecordNumber, int ADataSet);
	void __fastcall DeleteItem(int idx);
	__property int Count = {read=GetCount, nodefault};
	void __fastcall Assign(TIEIPTCInfoList* Source);
	void __fastcall SaveToStream(System::Classes::TStream* Stream);
	void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	bool __fastcall LoadFromStandardBuffer(void * Buffer, int BufferLength);
	void __fastcall SaveToStandardBuffer(void * &Buffer, int &BufferLength, bool WriteHeader);
	__property bool UserChanged = {read=fUserChanged, write=fUserChanged, nodefault};
	void * __fastcall GetItemData(int idx);
	int __fastcall GetItemLength(int idx);
};

#pragma pack(pop)

enum DECLSPEC_DENUM TIEPixelFormat : unsigned char { ienull, ie1g, ie8p, ie8g, ie16g, ie24RGB, ie32f, ieCMYK, ie48RGB, ieCIELab, ie32RGB };

typedef System::Set<TIEPixelFormat, TIEPixelFormat::ienull, TIEPixelFormat::ie32RGB> TIEPixelFormatSet;

enum DECLSPEC_DENUM Hyieutils__71 : unsigned char { iedRead, iedWrite };

typedef System::Set<Hyieutils__71, Hyieutils__71::iedRead, Hyieutils__71::iedWrite> TIEDataAccess;

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEBaseBitmap : public System::TObject
{
	typedef System::TObject inherited;
	
protected:
	TIEDataAccess fAccess;
	virtual void * __fastcall GetScanLine(int Row) = 0 ;
	virtual int __fastcall GetBitCount(void) = 0 ;
	virtual int __fastcall GetHeight(void) = 0 ;
	virtual int __fastcall GetWidth(void) = 0 ;
	virtual void __fastcall SetWidth(int Value) = 0 ;
	virtual void __fastcall SetHeight(int Value) = 0 ;
	virtual TIEPixelFormat __fastcall GetPixelFormat(void) = 0 ;
	virtual int __fastcall GetRowLen(void) = 0 ;
	virtual void * __fastcall GetPaletteBuffer(void) = 0 ;
	virtual Hyiedefs::TRGB __fastcall GetPalette(int index) = 0 ;
	virtual void __fastcall SetPalette(int index, Hyiedefs::TRGB Value) = 0 ;
	virtual int __fastcall GetPaletteLen(void) = 0 ;
	virtual int __fastcall GetPaletteUsed(void) = 0 ;
	virtual void __fastcall SetPaletteUsed(int Value) = 0 ;
	
public:
	__property void * Scanline[int row] = {read=GetScanLine};
	__property int BitCount = {read=GetBitCount, nodefault};
	__property int Width = {read=GetWidth, write=SetWidth, nodefault};
	__property int Height = {read=GetHeight, write=SetHeight, nodefault};
	__property TIEPixelFormat PixelFormat = {read=GetPixelFormat, nodefault};
	virtual bool __fastcall Allocate(int ImageWidth, int ImageHeight, TIEPixelFormat ImagePixelFormat) = 0 ;
	virtual void __fastcall Assign(System::TObject* Source) = 0 ;
	virtual void __fastcall AssignImage(TIEBaseBitmap* Source) = 0 ;
	__property int RowLen = {read=GetRowLen, nodefault};
	__property TIEDataAccess Access = {read=fAccess, write=fAccess, nodefault};
	__property Hyiedefs::TRGB Palette[int index] = {read=GetPalette, write=SetPalette};
	__property void * PaletteBuffer = {read=GetPaletteBuffer};
	__property int PaletteUsed = {read=GetPaletteUsed, write=SetPaletteUsed, nodefault};
	__property int PaletteLength = {read=GetPaletteLen, nodefault};
	virtual void __fastcall CopyPaletteTo(TIEBaseBitmap* Dest) = 0 ;
public:
	/* TObject.Create */ inline __fastcall TIEBaseBitmap(void) : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TIEBaseBitmap(void) { }
	
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIETemporaryFileStream : public System::Classes::THandleStream
{
	typedef System::Classes::THandleStream inherited;
	
private:
	NativeUInt FHandle;
	
public:
	__fastcall TIETemporaryFileStream(const System::UnicodeString FileName);
	__fastcall virtual ~TIETemporaryFileStream(void);
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEWideFileStream : public System::Classes::THandleStream
{
	typedef System::Classes::THandleStream inherited;
	
private:
	System::WideString FFileName;
	
public:
	__fastcall TIEWideFileStream(const System::WideString FileName, System::Word Mode);
	__fastcall virtual ~TIEWideFileStream(void);
	__property System::WideString FileName = {read=FFileName};
};

#pragma pack(pop)

struct DECLSPEC_DRECORD TIEFileBufferItem
{
public:
	__int64 Pos;
	__int64 Size;
	void *ptr;
	TIEDataAccess access;
};


typedef TIEFileBufferItem *PIEFileBufferItem;

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEFileBuffer : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::Classes::TStream* fSimFile;
	System::UnicodeString fFileName;
	System::Classes::TList* fMapped;
	int __fastcall IndexOf(void * ptr);
	
public:
	__fastcall TIEFileBuffer(void);
	__fastcall virtual ~TIEFileBuffer(void);
	bool __fastcall AllocateFile(__int64 InSize, const System::UnicodeString Descriptor, bool UseDisk);
	void __fastcall ReAllocateFile(__int64 NewSize);
	void * __fastcall Map(__int64 InPos, __int64 InSize, TIEDataAccess DataAccess);
	void __fastcall UnMap(void * ptr);
	void __fastcall UnMapAll(void);
	bool __fastcall IsAllocated(void);
	void __fastcall DeAllocate(void);
	void __fastcall CopyTo(TIEFileBuffer* Dest, __int64 InPos, __int64 InSize)/* overload */;
	void __fastcall CopyTo(System::Classes::TStream* Dest, __int64 InPos, __int64 InSize)/* overload */;
};

#pragma pack(pop)

enum DECLSPEC_DENUM TIEHashAlgorithm : unsigned short { iehaMD2 = 32769, iehaMD4, iehaMD5, iehaSHA };

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEHashStream : public System::Classes::TStream
{
	typedef System::Classes::TStream inherited;
	
private:
	System::Classes::TMemoryStream* m_MemStream;
	void *m_CryptProvider;
	void *m_CryptHash;
	
public:
	__fastcall TIEHashStream(TIEHashAlgorithm Algorithm, bool Buffered);
	__fastcall virtual ~TIEHashStream(void);
	System::AnsiString __fastcall GetHash(void);
	virtual int __fastcall Write(const void *Buffer, int Count)/* overload */;
	virtual int __fastcall Read(void *Buffer, int Count)/* overload */;
	virtual __int64 __fastcall Seek(const __int64 Offset, System::Classes::TSeekOrigin Origin)/* overload */;
	void __fastcall SaveToFile(const System::WideString filename);
	void __fastcall SaveToStream(System::Classes::TStream* Stream);
	void __fastcall LoadFromFile(const System::WideString filename);
	void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	/* Hoisted overloads: */
	
public:
	inline int __fastcall  Write(const System::DynamicArray<System::Byte> Buffer, int Offset, int Count){ return System::Classes::TStream::Write(Buffer, Offset, Count); }
	inline int __fastcall  Write(const System::DynamicArray<System::Byte> Buffer, int Count){ return System::Classes::TStream::Write(Buffer, Count); }
	inline int __fastcall  Read(System::DynamicArray<System::Byte> Buffer, int Offset, int Count){ return System::Classes::TStream::Read(Buffer, Offset, Count); }
	inline int __fastcall  Read(System::DynamicArray<System::Byte> &Buffer, int Count){ return System::Classes::TStream::Read(Buffer, Count); }
	inline int __fastcall  Seek(int Offset, System::Word Origin){ return System::Classes::TStream::Seek(Offset, Origin); }
	inline __int64 __fastcall  Seek _DEPRECATED_ATTRIBUTE0 (const __int64 Offset, System::Word Origin){ return System::Classes::TStream::Seek(Offset, Origin); }
	
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEMemStream : public System::Classes::TCustomMemoryStream
{
	typedef System::Classes::TCustomMemoryStream inherited;
	
public:
	__fastcall TIEMemStream(void * Ptr, int Size);
	virtual void __fastcall SetSize(int NewSize)/* overload */;
	virtual int __fastcall Write(const void *Buffer, int Count)/* overload */;
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TIEMemStream(void) { }
	
	/* Hoisted overloads: */
	
protected:
	inline void __fastcall  SetSize(const __int64 NewSize){ System::Classes::TStream::SetSize(NewSize); }
	
public:
	inline int __fastcall  Write(const System::DynamicArray<System::Byte> Buffer, int Offset, int Count){ return System::Classes::TStream::Write(Buffer, Offset, Count); }
	inline int __fastcall  Write(const System::DynamicArray<System::Byte> Buffer, int Count){ return System::Classes::TStream::Write(Buffer, Count); }
	
};

#pragma pack(pop)

struct DECLSPEC_DRECORD IE_PROFILE
{
public:
	unsigned dwType;
	void *pProfileData;
	unsigned cbDataSize;
};


typedef IE_PROFILE *IE_PPROFILE;

typedef NativeUInt IE_HPROFILE;

typedef NativeUInt *IE_PHPROFILE;

typedef NativeUInt IE_HTRANSFORM;

typedef System::LongBool __stdcall (*TIE_ICMProgressProcCallback)(unsigned ulMax, unsigned ulCurrent, NativeInt ulCallbackData);

typedef NativeUInt __stdcall (*TIE_OpenColorProfile)(IE_PPROFILE pProfile, unsigned dwDesiredAccess, unsigned dwShareMode, unsigned dwCreationMode);

typedef System::LongBool __stdcall (*TIE_CloseColorProfile)(NativeUInt hProfile);

typedef NativeUInt __stdcall (*TIE_CreateMultiProfileTransform)(IE_PHPROFILE pahProfiles, unsigned nProfiles, unsigned* padwIntent, unsigned nIntents, unsigned dwFlags, unsigned indexPreferredCMM);

typedef System::LongBool __stdcall (*TIE_DeleteColorTransform)(NativeUInt hColorTransform);

typedef System::LongBool __stdcall (*TIE_TranslateColors)(NativeUInt hColorTransform, void * paInputColors, unsigned nColors, unsigned ctInput, void * paOutputColors, unsigned ctOutput);

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEICC : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	bool fUseLCMS;
	System::Byte *fRaw;
	int fRawLen;
	void *fProfile;
	TIEMemStream* fProfileStream;
	NativeUInt fMSProfile;
	bool fApplied;
	void *fTransform;
	int fInputFormat;
	int fOutputFormat;
	TIEICC* fDestination;
	int fIntent;
	int fFlags;
	NativeUInt fMSTransform;
	System::AnsiString fCopyright;
	System::AnsiString fDescription;
	System::AnsiString fInputColorSpace;
	System::AnsiString fOutputColorSpace;
	void __fastcall OpenProfileFromRaw(void);
	void __fastcall CloseProfileFromRaw(void);
	void __fastcall ExtractInfo(void);
	
public:
	__property NativeUInt MSTransform = {read=fMSTransform, nodefault};
	__fastcall TIEICC(bool UseLCMS);
	__fastcall virtual ~TIEICC(void);
	void __fastcall LoadFromBuffer(void * buffer, int bufferlen);
	void __fastcall Clear(void);
	void __fastcall SaveToStream(System::Classes::TStream* Stream, bool StandardICC);
	void __fastcall LoadFromStream(System::Classes::TStream* Stream, bool StandardICC);
	void __fastcall LoadFromFile(const System::UnicodeString FileName);
	void __fastcall Assign(TIEICC* source);
	bool __fastcall IsValid(void);
	__property bool IsApplied = {read=fApplied, nodefault};
	__property System::PByte Raw = {read=fRaw};
	__property int RawLength = {read=fRawLen, nodefault};
	void __fastcall Assign_sRGBProfile(void);
	void __fastcall Assign_LabProfile(double WhitePoint_x, double WhitePoint_y, double WhitePoint_Y_);
	void __fastcall Assign_LabProfileFromTemp(int TempK);
	void __fastcall Assign_LabProfileD50(void);
	void __fastcall Assign_XYZProfile(void);
	void __fastcall Assign_AdobeRGB1998(void);
	void __fastcall Assign_CMYKProfile(void);
	bool __fastcall InitTransform(TIEICC* Destination, int InputFormat, int OutputFormat, int Intent, int Flags);
	void __fastcall FreeTransform(void);
	bool __fastcall Transform(TIEICC* Destination, int InputFormat, int OutputFormat, int Intent, int Flags, void * InputBuffer, void * OutputBuffer, int ImageWidth);
	bool __fastcall Apply(TIEBaseBitmap* SourceBitmap, int SourceFormat, TIEBaseBitmap* DestinationBitmap, int DestinationFormat, TIEICC* DestinationProfile, int Intent, int Flags);
	bool __fastcall Apply2(TIEBaseBitmap* Bitmap, int SourceFormat, int DestinationFormat, TIEICC* DestinationProfile, int Intent, int Flags);
	bool __fastcall ConvertBitmap(TIEBaseBitmap* Bitmap, TIEPixelFormat DestPixelFormat, TIEICC* DestProfile);
	bool __fastcall IsTransforming(void);
	bool __fastcall CheckTransform(int InputFormat)/* overload */;
	bool __fastcall CheckTransform(Hyiedefs::TIEColorSpace InputFormat)/* overload */;
	__property System::AnsiString Copyright = {read=fCopyright};
	__property System::AnsiString Description = {read=fDescription};
	__property System::AnsiString InputColorSpace = {read=fInputColorSpace};
	__property System::AnsiString OutputColorSpace = {read=fOutputColorSpace};
};

#pragma pack(pop)

enum DECLSPEC_DENUM TIELocation : unsigned char { ieMemory, ieFile, ieTBitmap };

enum DECLSPEC_DENUM TIERenderOperation : unsigned char { ielNormal, ielAdd, ielSub, ielDiv, ielMul, ielOR, ielAND, ielXOR, ielMAX, ielMIN, ielAverage, ielScreen, ielNegation, ielExclusion, ielOverlay, ielHardLight, ielSoftLight, ielXFader, ielColorEdge, ielColorBurn, ielInverseColorDodge, ielInverseColorBurn, ielSoftDodge, ielSoftBurn, ielReflect, ielGlow, ielFreeze, ielEat, ielSubtractive, ielInterpolation, ielStamp, ielRed, ielGreen, ielBlue, ielHue, ielSaturation, ielColor, ielLuminosity, ielStereoBW, ielStereoColor, ielStereoColorDubois, ielStereoEven, ielStereoOdd, ielLuminosity2 };

enum DECLSPEC_DENUM TIEDitherMethod : unsigned char { ieOrdered, ieThreshold, ieDithering };

enum DECLSPEC_DENUM TIEHAlign : unsigned char { iehLeft, iehCenter, iehRight };

enum DECLSPEC_DENUM TIEVAlign : unsigned char { ievTop, ievCenter, ievBottom };

enum DECLSPEC_DENUM TIEMemoryAllocator : unsigned char { iemaVCL, iemaSystem, iemaAuto };

enum DECLSPEC_DENUM TIEBitmapOrigin : unsigned char { ieboBOTTOMLEFT, ieboTOPLEFT };

typedef void __fastcall (__closure *TIERenderVirtualPixel)(System::TObject* Sender, int SrcX, int SrcY, Hyiedefs::TRGB &outval);

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEVirtualBitmapProvider : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	virtual void __fastcall Render(TIEBitmap* Container, int DestWidth, int DestHeight, Hyiedefs::PPointerArray DestScanlines, int DestX1, int DestY1, int DestX2, int DestY2, System::PInteger SrcCols, System::PInteger SrcRows, int Transparency, TIERenderOperation RenderOperation, double Opacity) = 0 ;
	virtual void * __fastcall GetSegment(TIEBitmap* Container, int Row, int Col, int Width) = 0 ;
public:
	/* TObject.Create */ inline __fastcall TIEVirtualBitmapProvider(void) : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TIEVirtualBitmapProvider(void) { }
	
};

#pragma pack(pop)

class PASCALIMPLEMENTATION TIEBitmap : public TIEBaseBitmap
{
	typedef TIEBaseBitmap inherited;
	
private:
	TIEFileBuffer* fmemmap;
	void *fWorkingMap;
	Hyiedefs::TIERGBPalette *fRGBPalette;
	int fRGBPaletteLen;
	int fPaletteUsed;
	TIEBitmap* fAlphaChannel;
	void *fMemory;
	void *fRealMemory;
	Vcl::Graphics::TBitmap* fBitmap;
	Hyiedefs::TPointerArray *fBitmapScanlines;
	System::Classes::TList* fScanlinesToUnMapPtr;
	System::Classes::TList* fScanlinesToUnMapRow;
	TIEBitmapOrigin fOrigin;
	int fWidth;
	int fHeight;
	int fBitCount;
	int fChannelCount;
	__int64 fRowLen;
	TIEPixelFormat fPixelFormat;
	bool fIsAlpha;
	TIELocation fLocation;
	bool fFull;
	bool fEncapsulatedFromTBitmap;
	bool fEncapsulatedFromMemory;
	__int64 fMinFileSize;
	TIEDitherMethod fDefaultDitherMethod;
	TIEICC* fColorProfile;
	TIEICC* fRenderColorProfile;
	double fBlackValue;
	double fWhiteValue;
	System::StaticArray<int, 4> fChannelOffset;
	bool fEnableChannelOffset;
	int fContrast;
	int fBitAlignment;
	TIEMemoryAllocator fMemoryAllocator;
	bool fFullReallocate;
	void *fUndoInfo;
	int fCanvasCurrentAlpha;
	Iegdiplus::TIECanvas* fIECanvas;
	int fFragmentsCount;
	int fRowsPerFragment;
	Hyiedefs::TPointerArray *fFragments;
	TIERenderVirtualPixel fOnRenderVirtualPixel;
	System::TObject* fVirtualBitmapProvider;
	void *fVirtualBitmapRowBuffer;
	TIEBitmap* fROIOriginalBitmap;
	System::Types::TRect fROIOriginalRect;
	Iegdiplus::TIECanvas* fROICanvas;
	bool __fastcall AllocateImage(void);
	void __fastcall SetPixelFormat(TIEPixelFormat Value);
	void __fastcall ConvertToPixelFormat(TIEPixelFormat DestPixelFormat);
	bool __fastcall GetPixels_ie1g(int x, int y);
	System::Byte __fastcall GetPixels_ie8(int x, int y);
	System::Word __fastcall GetPixels_ie16g(int x, int y);
	Hyiedefs::TRGB __fastcall GetPixels_ie24RGB(int x, int y);
	Hyiedefs::TRGBA __fastcall GetPixels_ie32RGB(int x, int y);
	float __fastcall GetPixels_ie32f(int x, int y);
	Hyiedefs::TCMYK __fastcall GetPixels_ieCMYK(int x, int y);
	Hyiedefs::TCIELab __fastcall GetPixels_ieCIELab(int x, int y);
	Hyiedefs::TRGB48 __fastcall GetPixels_ie48RGB(int x, int y);
	Hyiedefs::PRGB __fastcall GetPPixels_ie24RGB(int x, int y);
	Hyiedefs::PRGBA __fastcall GetPPixels_ie32RGB(int x, int y);
	Hyiedefs::PRGB48 __fastcall GetPPixels_ie48RGB(int x, int y);
	Hyiedefs::TRGB __fastcall GetPixels(int x, int y);
	void __fastcall SetPixels(int x, int y, Hyiedefs::TRGB value);
	void __fastcall SetPixels_ie1g(int x, int y, bool Value);
	void __fastcall SetPixels_ie8(int x, int y, System::Byte Value);
	void __fastcall SetPixels_ie16g(int x, int y, System::Word Value);
	void __fastcall SetPixels_ie24RGB(int x, int y, Hyiedefs::TRGB Value);
	void __fastcall SetPixels_ie32RGB(int x, int y, Hyiedefs::TRGBA Value);
	void __fastcall SetPixels_ie32f(int x, int y, float Value);
	void __fastcall SetPixels_ieCMYK(int x, int y, Hyiedefs::TCMYK Value);
	void __fastcall SetPixels_ieCIELab(int x, int y, Hyiedefs::TCIELab Value);
	void __fastcall SetPixels_ie48RGB(int x, int y, const Hyiedefs::TRGB48 &Value);
	System::Byte __fastcall GetAlpha(int x, int y);
	void __fastcall SetAlpha(int x, int y, System::Byte Value);
	void __fastcall SetLocation(TIELocation Value);
	void __fastcall UpdateTBitmapPalette(void);
	void __fastcall CopyPaletteFromTBitmap(Vcl::Graphics::TBitmap* source, int colors);
	bool __fastcall GetHasAlphaChannel(void);
	void __fastcall FreeBitmapScanlines(void);
	void __fastcall BuildBitmapScanlines(void);
	Vcl::Graphics::TBitmap* __fastcall GetVclBitmap(void);
	void __fastcall SetChannelOffset(int idx, int value);
	int __fastcall GetChannelOffset(int idx);
	void __fastcall SetBitAlignment(int value);
	int __fastcall GetChannelCount(void);
	void __fastcall SetCanvasCurrentAlpha(int v);
	void __fastcall SetAlphaChannel(TIEBitmap* value);
	void __fastcall FragmentedAlloc(void);
	void __fastcall FreeFragments(void);
	void __fastcall AllocateMemory(__int64 size, void * &StartBuffer, void * &AlignedBuffer);
	void __fastcall SetOrigin(TIEBitmapOrigin value);
	bool __fastcall GetIsVirtual(void);
	void __fastcall SetVirtualBitmapProvider(System::TObject* value);
	void __fastcall ReleaseROI(void);
	void __fastcall DestroyMe(System::TObject* Sender);
	void * __fastcall GetMemory(void);
	
protected:
	Vcl::Graphics::TCanvas* __fastcall GetCanvas(void);
	Iegdiplus::TIECanvas* __fastcall GetIECanvas(void);
	TIEBitmap* __fastcall GetAlphaChannel(void);
	TIEBitmap* __fastcall GetAlphaChannelOpt(void);
	virtual int __fastcall GetBitCount(void);
	virtual int __fastcall GetWidth(void);
	virtual int __fastcall GetHeight(void);
	virtual void __fastcall SetWidth(int Value);
	virtual void __fastcall SetHeight(int Value);
	virtual int __fastcall GetRowLen(void);
	virtual void * __fastcall GetScanLine(int Row);
	virtual TIEPixelFormat __fastcall GetPixelFormat(void);
	virtual Hyiedefs::TRGB __fastcall GetPalette(int index);
	virtual void * __fastcall GetPaletteBuffer(void);
	virtual void __fastcall SetPalette(int index, Hyiedefs::TRGB Value);
	virtual int __fastcall GetPaletteLen(void);
	virtual int __fastcall GetPaletteUsed(void);
	virtual void __fastcall SetPaletteUsed(int Value);
	void __fastcall FreeAllMaps(void);
	virtual void __fastcall Render_ie24RGB(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground, TIERenderOperation RenderOperation);
	virtual void __fastcall Render_ie24RGB_alpha(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, int Transparency, bool UseAlpha, System::PByte SimAlphaRow, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground, TIERenderOperation RenderOperation, double Opacity);
	virtual void __fastcall Render_ie32RGB(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground, TIERenderOperation RenderOperation);
	virtual void __fastcall Render_ie32RGB_alpha(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, int Transparency, bool UseAlpha, System::PByte SimAlphaRow, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground, TIERenderOperation RenderOperation, double Opacity);
	virtual void __fastcall Render_ie1g(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground);
	virtual void __fastcall Render_ie1g_alpha(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, int Transparency, bool UseAlpha, System::PByte SimAlphaRow, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground, double Opacity);
	virtual void __fastcall Render_ie8g(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground);
	virtual void __fastcall Render_ie8g_alpha(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, int Transparency, bool UseAlpha, System::PByte SimAlphaRow, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground, double Opacity);
	virtual void __fastcall Render_ie8p(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground);
	virtual void __fastcall Render_ie8p_alpha(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, int Transparency, bool UseAlpha, System::PByte SimAlphaRow, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground, double Opacity);
	virtual void __fastcall Render_ie16g(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground);
	virtual void __fastcall Render_ie16g_alpha(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, int Transparency, bool UseAlpha, System::PByte SimAlphaRow, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground, double Opacity);
	virtual void __fastcall Render_ie32f(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground);
	virtual void __fastcall Render_ie32f_alpha(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, int Transparency, bool UseAlpha, System::PByte SimAlphaRow, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground, double Opacity);
	virtual void __fastcall Render_ieCMYK(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground);
	virtual void __fastcall Render_ieCMYK_alpha(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, int Transparency, bool UseAlpha, System::PByte SimAlphaRow, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground, double Opacity);
	virtual void __fastcall Render_ieCIELab(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground);
	virtual void __fastcall Render_ieCIELab_alpha(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, int Transparency, bool UseAlpha, System::PByte SimAlphaRow, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground, double Opacity);
	virtual void __fastcall Render_ie48RGB(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground, TIERenderOperation RenderOperation);
	virtual void __fastcall Render_ie48RGB_alpha(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, int Transparency, bool UseAlpha, System::PByte SimAlphaRow, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground, TIERenderOperation RenderOperation, double Opacity);
	virtual void __fastcall Render_ieVirtual(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground, TIERenderOperation RenderOperation);
	virtual void __fastcall Render_ieVirtual_alpha(Hyiedefs::PPointerArray dbitmapscanline, TIEBitmap* &ABitmap, int Transparency, bool UseAlpha, System::PByte SimAlphaRow, System::PInteger XLUT, System::PInteger YLUT, int xSrc, int ySrc, int xDst, int yDst, int cx1, int cy1, int cx2, int cy2, int rx, int ry, bool SolidBackground, TIERenderOperation RenderOperation, double Opacity);
	
public:
	__fastcall TIEBitmap(void)/* overload */;
	__fastcall TIEBitmap(int ImageWidth, int ImageHeight, TIEPixelFormat ImagePixelFormat)/* overload */;
	__fastcall TIEBitmap(const System::UnicodeString FileName, System::TObject* IOParams)/* overload */;
	__fastcall TIEBitmap(TIEBitmap* image)/* overload */;
	__fastcall TIEBitmap(TIEBitmap* image, const System::Types::TRect &Rect)/* overload */;
	__fastcall TIEBitmap(Vcl::Graphics::TBitmap* image, const System::Types::TRect &Rect)/* overload */;
	__fastcall TIEBitmap(void * Buffer, int BufferSize, int Format)/* overload */;
	__fastcall TIEBitmap(int ImageWidth, int ImageHeight, TIELocation ImageLocation);
	__fastcall virtual ~TIEBitmap(void);
	TIEBitmap* __fastcall CreateROIBitmap(const System::Types::TRect &Rect, TIEPixelFormat ROIPixelFormat = (TIEPixelFormat)(0x0));
	Iegdiplus::TIECanvas* __fastcall CreateROICanvas(const System::Types::TRect &Rect, bool AntiAlias = true, bool UseGDIPlus = true);
	__property int Width = {read=GetWidth, write=SetWidth, nodefault};
	__property int Height = {read=GetHeight, write=SetHeight, nodefault};
	__property TIEPixelFormat PixelFormat = {read=GetPixelFormat, write=SetPixelFormat, nodefault};
	virtual void __fastcall Assign(System::TObject* Source);
	virtual void __fastcall AssignImage(TIEBaseBitmap* Source);
	__property void * ScanLine[int Row] = {read=GetScanLine};
	void * __fastcall GetSegment(int Row, int Col, int Width);
	void __fastcall UpdateFromTBitmap(void);
	void __fastcall AdjustCanvasOrientation(void);
	void __fastcall StretchValues(void);
	void __fastcall FixContrast(void);
	void __fastcall FixChannelOffset(void);
	bool __fastcall CheckFormat(TIEPixelFormatSet AllowedFormats, bool AutoConvert);
	__property void * Memory = {read=GetMemory};
	Ievision::_di_TIEVisionImage __fastcall GetIEVisionImage(void);
	bool __fastcall Read(const System::UnicodeString FileName, System::TObject* IOParams = (System::TObject*)(0x0))/* overload */;
	bool __fastcall Read(System::Classes::TStream* Stream, System::TObject* IOParams = (System::TObject*)(0x0))/* overload */;
	bool __fastcall Read(void * Buffer, int BufferSize, int Format = 0x0, System::TObject* IOParams = (System::TObject*)(0x0))/* overload */;
	bool __fastcall Write(const System::UnicodeString FileName, System::TObject* IOParams = (System::TObject*)(0x0))/* overload */;
	bool __fastcall Write(System::Classes::TStream* Stream, int FileType, System::TObject* IOParams = (System::TObject*)(0x0))/* overload */;
	System::AnsiString __fastcall GetHash(TIEHashAlgorithm Algorithm = (TIEHashAlgorithm)(0x8003));
	__property Hyiedefs::PPointerArray TBitmapScanlines = {read=fBitmapScanlines};
	__property Vcl::Graphics::TCanvas* Canvas = {read=GetCanvas};
	__property Iegdiplus::TIECanvas* IECanvas = {read=GetIECanvas};
	__property bool EncapsulatedFromTBitmap = {read=fEncapsulatedFromTBitmap, write=fEncapsulatedFromTBitmap, nodefault};
	__property bool EncapsulatedFromMemory = {read=fEncapsulatedFromMemory, write=fEncapsulatedFromMemory, nodefault};
	__property int Rowlen = {read=GetRowLen, nodefault};
	virtual bool __fastcall Allocate(int ImageWidth, int ImageHeight, TIEPixelFormat ImagePixelFormat = (TIEPixelFormat)(0x5));
	void __fastcall EncapsulateTBitmap(Vcl::Graphics::TBitmap* obj, bool DoFreeImage = false);
	void __fastcall EncapsulateMemory(void * mem, int bmpWidth, int bmpHeight, TIEPixelFormat bmpPixelFormat, bool DoFreeImage, TIEBitmapOrigin Origin = (TIEBitmapOrigin)(0x0));
	void __fastcall FreeImage(bool freeAlpha = true);
	void __fastcall SwitchTo(TIEBitmap* Target);
	__property TIEBitmap* AlphaChannel = {read=GetAlphaChannel, write=SetAlphaChannel};
	__property TIEBitmap* AlphaChannelOpt = {read=GetAlphaChannelOpt};
	__property bool IsAlpha = {read=fIsAlpha, nodefault};
	__property TIELocation Location = {read=fLocation, write=SetLocation, nodefault};
	void __fastcall CopyToTBitmap(Vcl::Graphics::TBitmap* Dest);
	void __fastcall CopyWithMask1(TIEBitmap* Dest, TIEMask* SourceMask, System::Uitypes::TColor Background)/* overload */;
	void __fastcall CopyWithMask1(TIEBitmap* Dest, TIEMask* SourceMask)/* overload */;
	void __fastcall CopyWithMask2(TIEBitmap* Dest, TIEMask* DestMask);
	void __fastcall CopyFromMemory(void * SrcBuffer, int SrcWidth, int SrcHeight, TIEPixelFormat SrcPixelFormat, TIEBitmapOrigin SrcOrigin, int SrcRowLen);
	void __fastcall CopyFromTBitmap(Vcl::Graphics::TBitmap* Source);
	void __fastcall CopyFromTIEMask(TIEMask* Source);
	void __fastcall CopyToTIEMask(TIEMask* Dest);
	void __fastcall CopyRectTo(TIEBitmap* Dest, int SrcX, int SrcY, int DstX, int DstY, int RectWidth, int RectHeight);
	void __fastcall MergeAlphaRectTo(TIEBitmap* Dest, int SrcX, int SrcY, int DstX, int DstY, int RectWidth, int RectHeight);
	void * __fastcall GetRow(int Row);
	void __fastcall FreeRow(int Row);
	void __fastcall Resize(int NewWidth, int NewHeight, double BackgroundValue = 0.000000E+00, int AlphaValue = 0xff, TIEHAlign HorizAlign = (TIEHAlign)(0x0), TIEVAlign VertAlign = (TIEVAlign)(0x0));
	void __fastcall Resample(int NewWidth, int NewHeight, Hyiedefs::TResampleFilter FilterType = (Hyiedefs::TResampleFilter)(0x0), bool bMaintainAspectRatio = false);
	void __fastcall Rotate(double Angle, Hyiedefs::TIEAntialiasMode AntiAliasMode = (Hyiedefs::TIEAntialiasMode)(0x1), System::Uitypes::TColor BackgroundColor = (System::Uitypes::TColor)(0x1))/* overload */;
	void __fastcall Rotate _DEPRECATED_ATTRIBUTE0 (double Angle, bool AntiAlias, Hyiedefs::TIEAntialiasMode AntialiasMode, System::Uitypes::TColor BackgroundColor)/* overload */;
	void __fastcall RotateEx(double Angle, Hyiedefs::TIEAntialiasMode AntialiasMode, System::Uitypes::TColor BackgroundColor, Hyiedefs::TIEProgressEvent OnProgress, System::TObject* Sender);
	void __fastcall Flip(Hyiedefs::TFlipDir Dir);
	__property Vcl::Graphics::TBitmap* VclBitmap = {read=GetVclBitmap, write=fBitmap};
	void __fastcall MoveRegion(int x1, int y1, int x2, int y2, int DstX, int DstY, double BackgroundValue, bool FillSource = true);
	void __fastcall CopyFromTDibBitmap(TIEDibbitmap* Source);
	void __fastcall MergeFromTDibBitmap(TIEDibbitmap* Source, int x, int y);
	void __fastcall CopyToTDibBitmap(TIEDibbitmap* Dest, int source_x, int source_y, int sourceWidth, int sourceHeight);
	void __fastcall CopyFromDIB(NativeUInt Source)/* overload */;
	void __fastcall CopyFromDIB(void * BitmapInfo, void * Pixels = (void *)(0x0))/* overload */;
	NativeUInt __fastcall CreateDIB(void)/* overload */;
	NativeUInt __fastcall CreateDIB(int x1, int y1, int x2, int y2)/* overload */;
	__property bool Pixels_ie1g[int x][int y] = {read=GetPixels_ie1g, write=SetPixels_ie1g};
	__property System::Byte Pixels_ie8[int x][int y] = {read=GetPixels_ie8, write=SetPixels_ie8};
	__property System::Word Pixels_ie16g[int x][int y] = {read=GetPixels_ie16g, write=SetPixels_ie16g};
	__property Hyiedefs::TRGB Pixels_ie24RGB[int x][int y] = {read=GetPixels_ie24RGB, write=SetPixels_ie24RGB};
	__property Hyiedefs::TRGBA Pixels_ie32RGB[int x][int y] = {read=GetPixels_ie32RGB, write=SetPixels_ie32RGB};
	__property float Pixels_ie32f[int x][int y] = {read=GetPixels_ie32f, write=SetPixels_ie32f};
	__property Hyiedefs::TCMYK Pixels_ieCMYK[int x][int y] = {read=GetPixels_ieCMYK, write=SetPixels_ieCMYK};
	__property Hyiedefs::TCIELab Pixels_ieCIELab[int x][int y] = {read=GetPixels_ieCIELab, write=SetPixels_ieCIELab};
	__property Hyiedefs::TRGB48 Pixels_ie48RGB[int x][int y] = {read=GetPixels_ie48RGB, write=SetPixels_ie48RGB};
	__property Hyiedefs::PRGB PPixels_ie24RGB[int x][int y] = {read=GetPPixels_ie24RGB};
	__property Hyiedefs::PRGBA PPixels_ie32RGB[int x][int y] = {read=GetPPixels_ie32RGB};
	__property Hyiedefs::PRGB48 PPixels_ie48RGB[int x][int y] = {read=GetPPixels_ie48RGB};
	__property Hyiedefs::TRGB Pixels[int x][int y] = {read=GetPixels, write=SetPixels};
	__property System::Byte Alpha[int x][int y] = {read=GetAlpha, write=SetAlpha};
	void __fastcall RenderToTIEBitmap(TIEBitmap* ABitmap, Hyiedefs::PPointerArray &ABitmapScanline, System::PInteger &XLUT, System::PInteger &YLUT, System::Types::PRect UpdRect, int xDst, int yDst, int dxDst, int dyDst, int xSrc, int ySrc, int dxSrc, int dySrc, bool EnableAlpha, bool SolidBackground, int Transparency, Hyiedefs::TResampleFilter Filter, bool FreeTables, TIERenderOperation RenderOperation = (TIERenderOperation)(0x0), double Opacity = 1.000000E+00);
	void __fastcall RenderToTBitmap(Vcl::Graphics::TBitmap* ABitmap, Hyiedefs::PPointerArray &ABitmapScanline, System::PInteger &XLUT, System::PInteger &YLUT, System::Types::PRect UpdRect, int xDst, int yDst, int dxDst, int dyDst, int xSrc, int ySrc, int dxSrc, int dySrc, bool EnableAlpha, bool SolidBackground, int Transparency, Hyiedefs::TResampleFilter Filter, bool FreeTables, TIERenderOperation RenderOperation = (TIERenderOperation)(0x0), double Opacity = 1.000000E+00);
	void __fastcall RenderToTBitmapEx(Vcl::Graphics::TBitmap* Dest, int xDst, int yDst, int dxDst, int dyDst, int xSrc, int ySrc, int dxSrc, int dySrc, int Transparency, Hyiedefs::TResampleFilter Filter, TIERenderOperation RenderOperation = (TIERenderOperation)(0x0), double Opacity = 1.000000E+00);
	void __fastcall RenderToTIEBitmapEx(TIEBitmap* Dest, int xDst, int yDst, int dxDst, int dyDst, int xSrc, int ySrc, int dxSrc, int dySrc, int Transparency, Hyiedefs::TResampleFilter Filter, TIERenderOperation RenderOperation = (TIERenderOperation)(0x0), double Opacity = 1.000000E+00);
	void __fastcall RenderToCanvasWithAlpha(Vcl::Graphics::TCanvas* Dest, int xDst, int yDst, int dxDst, int dyDst, int xSrc, int ySrc, int dxSrc, int dySrc, int Transparency = 0xff, Hyiedefs::TResampleFilter Filter = (Hyiedefs::TResampleFilter)(0x0), TIERenderOperation RenderOperation = (TIERenderOperation)(0x0), double Opacity = 1.000000E+00);
	void __fastcall StretchRectTo(TIEBitmap* Dest, int xDst, int yDst, int dxDst, int dyDst, int xSrc, int ySrc, int dxSrc, int dySrc, Hyiedefs::TResampleFilter Filter, int Transparency, double Opacity = 1.000000E+00);
	void __fastcall RenderToCanvas(Vcl::Graphics::TCanvas* DestCanvas, int xDst, int yDst, int dxDst, int dyDst, Hyiedefs::TResampleFilter Filter, double Gamma);
	void __fastcall DrawToCanvas(Vcl::Graphics::TCanvas* DestCanvas, int xDst, int yDst);
	void __fastcall DrawToCanvasWithAlpha(Vcl::Graphics::TCanvas* DestCanvas, int xDst, int yDst, int Transparency, double Opacity);
	void __fastcall DrawToTIEBitmap(TIEBitmap* Dest, int XDest, int YDest)/* overload */;
	void __fastcall DrawToTIEBitmap(TIEBitmap* Dest, int XDest, int YDest, const Hyiedefs::TIERectangle &SrcRect)/* overload */;
	void __fastcall DrawToTIEBitmap(TIEBitmap* Dest, const Hyiedefs::TIERectangle &DestRect, const Hyiedefs::TIERectangle &SrcRect, Hyiedefs::TResampleFilter Filter = (Hyiedefs::TResampleFilter)(0x5))/* overload */;
	void __fastcall SynchronizeRGBA(bool RGBAtoAlpha);
	void __fastcall MergeWithAlpha(TIEBitmap* Bitmap, int DstX = 0x0, int DstY = 0x0, int DstWidth = 0xffffffff, int DstHeight = 0xffffffff, int Transparency = 0xff, Hyiedefs::TResampleFilter ResampleFilter = (Hyiedefs::TResampleFilter)(0x0), TIERenderOperation Operation = (TIERenderOperation)(0x0), bool Resample = true, int SrcX = 0x0, int SrcY = 0x0, double Opacity = 1.000000E+00);
	__property bool Full = {read=fFull, write=fFull, nodefault};
	__property TIEBitmapOrigin Origin = {read=fOrigin, write=SetOrigin, nodefault};
	void __fastcall SyncFull(void);
	void __fastcall Fill(double Value)/* overload */;
	void __fastcall FillRect(int x1, int y1, int x2, int y2, double Value);
	__property bool HasAlphaChannel = {read=GetHasAlphaChannel, nodefault};
	__property __int64 MinFileSize = {read=fMinFileSize, write=fMinFileSize};
	void __fastcall RemoveAlphaChannel(bool Merge = false, System::Uitypes::TColor BackgroundColor = (System::Uitypes::TColor)(0xffffff));
	__property TIEDitherMethod DefaultDitherMethod = {read=fDefaultDitherMethod, write=fDefaultDitherMethod, nodefault};
	__property double BlackValue = {read=fBlackValue, write=fBlackValue};
	__property double WhiteValue = {read=fWhiteValue, write=fWhiteValue};
	void __fastcall AutoCalcBWValues(void);
	__property int ChannelOffset[int idx] = {read=GetChannelOffset, write=SetChannelOffset};
	__property int Contrast = {read=fContrast, write=fContrast, nodefault};
	bool __fastcall IsGrayScale(void);
	bool __fastcall IsAllBlack(void);
	__property int BitAlignment = {read=fBitAlignment, write=SetBitAlignment, nodefault};
	bool __fastcall IsEmpty(void);
	void __fastcall CopyAndConvertFormat(TIEBitmap* Source);
	__property int ChannelCount = {read=GetChannelCount, nodefault};
	__property int BitCount = {read=GetBitCount, nodefault};
	__property TIEMemoryAllocator MemoryAllocator = {read=fMemoryAllocator, write=fMemoryAllocator, nodefault};
	int __fastcall CalcRAWSize(void);
	void __fastcall SaveRAWToBufferOrStream(void * Buffer, System::Classes::TStream* Stream, bool StreamHasSize = true);
	bool __fastcall LoadRAWFromBufferOrStream(void * Buffer, System::Classes::TStream* Stream);
	__property void * UndoInfo = {read=fUndoInfo, write=fUndoInfo};
	__property int CanvasCurrentAlpha = {read=fCanvasCurrentAlpha, write=SetCanvasCurrentAlpha, nodefault};
	virtual void __fastcall CopyPaletteTo(TIEBaseBitmap* Dest);
	__property int FragmentsCount = {read=fFragmentsCount, nodefault};
	__property TIERenderVirtualPixel OnRenderVirtualPixel = {read=fOnRenderVirtualPixel, write=fOnRenderVirtualPixel};
	__property System::TObject* VirtualBitmapProvider = {read=fVirtualBitmapProvider, write=SetVirtualBitmapProvider};
	__property bool IsVirtual = {read=GetIsVirtual, nodefault};
	__property TIEICC* ColorProfile = {read=fColorProfile};
};


class PASCALIMPLEMENTATION TIEMask : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	int fWidth;
	int fHeight;
	int fBitsperpixel;
	__int64 fRowlen;
	System::Byte *fBits;
	int fX1;
	int fY1;
	int fX2;
	int fY2;
	Hyiedefs::TBitmapInfoHeader256 fBitmapInfoHeader1;
	System::Byte *fTmpBmp;
	int fTmpBmpWidth;
	int fTmpBmpHeight;
	Hyiedefs::TPointerArray *fTmpBmpScanline;
	bool fFull;
	Vcl::Graphics::TBitmap* fDrawPixelBitmap;
	Hyiedefs::TRGB *fDrawPixelPtr;
	int __fastcall DrawHorizontalLine(int Alpha, int xleft, int xright, int y);
	void __fastcall DrawSinglePolygon(int Alpha, Hyiedefs::PPointArray SelPoly, int SelPolyCount);
	void * __fastcall GetScanLine(int Row);
	void __fastcall CheckMemoryAllocation(void);
	System::PByte __fastcall GetBits(void);
	
public:
	__fastcall TIEMask(void);
	__fastcall virtual ~TIEMask(void);
	void __fastcall SetPixel(int x, int y, int Alpha);
	int __fastcall GetPixel(int x, int y);
	void __fastcall SetRectangle(const System::Types::TRect &Rect, int Alpha)/* overload */;
	void __fastcall SetRectangle(int x1, int y1, int x2, int y2, int Alpha)/* overload */;
	void __fastcall SetEllipse(int CenterX, int CenterY, int Width, int Height, int Alpha);
	void __fastcall AllocateBits(int width, int height, int bitsperpixel);
	void __fastcall Resize(int NewWidth, int NewHeight);
	void __fastcall FreeBits(void);
	void __fastcall CopyBitmap(Vcl::Graphics::TBitmap* Dest, Vcl::Graphics::TBitmap* Source, bool dstonlymask, bool srconlymask);
	void __fastcall CopyIEBitmap(TIEBitmap* Dest, TIEBitmap* Source, bool dstonlymask, bool srconlymask, bool UseAlphaChannel);
	void __fastcall CopyIEBitmapAlpha(TIEBitmap* Dest, TIEBitmap* Source, bool dstonlymask, bool srconlymask);
	void __fastcall DrawPolygon(int Alpha, Hyiedefs::PPointArray SelPoly, int SelPolyCount);
	void __fastcall CombineWithAlpha(TIEBitmap* SourceAlpha, int ox, int oy, bool SynchronizeBoundingRect);
	void __fastcall Fill(int Alpha);
	void __fastcall Empty(void);
	bool __fastcall IsPointInside(int x, int y);
	void __fastcall TranslateBitmap(int &ox, int &oy, bool CutSel);
	void __fastcall InvertCanvas(Vcl::Graphics::TCanvas* Dest, int xDst, int yDst, int dxDst, int dyDst, int xMask, int yMask, int dxMask, int dyMask);
	void __fastcall DrawOuter(Vcl::Graphics::TBitmap* Dest, int xDst, int yDst, int dxDst, int dyDst, int xMask, int yMask, int dxMask, int dyMask, int AlphaBlend = 0xffffffff, System::Uitypes::TColor Color = (System::Uitypes::TColor)(0x0));
	void __fastcall DrawOutline(Vcl::Graphics::TCanvas* Dest, int xDst, int yDst, int dxDst, int dyDst, int xMask, int yMask, int dxMask, int dyMask, int AniCounter, System::Uitypes::TColor Color1, System::Uitypes::TColor Color2, System::Types::PRect actualRect = (System::Types::PRect)(0x0));
	void __fastcall Negative(int MaxVal);
	void __fastcall SyncFull(void);
	void __fastcall SyncRect(void);
	void __fastcall Intersect(int x1, int y1, int x2, int y2);
	TIEMask* __fastcall CreateResampledMask(int NewWidth, int NewHeight);
	__property int Width = {read=fWidth, nodefault};
	__property int Height = {read=fHeight, nodefault};
	__property int BitsPerPixel = {read=fBitsperpixel, nodefault};
	__property int X1 = {read=fX1, write=fX1, nodefault};
	__property int Y1 = {read=fY1, write=fY1, nodefault};
	__property int X2 = {read=fX2, write=fX2, nodefault};
	__property int Y2 = {read=fY2, write=fY2, nodefault};
	bool __fastcall IsEmpty(void);
	__property void * ScanLine[int row] = {read=GetScanLine};
	void __fastcall Assign(TIEMask* Source);
	__property __int64 Rowlen = {read=fRowlen};
	__property System::PByte Bits = {read=GetBits};
	__property bool Full = {read=fFull, write=fFull, nodefault};
};


struct DECLSPEC_DRECORD TIEVirtualImageInfo
{
public:
	__int64 pos;
	__int64 vsize;
	void *ptr;
	bool bitmapped;
	int orig_width;
	int orig_height;
	bool HasAlphaChannel;
	TIEDataAccess currentaccess;
	int ImWidth;
	int ImHeight;
	int ImBitCount;
	TIEPixelFormat ImPixelFormat;
};


typedef TIEVirtualImageInfo *PIEVirtualImageInfo;

struct DECLSPEC_DRECORD TIEVirtualToReleaseBmp
{
public:
	TIEVirtualImageInfo *info;
	TIEBitmap* bmp;
	int refcount;
};


typedef TIEVirtualToReleaseBmp *PIEVirtualToReleaseBmp;

struct DECLSPEC_DRECORD TIEVirtualFreeBlock
{
public:
	__int64 pos;
	unsigned vsize;
};


typedef TIEVirtualFreeBlock *PIEVirtualFreeBlock;

class PASCALIMPLEMENTATION TIEVirtualImageList : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	TIEFileBuffer* fmemmap;
	bool fUseDisk;
	__int64 fSize;
	System::Classes::TList* fImageInfo;
	System::Classes::TList* fToDiscardList;
	System::Classes::TList* fFreeBlocks;
	__int64 fInsPos;
	unsigned fAllocationBlock;
	int fMaxImagesInMemory;
	int fImagesInMemory;
	System::Classes::TList* fBmpToRelease;
	unsigned fLastVImageSize;
	System::UnicodeString fDescriptor;
	_RTL_CRITICAL_SECTION fLock;
	int __fastcall GetImageCount(void);
	int __fastcall BmpToReleaseIndexOf(void * image);
	void __fastcall MergeConsecutiveBlocks(void);
	
protected:
	void __fastcall ReAllocateBits(void);
	void __fastcall FreeBits(void);
	void __fastcall RemoveImageInfo(int idx, bool deleteItem);
	void __fastcall DiscardImage(PIEVirtualImageInfo info);
	void __fastcall DiscardOne(void);
	void __fastcall DiscardAll(void);
	void __fastcall MapImage(void * image, TIEDataAccess access);
	bool __fastcall AllocImage(void * image, int Width, int Height, int Bitcount, TIEPixelFormat PixelFormat, bool HasAlpha);
	void __fastcall DirectCopyToBitmap(void * image, TIEBitmap* bitmap);
	void __fastcall CreateEx(void);
	void __fastcall DestroyEx(void);
	
public:
	__fastcall TIEVirtualImageList(const System::UnicodeString Descriptor, bool UseDisk);
	__fastcall virtual ~TIEVirtualImageList(void);
	void __fastcall PrepareSpaceFor(int Width, int Height, int Bitcount, int ImageCount);
	void * __fastcall AddBlankImage(int Width, int Height, int Bitcount, TIEPixelFormat PixelFormat, bool HasAlpha);
	void * __fastcall AddBitmap(Vcl::Graphics::TBitmap* bitmap);
	void * __fastcall AddIEBitmap(TIEBaseBitmap* bitmap);
	void * __fastcall AddBitmapRect(Vcl::Graphics::TBitmap* bitmap, int xsrc, int ysrc, int dxsrc, int dysrc);
	void __fastcall CopyToIEBitmap(void * image, TIEBitmap* bitmap);
	void __fastcall CopyFromIEBitmap(void * image, TIEBitmap* bitmap);
	TIEBitmap* __fastcall GetBitmap(void * image);
	void __fastcall ReleaseBitmap(TIEBitmap* bitmap, bool changed);
	void __fastcall ReleaseBitmapByImage(void * image, bool changed);
	__property int MaxImagesInMemory = {read=fMaxImagesInMemory, write=fMaxImagesInMemory, nodefault};
	__property int ImageCount = {read=GetImageCount, nodefault};
	void __fastcall Delete(void * image);
	int __fastcall GetImageWidth(void * image);
	int __fastcall GetImageHeight(void * image);
	int __fastcall GetImageOriginalWidth(void * image);
	int __fastcall GetImageOriginalHeight(void * image);
	void __fastcall SetImageOriginalWidth(void * image, int Value);
	void __fastcall SetImageOriginalHeight(void * image, int Value);
	int __fastcall GetImageBitCount(void * image);
	void * __fastcall GetImageBits(void * image);
	TIEPixelFormat __fastcall GetImagePixelFormat(void * image);
	void * __fastcall GetImagePalette(void * image);
	void * __fastcall GetAlphaBits(void * image);
	__int64 __fastcall GetImageFilePos(void * image);
	int __fastcall FindImageIndex(void * image);
	void * __fastcall GetImageFromIndex(int index);
	void __fastcall SaveToStream(System::Classes::TStream* Stream);
	bool __fastcall LoadFromStream(System::Classes::TStream* Stream);
};


#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEDibbitmap : public TIEBaseBitmap
{
	typedef TIEBaseBitmap inherited;
	
private:
	unsigned fWidth;
	unsigned fHeight;
	unsigned fBitCount;
	unsigned fRowLen;
	NativeUInt fHDC;
	NativeUInt fDIB;
	Hyiedefs::TBitmapInfoHeader256 fBitmapInfoHeader1;
	void *fBits;
	
protected:
	virtual int __fastcall GetBitCount(void);
	virtual int __fastcall GetWidth(void);
	virtual int __fastcall GetHeight(void);
	virtual void __fastcall SetWidth(int Value);
	virtual void __fastcall SetHeight(int Value);
	virtual TIEPixelFormat __fastcall GetPixelFormat(void);
	virtual int __fastcall GetRowLen(void);
	virtual void * __fastcall GetScanLine(int row);
	virtual Hyiedefs::TRGB __fastcall GetPalette(int index);
	virtual void * __fastcall GetPaletteBuffer(void);
	virtual void __fastcall SetPalette(int index, Hyiedefs::TRGB Value);
	virtual int __fastcall GetPaletteLen(void);
	virtual int __fastcall GetPaletteUsed(void);
	virtual void __fastcall SetPaletteUsed(int Value);
	
public:
	__fastcall TIEDibbitmap(void);
	__fastcall virtual ~TIEDibbitmap(void);
	bool __fastcall AllocateBits(unsigned BmpWidth, unsigned BmpHeight, unsigned BmpBitCount);
	virtual bool __fastcall Allocate(int ImageWidth, int ImageHeight, TIEPixelFormat ImagePixelFormat);
	void __fastcall FreeBits(void);
	__property NativeUInt HDC = {read=fHDC, nodefault};
	__property NativeUInt DIB = {read=fDIB, nodefault};
	__property unsigned Width = {read=fWidth, nodefault};
	__property unsigned Height = {read=fHeight, nodefault};
	__property unsigned BitCount = {read=fBitCount, nodefault};
	__property void * Scanline[int row] = {read=GetScanLine};
	__property void * Bits = {read=fBits};
	__property int Rowlen = {read=GetRowLen, nodefault};
	void __fastcall CopyToTBitmap(Vcl::Graphics::TBitmap* Dest);
	virtual void __fastcall Assign(System::TObject* Source);
	virtual void __fastcall AssignImage(TIEBaseBitmap* Source);
	virtual void __fastcall CopyPaletteTo(TIEBaseBitmap* Dest);
};

#pragma pack(pop)

struct DECLSPEC_DRECORD OIAN_MARK_ATTRIBUTES
{
public:
	int uType;
	System::Types::TRect lrBounds;
	tagRGBQUAD rgbColor1;
	tagRGBQUAD rgbColor2;
	System::LongBool bHighlighting;
	System::LongBool bTransparent;
	unsigned uLineSize;
	unsigned uReserved1;
	unsigned uReserved2;
	tagLOGFONTA lfFont;
	unsigned bReserved3;
	int Time;
	System::LongBool bVisible;
	unsigned dwReserved4;
	System::StaticArray<int, 10> lReserved;
};


#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEImagingObject : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	OIAN_MARK_ATTRIBUTES attrib;
	Hyiedefs::TIEPointArray *points;
	int pointsLen;
	char *text;
	TIEBitmap* image;
	
public:
	__fastcall TIEImagingObject(void);
	__fastcall virtual ~TIEImagingObject(void);
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEImagingAnnot : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::TObject* fParent;
	bool fUserChanged;
	System::Classes::TList* fObjects;
	TIEImagingObject* __fastcall GetObject(int idx);
	int __fastcall GetObjectsCount(void);
	
public:
	__fastcall TIEImagingAnnot(void);
	__fastcall virtual ~TIEImagingAnnot(void);
	void __fastcall LoadFromStandardBuffer(void * buffer, int buflen);
	void __fastcall SaveToStandardBuffer(void * &Buffer, int &BufferLength);
	__property bool UserChanged = {read=fUserChanged, write=fUserChanged, nodefault};
	void __fastcall Clear(void);
	void __fastcall Assign(TIEImagingAnnot* Source);
	void __fastcall SaveToStream(System::Classes::TStream* Stream);
	void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	void __fastcall CopyToTImageEnVect(System::TObject* Target = (System::TObject*)(0x0));
	void __fastcall CopyFromTImageEnVect(System::TObject* Target = (System::TObject*)(0x0));
	void __fastcall DrawToBitmap(TIEBitmap* target, bool Antialias);
	__property TIEImagingObject* Objects[int idx] = {read=GetObject};
	__property int ObjectsCount = {read=GetObjectsCount, nodefault};
	__property System::TObject* Parent = {read=fParent, write=fParent};
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEImageEnAnnot : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::TObject* fParent;
	System::Classes::TMemoryStream* fData;
	
public:
	__fastcall TIEImageEnAnnot(System::TObject* parent);
	__fastcall virtual ~TIEImageEnAnnot(void);
	__classmethod bool __fastcall BufferContainsImageEnAnnot(void * buffer, int buflen);
	__classmethod bool __fastcall TIFFContainsImageEnAnnot(System::Classes::TStream* Stream, int ImageIndex)/* overload */;
	__classmethod bool __fastcall TIFFContainsImageEnAnnot(const System::WideString Filename, int ImageIndex)/* overload */;
	void __fastcall LoadFromBuffer(void * buffer, int buflen);
	void __fastcall SaveToBuffer(void * &Buffer, int &BufferLength);
	void __fastcall Clear(void);
	void __fastcall Assign(TIEImageEnAnnot* Source);
	void __fastcall SaveToStream(System::Classes::TStream* Stream);
	void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	void __fastcall CopyToTImageEnVect(System::TObject* Target = (System::TObject*)(0x0));
	void __fastcall CopyFromTImageEnVect(System::TObject* Target = (System::TObject*)(0x0));
	void __fastcall DrawToBitmap(TIEBitmap* target, bool Antialias);
	bool __fastcall IsEmpty(void);
	__property System::TObject* Parent = {read=fParent};
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEWorkBitmap : public System::TObject
{
	typedef System::TObject inherited;
	
	
private:
	typedef System::DynamicArray<void *> _TIEWorkBitmap__1;
	
	
private:
	int fWidth;
	int fHeight;
	int fBitCount;
	int fRowLen;
	void *fBits;
	int fRowsPerFragment;
	_TIEWorkBitmap__1 fFragments;
	void * __fastcall GetScanline(int row);
	void __fastcall FragmentedAlloc(void);
	void __fastcall FreeFragments(void);
	
public:
	__fastcall TIEWorkBitmap(int BmpWidth, int BmpHeight, int BmpBitCount);
	__fastcall virtual ~TIEWorkBitmap(void);
	void __fastcall AllocateBits(int BmpWidth, int BmpHeight, int BmpBitCount);
	void __fastcall FreeBits(void);
	__property int Width = {read=fWidth, nodefault};
	__property int Height = {read=fHeight, nodefault};
	__property int BitCount = {read=fBitCount, nodefault};
	__property void * Scanline[int row] = {read=GetScanline};
	__property void * Bits = {read=fBits};
	__property int Rowlen = {read=fRowLen, nodefault};
	System::PByte __fastcall GetPByte(int row, int col);
	PWORD __fastcall GetPWord(int row, int col);
	Hyiedefs::PRGB __fastcall GetPRGB(int row, int col);
	System::PDouble __fastcall GetPDouble(int row, int col);
	Winapi::Windows::PSingle __fastcall GetPSingle(int row, int col);
	System::PInteger __fastcall GetPInteger(int row, int col);
	void __fastcall SetBit(int row, int col, int value);
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIETIFTagsReader : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::Classes::TStream* fFileStream;
	System::Classes::TStream* fStream;
	TIETIFFIFDReader* fIFD;
	int fNumi;
	
public:
	__fastcall TIETIFTagsReader(const System::UnicodeString FileName, int ImageIndex);
	__fastcall TIETIFTagsReader(System::Classes::TStream* Stream, int ImageIndex);
	__fastcall TIETIFTagsReader(TIETIFTagsReader* tagReader, int IFDTag);
	__fastcall virtual ~TIETIFTagsReader(void);
	__property int ImageCount = {read=fNumi, nodefault};
	bool __fastcall TagExists(int Tag);
	int __fastcall TagLength(int Tag);
	__int64 __fastcall GetInteger(int Tag);
	int __fastcall GetIntegerIndexed(int Tag, int index);
	double __fastcall GetRational(int Tag, double defaultValue = 0.000000E+00);
	double __fastcall GetRationalIndexed(int Tag, int index, double defVal = 0.000000E+00);
	int __fastcall GetIntegerArray(int Tag, Hyiedefs::pint64array &ar);
	void * __fastcall GetRawData(int Tag);
	System::AnsiString __fastcall GetString(int Tag);
	System::AnsiString __fastcall GetMiniString(int Tag);
public:
	/* TObject.Create */ inline __fastcall TIETIFTagsReader(void) : System::TObject() { }
	
};

#pragma pack(pop)

struct DECLSPEC_DRECORD TIEEXIFMakerNoteDeviceInfo
{
	
private:
	enum DECLSPEC_DENUM _TIEEXIFMakerNoteDeviceInfo__1 : unsigned char { iemnAbsolute, iemnTIFFHeader, iemnEXIFSegment };
	
	enum DECLSPEC_DENUM _TIEEXIFMakerNoteDeviceInfo__2 : unsigned char { iemnNONE, iemnTIFF, iemnIFDOFFSET };
	
	enum DECLSPEC_DENUM _TIEEXIFMakerNoteDeviceInfo__3 : unsigned char { ieboFromEXIF, ieboFromTIFFHeader, ieboLittleEndian, ieboBigEndian };
	
	
public:
	System::AnsiString signature;
	_TIEEXIFMakerNoteDeviceInfo__1 base;
	_TIEEXIFMakerNoteDeviceInfo__2 headerType;
	TTIFFHeader TIFFHeader;
	_TIEEXIFMakerNoteDeviceInfo__3 byteOrder;
};


typedef void __fastcall (__closure *TIETagsHandlerAddTagFunc)(int tagPosition, bool littleEndian, TTIFFTAG &tag);

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIETagsHandler : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	void *fUnparsedData;
	int fUnparsedDataLength;
	TIEEXIFMakerNoteDeviceInfo fEXIFMakerInfo;
	System::Classes::TMemoryStream* fData;
	TIETIFFIFDReader* fIFD;
	void __fastcall SetUnparsedData(void * value);
	TIEEXIFMakerNoteDeviceInfo __fastcall CheckHeader(void * buffer, int bufferLen);
	
public:
	__fastcall TIETagsHandler(void);
	__fastcall virtual ~TIETagsHandler(void);
	__property System::Classes::TMemoryStream* Data = {read=fData};
	void __fastcall Update(void);
	void __fastcall Assign(TIETagsHandler* source);
	void __fastcall Clear(void);
	bool __fastcall TagExists(int Tag);
	int __fastcall TagLength(int Tag);
	int __fastcall GetInteger(int Tag);
	int __fastcall GetIntegerIndexed(int Tag, int index);
	double __fastcall GetRational(int Tag, double defaultValue = 0.000000E+00);
	double __fastcall GetRationalIndexed(int Tag, int index, double defVal = 0.000000E+00);
	int __fastcall GetIntegerArray(int Tag, Hyiedefs::pint64array &ar);
	void * __fastcall GetRawData(int Tag);
	System::AnsiString __fastcall GetString(int Tag);
	System::AnsiString __fastcall GetMiniString(int Tag);
	__property void * UnparsedData = {read=fUnparsedData, write=SetUnparsedData};
	__property int UnparsedDataLength = {read=fUnparsedDataLength, write=fUnparsedDataLength, nodefault};
	void __fastcall ReadFromStream(System::Classes::TStream* stream, int size, bool littleEndian, __int64 exifSegmentPos, TIETagsHandlerAddTagFunc addTagFunc = 0x0);
	int __fastcall WriteToStream(System::Classes::TStream* stream, __int64 exifSegmentPos);
};

#pragma pack(pop)

class PASCALIMPLEMENTATION TIETagsHandlerRelocator : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::Classes::TStream* Stream;
	__int64 Position;
	__int64 Offset;
	bool LittleEndian;
	TIETagsHandler* TagsHandler;
	void __fastcall AddTagFunc(int tagPosition, bool littleEndian, TTIFFTAG &tag);
	
public:
	__fastcall TIETagsHandlerRelocator(System::Classes::TStream* Stream_, __int64 Position_, __int64 Offset_, bool LittleEndian_);
	__fastcall virtual ~TIETagsHandlerRelocator(void);
	void __fastcall Relocate(void);
};


enum DECLSPEC_DENUM TIETagType : unsigned char { ttUnknown, ttByte, ttAscii, ttShort, ttLong, ttRational, ttSByte, ttUndefined, ttSShort, ttSLong, ttSRational, ttFloat, ttDouble, ttLongOffset };

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIETIFFHandler : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	bool fBigEndian;
	System::Word fVersion;
	System::Classes::TList* fPages;
	System::Classes::TList* fBuffers;
	bool __fastcall ReadHeader(System::Classes::TStream* Stream);
	System::Word __fastcall xword(System::Word value);
	unsigned __fastcall xdword(unsigned value);
	int __fastcall GetIntegerByCode(int page, int tagcode, int idx)/* overload */;
	int __fastcall GetIntegerByCode(System::Classes::TList* ifd, int tagcode, int idx)/* overload */;
	void __fastcall SortTags(int pageIndex)/* overload */;
	void __fastcall SortTags(System::Classes::TList* ifd)/* overload */;
	void * __fastcall GetValueRAWEx(int pageIndex, int tagIndex, int arrayIndex, int &tagType)/* overload */;
	void * __fastcall GetValueRAWEx(PTIFFTAG tag, int arrayIndex)/* overload */;
	bool __fastcall GetLittleEndian(void);
	void __fastcall CheckPairTag(int tagCode, int &tgpos, int &tglen)/* overload */;
	bool __fastcall CheckPairTag(int tagCode)/* overload */;
	bool __fastcall CheckIFD(int tagCode);
	bool __fastcall ReadIFD(System::Classes::TStream* Stream, System::Classes::TList* Pages, System::Classes::TList* ifd, int insertPos);
	int __fastcall FindTag(System::Classes::TList* ifd, int tagCode)/* overload */;
	void __fastcall DeleteTag(int pageIndex, int tagIndex, bool checkOffsetTags)/* overload */;
	void __fastcall DeleteTag(System::Classes::TList* ifd, int tagIndex, bool checkOffsetTags)/* overload */;
	void __fastcall WriteIFD(System::Classes::TStream* Stream, System::Classes::TList* ifd, __int64 &dataPos);
	int __fastcall GetInteger(System::Classes::TList* ifd, int tagIndex, int arrayIndex)/* overload */;
	void __fastcall SetValue(System::Classes::TList* ifd, int tagCode, TIETagType tagType, const System::Variant &value)/* overload */;
	void __fastcall SetValueRAW(System::Classes::TList* ifd, int tagCode, TIETagType tagType, int dataNum, void * buffer)/* overload */;
	void __fastcall CopyTag(System::Classes::TList* src_ifd, int srcTagIndex, TIETIFFHandler* source, System::Classes::TList* dst_ifd)/* overload */;
	void __fastcall init(void);
	
public:
	__fastcall TIETIFFHandler(void)/* overload */;
	__fastcall TIETIFFHandler(const System::UnicodeString FileName)/* overload */;
	__fastcall TIETIFFHandler(System::Classes::TStream* Stream)/* overload */;
	__fastcall virtual ~TIETIFFHandler(void);
	bool __fastcall ReadFile(const System::UnicodeString FileName);
	bool __fastcall ReadStream(System::Classes::TStream* Stream);
	bool __fastcall InsertTIFFStream(System::Classes::TStream* Stream, int pageIndex);
	bool __fastcall InsertTIFFFile(const System::UnicodeString FileName, int pageIndex);
	bool __fastcall InsertPageAsFile(const System::UnicodeString FileName, int pageIndex);
	bool __fastcall InsertPageAsStream(System::Classes::TStream* Stream, int pageIndex);
	bool __fastcall InsertPageAsImage(System::TObject* viewer, int pageIndex);
	void __fastcall WriteFile(const System::UnicodeString FileName, int page = 0xffffffff);
	void __fastcall WriteStream(System::Classes::TStream* Stream, int page = 0xffffffff);
	void __fastcall FreeData(void);
	int __fastcall GetTagsCount(int pageIndex);
	int __fastcall GetPagesCount(void);
	int __fastcall GetTagCode(int pageIndex, int tagIndex);
	TIETagType __fastcall GetTagType(int pageIndex, int tagIndex);
	int __fastcall GetTagLength(int pageIndex, int tagIndex);
	int __fastcall GetTagLengthInBytes(int pageIndex, int tagIndex);
	int __fastcall FindTag(int pageIndex, int tagCode)/* overload */;
	void __fastcall DeleteTag(int pageIndex, int tagIndex)/* overload */;
	System::AnsiString __fastcall GetTagDescription(int pageIndex, int tagIndex);
	void __fastcall ChangeTagCode(int pageIndex, int tagIndex, int newCode);
	int __fastcall GetInteger(int pageIndex, int tagIndex, int arrayIndex)/* overload */;
	System::AnsiString __fastcall GetString(int pageIndex, int tagIndex);
	double __fastcall GetFloat(int pageIndex, int tagIndex, int arrayIndex);
	System::Variant __fastcall GetValue(int pageIndex, int tagIndex, int arrayIndex);
	void __fastcall SaveTagToFile(int pageIndex, int tagIndex, const System::UnicodeString fileName);
	void * __fastcall GetValueRAW(int pageIndex, int tagIndex, int arrayIndex);
	void __fastcall SetValue(int pageIndex, int tagCode, TIETagType tagType, const System::Variant &value)/* overload */;
	void __fastcall SetValueRAW(int pageIndex, int tagCode, TIETagType tagType, int dataNum, void * buffer)/* overload */;
	void __fastcall CopyTag(int srcPageIndex, int srcTagIndex, TIETIFFHandler* source, int dstPageIndex)/* overload */;
	void __fastcall DeletePage(int pageIndex);
	void __fastcall ExchangePage(int Index1, int Index2);
	void __fastcall MovePage(int CurIndex, int NewIndex);
	int __fastcall InsertPage(int pageIndex = 0xffffffff)/* overload */;
	int __fastcall InsertPage(int pageIndex, TIETIFFHandler* sourceHandler, int sourcePage)/* overload */;
	__property bool LittleEndian = {read=GetLittleEndian, nodefault};
	__property System::Word Version = {read=fVersion, write=fVersion, nodefault};
};

#pragma pack(pop)

class PASCALIMPLEMENTATION TIEGraphicBase : public Vcl::Graphics::TGraphic
{
	typedef Vcl::Graphics::TGraphic inherited;
	
private:
	System::TObject* fio;
	TIEBitmap* bmp;
	int fFiletype;
	Hyiedefs::TResampleFilter fResampleFilter;
	
protected:
	virtual void __fastcall Draw(Vcl::Graphics::TCanvas* ACanvas, const System::Types::TRect &Rect);
	virtual bool __fastcall GetEmpty(void);
	virtual int __fastcall GetHeight(void);
	virtual int __fastcall GetWidth(void);
	virtual void __fastcall SetHeight(int Value);
	virtual void __fastcall SetWidth(int Value);
	virtual void __fastcall WriteData(System::Classes::TStream* Stream);
	virtual void __fastcall ReadData(System::Classes::TStream* Stream);
	
public:
	__fastcall virtual TIEGraphicBase(void);
	__fastcall virtual ~TIEGraphicBase(void);
	virtual void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(System::Classes::TStream* Stream);
	virtual void __fastcall LoadFromClipboardFormat(System::Word AFormat, NativeUInt AData, HPALETTE APalette);
	virtual void __fastcall SaveToClipboardFormat(System::Word &AFormat, NativeUInt &AData, HPALETTE &APalette);
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	__property System::TObject* IO = {read=fio};
	__property Hyiedefs::TResampleFilter ResampleFilter = {read=fResampleFilter, write=fResampleFilter, nodefault};
	__property TIEBitmap* IEBitmap = {read=bmp};
	virtual void __fastcall AssignTo(System::Classes::TPersistent* Dest);
};


class PASCALIMPLEMENTATION TIEBufferedReadStream : public System::Classes::TStream
{
	typedef System::Classes::TStream inherited;
	
private:
	System::Classes::TStream* fStream;
	int fBufferSize;
	System::Sysutils::TByteArray *fMemory;
	__int64 fPosition;
	int fPositionBuf;
	__int64 fSize;
	__int64 fRelativePosition;
	bool fOverPosition;
	void __fastcall AllocBufferSize(int BufferSize);
	void __fastcall LoadData(void);
	
public:
	__fastcall TIEBufferedReadStream(System::Classes::TStream* InputStream, int BufferSize, bool UseRelativePosition);
	__fastcall virtual ~TIEBufferedReadStream(void);
	virtual int __fastcall Read(void *Buffer, int Count)/* overload */;
	virtual int __fastcall Write(const void *Buffer, int Count)/* overload */;
	virtual __int64 __fastcall Seek(const __int64 Offset, System::Classes::TSeekOrigin Origin)/* overload */;
	__property bool OverPosition = {read=fOverPosition, nodefault};
	/* Hoisted overloads: */
	
public:
	inline int __fastcall  Read(System::DynamicArray<System::Byte> Buffer, int Offset, int Count){ return System::Classes::TStream::Read(Buffer, Offset, Count); }
	inline int __fastcall  Read(System::DynamicArray<System::Byte> &Buffer, int Count){ return System::Classes::TStream::Read(Buffer, Count); }
	inline int __fastcall  Write(const System::DynamicArray<System::Byte> Buffer, int Offset, int Count){ return System::Classes::TStream::Write(Buffer, Offset, Count); }
	inline int __fastcall  Write(const System::DynamicArray<System::Byte> Buffer, int Count){ return System::Classes::TStream::Write(Buffer, Count); }
	inline int __fastcall  Seek(int Offset, System::Word Origin){ return System::Classes::TStream::Seek(Offset, Origin); }
	inline __int64 __fastcall  Seek _DEPRECATED_ATTRIBUTE0 (const __int64 Offset, System::Word Origin){ return System::Classes::TStream::Seek(Offset, Origin); }
	
};


#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEBufferedWriteStream : public System::Classes::TStream
{
	typedef System::Classes::TStream inherited;
	
private:
	System::Classes::TStream* fStream;
	System::Sysutils::TByteArray *fMemory;
	int fBufferSize;
	int fBufferPos;
	void __fastcall FlushData(void);
	
public:
	__fastcall TIEBufferedWriteStream(System::Classes::TStream* InputStream, int BufferSize);
	__fastcall virtual ~TIEBufferedWriteStream(void);
	virtual int __fastcall Read(void *Buffer, int Count)/* overload */;
	virtual int __fastcall Write(const void *Buffer, int Count)/* overload */;
	virtual __int64 __fastcall Seek(const __int64 Offset, System::Classes::TSeekOrigin Origin)/* overload */;
	/* Hoisted overloads: */
	
public:
	inline int __fastcall  Read(System::DynamicArray<System::Byte> Buffer, int Offset, int Count){ return System::Classes::TStream::Read(Buffer, Offset, Count); }
	inline int __fastcall  Read(System::DynamicArray<System::Byte> &Buffer, int Count){ return System::Classes::TStream::Read(Buffer, Count); }
	inline int __fastcall  Write(const System::DynamicArray<System::Byte> Buffer, int Offset, int Count){ return System::Classes::TStream::Write(Buffer, Offset, Count); }
	inline int __fastcall  Write(const System::DynamicArray<System::Byte> Buffer, int Count){ return System::Classes::TStream::Write(Buffer, Count); }
	inline int __fastcall  Seek(int Offset, System::Word Origin){ return System::Classes::TStream::Seek(Offset, Origin); }
	inline __int64 __fastcall  Seek _DEPRECATED_ATTRIBUTE0 (const __int64 Offset, System::Word Origin){ return System::Classes::TStream::Seek(Offset, Origin); }
	
};

#pragma pack(pop)

class PASCALIMPLEMENTATION TIETIFFImage : public TIEGraphicBase
{
	typedef TIEGraphicBase inherited;
	
public:
	/* TIEGraphicBase.Create */ inline __fastcall virtual TIETIFFImage(void) : TIEGraphicBase() { }
	/* TIEGraphicBase.Destroy */ inline __fastcall virtual ~TIETIFFImage(void) { }
	
};


class PASCALIMPLEMENTATION TIEGIFImage : public TIEGraphicBase
{
	typedef TIEGraphicBase inherited;
	
public:
	/* TIEGraphicBase.Create */ inline __fastcall virtual TIEGIFImage(void) : TIEGraphicBase() { }
	/* TIEGraphicBase.Destroy */ inline __fastcall virtual ~TIEGIFImage(void) { }
	
};


class PASCALIMPLEMENTATION TIEJpegImage : public TIEGraphicBase
{
	typedef TIEGraphicBase inherited;
	
public:
	/* TIEGraphicBase.Create */ inline __fastcall virtual TIEJpegImage(void) : TIEGraphicBase() { }
	/* TIEGraphicBase.Destroy */ inline __fastcall virtual ~TIEJpegImage(void) { }
	
};


class PASCALIMPLEMENTATION TIEPCXImage : public TIEGraphicBase
{
	typedef TIEGraphicBase inherited;
	
public:
	/* TIEGraphicBase.Create */ inline __fastcall virtual TIEPCXImage(void) : TIEGraphicBase() { }
	/* TIEGraphicBase.Destroy */ inline __fastcall virtual ~TIEPCXImage(void) { }
	
};


class PASCALIMPLEMENTATION TIEBMPImage : public TIEGraphicBase
{
	typedef TIEGraphicBase inherited;
	
public:
	/* TIEGraphicBase.Create */ inline __fastcall virtual TIEBMPImage(void) : TIEGraphicBase() { }
	/* TIEGraphicBase.Destroy */ inline __fastcall virtual ~TIEBMPImage(void) { }
	
};


class PASCALIMPLEMENTATION TIEICOImage : public TIEGraphicBase
{
	typedef TIEGraphicBase inherited;
	
public:
	/* TIEGraphicBase.Create */ inline __fastcall virtual TIEICOImage(void) : TIEGraphicBase() { }
	/* TIEGraphicBase.Destroy */ inline __fastcall virtual ~TIEICOImage(void) { }
	
};


class PASCALIMPLEMENTATION TIEPNGImage : public TIEGraphicBase
{
	typedef TIEGraphicBase inherited;
	
public:
	/* TIEGraphicBase.Create */ inline __fastcall virtual TIEPNGImage(void) : TIEGraphicBase() { }
	/* TIEGraphicBase.Destroy */ inline __fastcall virtual ~TIEPNGImage(void) { }
	
};


class PASCALIMPLEMENTATION TIETGAImage : public TIEGraphicBase
{
	typedef TIEGraphicBase inherited;
	
public:
	/* TIEGraphicBase.Create */ inline __fastcall virtual TIETGAImage(void) : TIEGraphicBase() { }
	/* TIEGraphicBase.Destroy */ inline __fastcall virtual ~TIETGAImage(void) { }
	
};


class PASCALIMPLEMENTATION TIEPXMImage : public TIEGraphicBase
{
	typedef TIEGraphicBase inherited;
	
public:
	/* TIEGraphicBase.Create */ inline __fastcall virtual TIEPXMImage(void) : TIEGraphicBase() { }
	/* TIEGraphicBase.Destroy */ inline __fastcall virtual ~TIEPXMImage(void) { }
	
};


class PASCALIMPLEMENTATION TIEJP2Image : public TIEGraphicBase
{
	typedef TIEGraphicBase inherited;
	
public:
	/* TIEGraphicBase.Create */ inline __fastcall virtual TIEJP2Image(void) : TIEGraphicBase() { }
	/* TIEGraphicBase.Destroy */ inline __fastcall virtual ~TIEJP2Image(void) { }
	
};


class PASCALIMPLEMENTATION TIEJ2KImage : public TIEGraphicBase
{
	typedef TIEGraphicBase inherited;
	
public:
	/* TIEGraphicBase.Create */ inline __fastcall virtual TIEJ2KImage(void) : TIEGraphicBase() { }
	/* TIEGraphicBase.Destroy */ inline __fastcall virtual ~TIEJ2KImage(void) { }
	
};


class PASCALIMPLEMENTATION TIEPSDImage : public TIEGraphicBase
{
	typedef TIEGraphicBase inherited;
	
public:
	/* TIEGraphicBase.Create */ inline __fastcall virtual TIEPSDImage(void) : TIEGraphicBase() { }
	/* TIEGraphicBase.Destroy */ inline __fastcall virtual ~TIEPSDImage(void) { }
	
};


enum DECLSPEC_DENUM TIEShadowType : unsigned char { iestNone, iestSolid, iestSmooth1, iestSmooth2 };

typedef void __fastcall (__closure *TIEMultiCallBack)(TIEBitmap* Bitmap, System::TObject* &IOParams, int ImDpiX, int ImDpiY);

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEPDFObject : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	int Index;
	int Position;
	bool DontFree;
	__fastcall TIEPDFObject(void);
	__fastcall virtual ~TIEPDFObject(void);
	virtual void __fastcall Write(System::Classes::TStream* Stream) = 0 ;
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEPDFRefObject : public TIEPDFObject
{
	typedef TIEPDFObject inherited;
	
public:
	int ObjectNumber;
	int GenerationNumber;
	__fastcall TIEPDFRefObject(int ObjNumber, int GenNumber);
	virtual void __fastcall Write(System::Classes::TStream* Stream);
public:
	/* TIEPDFObject.Destroy */ inline __fastcall virtual ~TIEPDFRefObject(void) { }
	
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEPDFBooleanObject : public TIEPDFObject
{
	typedef TIEPDFObject inherited;
	
public:
	bool Value;
	__fastcall TIEPDFBooleanObject(bool vv);
	virtual void __fastcall Write(System::Classes::TStream* Stream);
public:
	/* TIEPDFObject.Destroy */ inline __fastcall virtual ~TIEPDFBooleanObject(void) { }
	
};

#pragma pack(pop)

class PASCALIMPLEMENTATION TIEPDFNumericObject : public TIEPDFObject
{
	typedef TIEPDFObject inherited;
	
public:
	double Value;
	__fastcall TIEPDFNumericObject(double vv);
	virtual void __fastcall Write(System::Classes::TStream* Stream);
public:
	/* TIEPDFObject.Destroy */ inline __fastcall virtual ~TIEPDFNumericObject(void) { }
	
};


#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEPDFStringObject : public TIEPDFObject
{
	typedef TIEPDFObject inherited;
	
public:
	System::AnsiString Value;
	__fastcall TIEPDFStringObject(System::AnsiString vv);
	virtual void __fastcall Write(System::Classes::TStream* Stream);
public:
	/* TIEPDFObject.Destroy */ inline __fastcall virtual ~TIEPDFStringObject(void) { }
	
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEPDFNameObject : public TIEPDFObject
{
	typedef TIEPDFObject inherited;
	
public:
	System::AnsiString Value;
	__fastcall TIEPDFNameObject(System::AnsiString vv);
	virtual void __fastcall Write(System::Classes::TStream* Stream);
public:
	/* TIEPDFObject.Destroy */ inline __fastcall virtual ~TIEPDFNameObject(void) { }
	
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEPDFArrayObject : public TIEPDFObject
{
	typedef TIEPDFObject inherited;
	
public:
	System::Classes::TList* Items;
	__fastcall TIEPDFArrayObject(void);
	__fastcall virtual ~TIEPDFArrayObject(void);
	virtual void __fastcall Write(System::Classes::TStream* Stream);
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEPDFDictionaryObject : public TIEPDFObject
{
	typedef TIEPDFObject inherited;
	
public:
	System::Classes::TStringList* items;
	__fastcall TIEPDFDictionaryObject(void);
	__fastcall virtual ~TIEPDFDictionaryObject(void);
	virtual void __fastcall Write(System::Classes::TStream* Stream);
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEPDFStreamObject : public TIEPDFObject
{
	typedef TIEPDFObject inherited;
	
public:
	void *data;
	int length;
	TIEPDFDictionaryObject* dict;
	TIETemporaryFileStream* cache;
	__fastcall TIEPDFStreamObject(void);
	__fastcall TIEPDFStreamObject(void * copydata, int copylength);
	__fastcall virtual ~TIEPDFStreamObject(void);
	virtual void __fastcall Write(System::Classes::TStream* Stream);
	void __fastcall FlushToCache(void);
};

#pragma pack(pop)

enum DECLSPEC_DENUM TIEDicomTagSource : unsigned char { dsStandard, dsDeprecated, dsProprietary };

enum DECLSPEC_DENUM TIEDicomTagType : unsigned char { dvAE, dvAS, dvAT, dvCS, dvDA, dvDS, dvDT, dvFD, dvFL, dvIS, dvLO, dvLT, dvOB, dvOF, dvOW, dvPN, dvSH, dvSL, dvSQ, dvSS, dvST, dvTM, dvUI, dvUL, dvUN, dvUR, dvUS, dvUT, dvUSorSS, dvUnknown };

struct DECLSPEC_DRECORD TIEDicomTag
{
public:
	System::Word Group;
	System::Word Element;
	TIEDicomTagType DataType;
	void *Data;
	int DataLen;
	System::Contnrs::TObjectList* Children;
};


typedef TIEDicomTag *PIEDicomTag;

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEDicomTags : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::Classes::TList* fTags;
	int __fastcall GetCount(void);
	void __fastcall FreeTag(int Index);
	int __fastcall SetTag(PIEDicomTag Tag, bool DeleteIfExist);
	
public:
	__fastcall TIEDicomTags(void);
	__fastcall virtual ~TIEDicomTags(void);
	void __fastcall Clear(void);
	void __fastcall SaveToStream(System::Classes::TStream* Stream);
	void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	void __fastcall Assign(TIEDicomTags* Source);
	int __fastcall AddTag(System::Word Group, System::Word Element, TIEDicomTagType DataType, void * Data, int DataLen, System::Contnrs::TObjectList* Children = (System::Contnrs::TObjectList*)(0x0));
	int __fastcall IndexOf(System::Word Group, System::Word Element);
	PIEDicomTag __fastcall GetTag(int Index)/* overload */;
	PIEDicomTag __fastcall GetTag(System::Word Group, System::Word Element)/* overload */;
	System::AnsiString __fastcall GetTagString(int Index)/* overload */;
	System::AnsiString __fastcall GetTagString(System::Word Group, System::Word Element)/* overload */;
	double __fastcall GetTagNumeric(int Index, double Default = 0.000000E+00)/* overload */;
	double __fastcall GetTagNumeric(System::Word Group, System::Word Element, double Default = 0.000000E+00)/* overload */;
	System::Contnrs::TObjectList* __fastcall GetTagChildren(System::Word Group, System::Word Element)/* overload */;
	System::Contnrs::TObjectList* __fastcall GetTagChildren(int Index)/* overload */;
	System::UnicodeString __fastcall GetTagDescription(int Index)/* overload */;
	System::UnicodeString __fastcall GetTagDescription(int Index, /* out */ TIEDicomTagSource &TagSource)/* overload */;
	__classmethod System::UnicodeString __fastcall GetTagDescription(System::Word Group, System::Word Element)/* overload */;
	__classmethod System::UnicodeString __fastcall GetTagDescription(System::Word Group, System::Word Element, /* out */ TIEDicomTagSource &TagSource)/* overload */;
	void __fastcall SetTagNumeric(System::Word Group, System::Word Element, double Value);
	void __fastcall SetTagString(System::Word Group, System::Word Element, System::AnsiString Value);
	void __fastcall SetTagByteBuffer(System::Word Group, System::Word Element, System::PByte Buffer, int Length);
	void __fastcall DeleteTag(int Index)/* overload */;
	void __fastcall DeleteTag(System::Word Group, System::Word Element, bool DeleteAllInstances = false)/* overload */;
	void __fastcall DeleteGroup(System::Word Group);
	TIEDicomTags* __fastcall FindNestedTag(System::Word Group, System::Word Element, /* out */ int &Index, TIEDicomTags* StartFrom = (TIEDicomTags*)(0x0));
	__property int Count = {read=GetCount, nodefault};
};

#pragma pack(pop)

typedef System::StaticArray<char, 2> TDicomStr;

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEWideStrings : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	System::WideString operator[](int idx) { return Strings[idx]; }
	
private:
	System::Classes::TList* fStrings;
	System::WideChar * __fastcall CreateCopyBuffer(const System::WideString S);
	int __fastcall GetCount(void);
	System::WideString __fastcall GetString(int idx);
	void __fastcall SetString(int idx, const System::WideString S);
	
public:
	__fastcall TIEWideStrings(void);
	__fastcall virtual ~TIEWideStrings(void);
	void __fastcall Clear(void);
	__property int Count = {read=GetCount, nodefault};
	int __fastcall Add(const System::WideString S);
	__property System::WideString Strings[int idx] = {read=GetString, write=SetString/*, default*/};
};

#pragma pack(pop)

class PASCALIMPLEMENTATION TIEDirContent : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	bool fFirstGot;
	NativeUInt fHandle;
	_WIN32_FIND_DATAW fFindData;
	bool fIsDir;
	bool fIsHidden;
	__int64 fFileSizeBytes;
	System::TDateTime fCreateDate;
	System::TDateTime fEditDate;
	
public:
	__fastcall TIEDirContent(const System::WideString dir);
	__fastcall virtual ~TIEDirContent(void);
	bool __fastcall GetItem(/* out */ System::WideString &sFilename, bool bGetFiles = true, bool bGetDirs = false, bool bGetHidden = true);
	__property bool IsFolder = {read=fIsDir, nodefault};
	__property bool IsHiddenFile = {read=fIsHidden, nodefault};
	__property __int64 FileSizeBytes = {read=fFileSizeBytes};
	__property System::TDateTime CreateDate = {read=fCreateDate};
	__property System::TDateTime EditDate = {read=fEditDate};
};


#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEThreadPool : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	System::Classes::TThread* operator[](int idx) { return Threads[idx]; }
	
private:
	System::Classes::TList* fThreads;
	System::Classes::TThread* __fastcall GetThreads(int idx);
	
public:
	__fastcall TIEThreadPool(void);
	__fastcall virtual ~TIEThreadPool(void);
	void __fastcall Add(System::Classes::TThread* Thread);
	void __fastcall Join(void);
	void __fastcall WaitFor(void);
	__property System::Classes::TThread* Threads[int idx] = {read=GetThreads/*, default*/};
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEResourceBookmark : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	int m_TypeIndex;
	int m_NameIndex;
	int m_FrameIndex;
	
public:
	__property int TypeIndex = {read=m_TypeIndex, nodefault};
	__property int NameIndex = {read=m_NameIndex, nodefault};
	__property int FrameIndex = {read=m_FrameIndex, nodefault};
	__fastcall TIEResourceBookmark(int TypeIndex_, int NameIndex_, int FrameIndex_);
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TIEResourceBookmark(void) { }
	
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEResourceExtractor : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	NativeUInt m_hlib;
	System::Classes::TStringList* m_typesList;
	System::Classes::TList* m_resourceBookmarks;
	int __fastcall GetTypesCount(void);
	int __fastcall GetNamesCount(int TypeIndex);
	System::AnsiString __fastcall GetTypes(int TypeIndex);
	System::AnsiString __fastcall GetNames(int TypeIndex, int NameIndex);
	System::AnsiString __fastcall GetFriendlyTypes(int TypeIndex);
	bool __fastcall GetIsValid(void);
	int __fastcall GetGroupCountFrames(int TypeIndex, int NameIndex);
	int __fastcall GetGroupFrameWidth(int TypeIndex, int NameIndex, int FrameIndex);
	int __fastcall GetGroupFrameHeight(int TypeIndex, int NameIndex, int FrameIndex);
	int __fastcall GetGroupFrameDepth(int TypeIndex, int NameIndex, int FrameIndex);
	System::AnsiString __fastcall GetGroupFrameName(int TypeIndex, int NameIndex, int FrameIndex);
	bool __fastcall GetIsGroup(int TypeIndex);
	bool __fastcall GetIsGrouped(int TypeIndex);
	
public:
	__fastcall TIEResourceExtractor(const System::WideString Filename);
	__fastcall virtual ~TIEResourceExtractor(void);
	__property int TypesCount = {read=GetTypesCount, nodefault};
	__property System::AnsiString Types[int TypeIndex] = {read=GetTypes};
	__property System::AnsiString FriendlyTypes[int TypeIndex] = {read=GetFriendlyTypes};
	__property int NamesCount[int TypeIndex] = {read=GetNamesCount};
	__property System::AnsiString Names[int TypeIndex][int NameIndex] = {read=GetNames};
	void * __fastcall GetBuffer(int TypeIndex, int NameIndex, int &BufferLength)/* overload */;
	void * __fastcall GetBuffer(const System::AnsiString TypeStr, const System::AnsiString NameStr, int &BufferLength)/* overload */;
	void * __fastcall GetBuffer(TIEResourceBookmark* ResourceBookmark, int &BufferLength)/* overload */;
	__property bool IsValid = {read=GetIsValid, nodefault};
	__property bool IsGroup[int TypeIndex] = {read=GetIsGroup};
	__property bool IsGrouped[int TypeIndex] = {read=GetIsGrouped};
	__property int GroupCountFrames[int TypeIndex][int NameIndex] = {read=GetGroupCountFrames};
	__property int GroupFrameWidth[int TypeIndex][int NameIndex][int FrameIndex] = {read=GetGroupFrameWidth};
	__property int GroupFrameHeight[int TypeIndex][int NameIndex][int FrameIndex] = {read=GetGroupFrameHeight};
	__property int GroupFrameDepth[int TypeIndex][int NameIndex][int FrameIndex] = {read=GetGroupFrameDepth};
	__property System::AnsiString GroupFrameName[int TypeIndex][int NameIndex][int FrameIndex] = {read=GetGroupFrameName};
	void __fastcall GetGroupAndFrame(int TypeIndex, int NameIndex, int &GroupTypeIndex, int &GroupIndex, int &GroupFrameIndex);
	int __fastcall IndexOfType(System::AnsiString TypeName);
	void * __fastcall GetFrameBuffer(int TypeIndex, int NameIndex, int FrameIndex, int &BufferLength);
	TIEResourceBookmark* __fastcall GetResourceBookmark(int TypeIndex, int NameIndex, int FrameIndex = 0xffffffff);
};

#pragma pack(pop)

typedef void __fastcall (__closure *TIERFBClipboardTextEvent)(System::TObject* Sender, System::AnsiString Text);

typedef void __fastcall (__closure *TIERFBUpdateRectEvent)(System::TObject* Sender, const System::Types::TRect &Rect);

#pragma pack(push,4)
class PASCALIMPLEMENTATION EIERFBError : public System::Sysutils::Exception
{
	typedef System::Sysutils::Exception inherited;
	
public:
	/* Exception.Create */ inline __fastcall EIERFBError(const System::UnicodeString Msg) : System::Sysutils::Exception(Msg) { }
	/* Exception.CreateFmt */ inline __fastcall EIERFBError(const System::UnicodeString Msg, System::TVarRec const *Args, const int Args_High) : System::Sysutils::Exception(Msg, Args, Args_High) { }
	/* Exception.CreateRes */ inline __fastcall EIERFBError(NativeUInt Ident)/* overload */ : System::Sysutils::Exception(Ident) { }
	/* Exception.CreateRes */ inline __fastcall EIERFBError(System::PResStringRec ResStringRec)/* overload */ : System::Sysutils::Exception(ResStringRec) { }
	/* Exception.CreateResFmt */ inline __fastcall EIERFBError(NativeUInt Ident, System::TVarRec const *Args, const int Args_High)/* overload */ : System::Sysutils::Exception(Ident, Args, Args_High) { }
	/* Exception.CreateResFmt */ inline __fastcall EIERFBError(System::PResStringRec ResStringRec, System::TVarRec const *Args, const int Args_High)/* overload */ : System::Sysutils::Exception(ResStringRec, Args, Args_High) { }
	/* Exception.CreateHelp */ inline __fastcall EIERFBError(const System::UnicodeString Msg, int AHelpContext) : System::Sysutils::Exception(Msg, AHelpContext) { }
	/* Exception.CreateFmtHelp */ inline __fastcall EIERFBError(const System::UnicodeString Msg, System::TVarRec const *Args, const int Args_High, int AHelpContext) : System::Sysutils::Exception(Msg, Args, Args_High, AHelpContext) { }
	/* Exception.CreateResHelp */ inline __fastcall EIERFBError(NativeUInt Ident, int AHelpContext)/* overload */ : System::Sysutils::Exception(Ident, AHelpContext) { }
	/* Exception.CreateResHelp */ inline __fastcall EIERFBError(System::PResStringRec ResStringRec, int AHelpContext)/* overload */ : System::Sysutils::Exception(ResStringRec, AHelpContext) { }
	/* Exception.CreateResFmtHelp */ inline __fastcall EIERFBError(System::PResStringRec ResStringRec, System::TVarRec const *Args, const int Args_High, int AHelpContext)/* overload */ : System::Sysutils::Exception(ResStringRec, Args, Args_High, AHelpContext) { }
	/* Exception.CreateResFmtHelp */ inline __fastcall EIERFBError(NativeUInt Ident, System::TVarRec const *Args, const int Args_High, int AHelpContext)/* overload */ : System::Sysutils::Exception(Ident, Args, Args_High, AHelpContext) { }
	/* Exception.Destroy */ inline __fastcall virtual ~EIERFBError(void) { }
	
};

#pragma pack(pop)

class PASCALIMPLEMENTATION TIERFBMessageThread : public System::Classes::TThread
{
	typedef System::Classes::TThread inherited;
	
private:
	TIERFBClient* m_client;
	System::AnsiString m_clipboardText;
	System::Types::TRect m_updatedRect;
	void __fastcall CopyRawRow(System::PByte &src, System::PByte dst, int columns);
	void __fastcall msg_FrameBufferUpdate(void);
	void __fastcall msg_SetColourMapEntries(void);
	void __fastcall msg_Bell(void);
	void __fastcall msg_ServerCutText(void);
	void __fastcall DoOnUpdate(void);
	void __fastcall DoOnUpdateNonSync(void);
	void __fastcall DoOnUpdateRect(void);
	void __fastcall DoOnBell(void);
	void __fastcall DoOnClipboardText(void);
	void __fastcall DoOnUpdateScreenSize(void);
	void __fastcall UpdateCursorShape(void);
	
public:
	__fastcall TIERFBMessageThread(TIERFBClient* Client);
	__fastcall virtual ~TIERFBMessageThread(void);
	virtual void __fastcall Execute(void);
};


enum DECLSPEC_DENUM TIERFBPixelFormat : unsigned char { ierfbPalette256, ierfbRGB16, ierfbRGB32 };

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEClientSocket : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	void *m_socket;
	bool m_littleEndian;
	bool __fastcall GetConnected(void);
	
public:
	__fastcall TIEClientSocket(void);
	__fastcall virtual ~TIEClientSocket(void);
	__property bool LittleEndian = {read=m_littleEndian, write=m_littleEndian, nodefault};
	void __fastcall ReceiveBuffer(void * buf, int len);
	void __fastcall ReceivePad(int len);
	System::Byte __fastcall ReceiveByte(void);
	System::Word __fastcall ReceiveWord(void);
	unsigned __fastcall ReceiveDWord(void);
	void __fastcall SendBuffer(void * buf, int len);
	void __fastcall SendPad(int len);
	void __fastcall SendByte(System::Byte value);
	void __fastcall SendWord(System::Word value);
	void __fastcall SendDWord(unsigned value);
	void __fastcall Connect(const System::UnicodeString Address, System::Word Port);
	void __fastcall Disconnect(void);
	__property bool Connected = {read=GetConnected, nodefault};
};

#pragma pack(pop)

class PASCALIMPLEMENTATION TIERFBClient : public System::TObject
{
	typedef System::TObject inherited;
	
	
private:
	typedef System::DynamicArray<Hyiedefs::TRGB48> _TIERFBClient__1;
	
	
private:
	TIEClientSocket* m_socket;
	System::Types::TSize m_frameBufferSize;
	System::Byte m_bitsPerPixel;
	System::Byte m_depth;
	System::Byte m_bigEndianFlag;
	System::Byte m_trueColorFlag;
	System::Word m_redMax;
	System::Word m_greenMax;
	System::Word m_blueMax;
	System::Byte m_redShift;
	System::Byte m_greenShift;
	System::Byte m_blueShift;
	System::AnsiString m_name;
	TIEBitmap* m_frameBuffer;
	bool m_freeFrameBuffer;
	TIERFBUpdateRectEvent m_OnUpdateRect;
	System::Classes::TNotifyEvent m_OnUpdate;
	System::Classes::TNotifyEvent m_OnUpdateNonSync;
	System::Classes::TNotifyEvent m_OnBell;
	TIERFBClipboardTextEvent m_OnClipboardText;
	System::Classes::TNotifyEvent m_OnCursorShapeUpdated;
	System::Classes::TNotifyEvent m_OnUpdateScreenSize;
	TIERFBMessageThread* m_msgThread;
	_TIERFBClient__1 m_colorMap;
	TIERFBPixelFormat m_pixelFormat;
	TIEBitmap* m_cursor;
	System::Types::TPoint m_cursorPos;
	System::Types::TPoint m_cursorHotSpot;
	TIEBitmap* m_savedCursorArea;
	System::Types::TPoint m_savedCursorPos;
	_RTL_CRITICAL_SECTION m_frameBufferLock;
	_RTL_CRITICAL_SECTION m_socketSendLock;
	bool m_suspended;
	void __fastcall SendSetPixelFormat(TIERFBPixelFormat pixelFormat);
	bool __fastcall GetConnected(void);
	void __fastcall PaintCursor(void);
	void __fastcall RemoveCursor(void);
	void __fastcall SetSuspended(bool value);
	
public:
	__fastcall TIERFBClient(TIEBitmap* FrameBuffer);
	__fastcall virtual ~TIERFBClient(void);
	void __fastcall Connect(const System::UnicodeString Address, System::Word Port = (System::Word)(0x170c), const System::AnsiString Password = System::AnsiString());
	void __fastcall Disconnect(void);
	__property bool Connected = {read=GetConnected, nodefault};
	__property bool Suspended = {read=m_suspended, write=SetSuspended, nodefault};
	__property System::Types::TSize ScreenSize = {read=m_frameBufferSize};
	__property System::AnsiString ScreenName = {read=m_name};
	__property TIERFBPixelFormat ScreenPixelFormat = {read=m_pixelFormat, write=m_pixelFormat, default=2};
	void __fastcall SendRequestUpdate(System::Word x, System::Word y, System::Word width, System::Word height, bool incremental)/* overload */;
	void __fastcall SendRequestUpdate(bool incremental = true)/* overload */;
	void __fastcall SendPointerEvent(int x, int y, bool LeftButton, bool MiddleButton, bool RightButton);
	void __fastcall SendKeyEvent(unsigned xkey, bool down)/* overload */;
	void __fastcall SendKeyEvent(unsigned VirtualKey, unsigned KeyData, bool down)/* overload */;
	void __fastcall SendClipboard(const System::AnsiString Text);
	void __fastcall LockFrameBuffer(void);
	void __fastcall UnlockFrameBuffer(void);
	__property TIEBitmap* FrameBuffer = {read=m_frameBuffer};
	__property TIEBitmap* Cursor = {read=m_cursor};
	__property TIERFBUpdateRectEvent OnUpdateRect = {read=m_OnUpdateRect, write=m_OnUpdateRect};
	__property System::Classes::TNotifyEvent OnUpdate = {read=m_OnUpdate, write=m_OnUpdate};
	__property System::Classes::TNotifyEvent OnUpdateNonSync = {read=m_OnUpdateNonSync, write=m_OnUpdateNonSync};
	__property System::Classes::TNotifyEvent OnBell = {read=m_OnBell, write=m_OnBell};
	__property TIERFBClipboardTextEvent OnClipboardText = {read=m_OnClipboardText, write=m_OnClipboardText};
	__property System::Classes::TNotifyEvent OnCursorShapeUpdated = {read=m_OnCursorShapeUpdated, write=m_OnCursorShapeUpdated};
	__property System::Classes::TNotifyEvent OnUpdateScreenSize = {read=m_OnUpdateScreenSize, write=m_OnUpdateScreenSize};
};


enum DECLSPEC_DENUM TIE3DESMode : unsigned char { ie3desENCRYPT, ie3desDECRYPT };

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIE3DES : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::StaticArray<unsigned, 32> KnL;
	void __fastcall scrunch(System::PByte outof, unsigned* into);
	void __fastcall unscrun(unsigned* outof, System::PByte into);
	void __fastcall desfunc(Hyiedefs::PDWordArray block, unsigned* keys);
	void __fastcall cookey(unsigned* raw1);
	void __fastcall usekey(unsigned* from);
	void __fastcall deskey(System::Sysutils::PByteArray key, TIE3DESMode edf);
	void __fastcall des(System::PByte inblock, System::PByte outblock);
	
public:
	__fastcall TIE3DES(void)/* overload */;
	__fastcall TIE3DES(const System::AnsiString Password, TIE3DESMode Mode)/* overload */;
	__fastcall virtual ~TIE3DES(void);
	void __fastcall Reset(const System::AnsiString Password, TIE3DESMode Mode)/* overload */;
	void __fastcall Reset(__int64 Password, TIE3DESMode Mode)/* overload */;
	void __fastcall Transform(System::PByte InBlock, System::PByte OutBlock, int Length);
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIERandomGenerator : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	unsigned x;
	unsigned y;
	unsigned z;
	unsigned w;
	
public:
	__fastcall TIERandomGenerator(unsigned Seed)/* overload */;
	__fastcall TIERandomGenerator(System::AnsiString Seed)/* overload */;
	__fastcall TIERandomGenerator(unsigned Seed1, unsigned Seed2, unsigned Seed3, unsigned Seed4)/* overload */;
	unsigned __fastcall NextDWORD(void);
	__int64 __fastcall NextINT64(void);
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TIERandomGenerator(void) { }
	
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEImageListItem : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	TIEBitmap* image;
	System::WideString filename;
	__fastcall TIEImageListItem(TIEBitmap* image_, System::WideString filename_);
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TIEImageListItem(void) { }
	
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEImageList : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	TIEBitmap* operator[](int idx) { return Image[idx]; }
	
private:
	System::Classes::TList* m_images;
	int __fastcall GetImageCount(void);
	TIEBitmap* __fastcall GetImage(int idx);
	void __fastcall SetImage(int idx, TIEBitmap* value);
	System::WideString __fastcall GetFilename(int idx);
	void __fastcall SetFilename(int idx, System::WideString value);
	
public:
	__fastcall TIEImageList(void);
	__fastcall virtual ~TIEImageList(void);
	void __fastcall Clear(void);
	void __fastcall FillFromDirectory(const System::WideString Directory, int Limit = 0xffffffff, bool AllowUnknownFormats = false, const System::WideString ExcludeExtensions = System::WideString(), bool DetectFileFormat = false, const System::WideString FilterMask = System::WideString(), bool IncludeVideoFiles = false);
	int __fastcall AppendImageRef(TIEBitmap* image, System::WideString filename);
	void __fastcall Remove(int imageIndex);
	__property int ImageCount = {read=GetImageCount, nodefault};
	__property TIEBitmap* Image[int idx] = {read=GetImage, write=SetImage/*, default*/};
	__property System::WideString Filename[int idx] = {read=GetFilename, write=SetFilename};
};

#pragma pack(pop)

enum DECLSPEC_DENUM TIEEquirectangularRendererQuality : unsigned char { ierqLow, ierqHigh };

class PASCALIMPLEMENTATION TIEEquirectangularRenderer : public TIEVirtualBitmapProvider
{
	typedef TIEVirtualBitmapProvider inherited;
	
private:
	void *m_segmentBuffer;
	int m_segmentBufferSize;
	TIEBitmap* m_source;
	bool m_ownSource;
	System::StaticArray<double, 20001> m_arccos_tab;
	double m_cam_heading;
	double m_cam_pitch;
	double m_cam_fov;
	TIEEquirectangularRendererQuality m_quality;
	void __fastcall Init(TIEBitmap* Source, System::TObject* IOParams, bool OwnSource);
	void __fastcall RenderLowQuality(TIEBitmap* Container, int DestWidth, int DestHeight, Hyiedefs::PPointerArray DestScanlines, int DestX1, int DestY1, int DestX2, int DestY2, System::PInteger SrcCols, System::PInteger SrcRows, int Transparency, TIERenderOperation RenderOperation, double Opacity);
	void __fastcall RenderHighQuality(TIEBitmap* Container, int DestWidth, int DestHeight, Hyiedefs::PPointerArray DestScanlines, int DestX1, int DestY1, int DestX2, int DestY2, System::PInteger SrcCols, System::PInteger SrcRows, int Transparency, TIERenderOperation RenderOperation, double Opacity);
	
public:
	__fastcall TIEEquirectangularRenderer(TIEBitmap* Source, System::TObject* IOParams, bool OwnSource)/* overload */;
	__fastcall TIEEquirectangularRenderer(System::TObject* SourceView)/* overload */;
	__fastcall virtual ~TIEEquirectangularRenderer(void);
	virtual void __fastcall Render(TIEBitmap* Container, int DestWidth, int DestHeight, Hyiedefs::PPointerArray DestScanlines, int DestX1, int DestY1, int DestX2, int DestY2, System::PInteger SrcCols, System::PInteger SrcRows, int Transparency, TIERenderOperation RenderOperation, double Opacity);
	virtual void * __fastcall GetSegment(TIEBitmap* Container, int Row, int Col, int Width);
	__property TIEEquirectangularRendererQuality Quality = {read=m_quality, write=m_quality, nodefault};
	__property double CamHeading = {read=m_cam_heading, write=m_cam_heading};
	__property double CamPitch = {read=m_cam_pitch, write=m_cam_pitch};
	__property double CamFov = {read=m_cam_fov, write=m_cam_fov};
};


__interface  INTERFACE_UUID("{A7CC5606-1E6C-4A7D-972C-6464A392A278}") IIELoadPicture  : public System::IInterface 
{
	virtual void __fastcall LoadPicture(void) = 0 ;
};

enum DECLSPEC_DENUM TIESlippyMapProvider : unsigned char { iesmpOSM_Mapnik, iesmpOpenCycleMap, iesmpOpenCycleMapTransport, iesmpCloudMadeWebStyle, iesmpCloudMadeFineLineStyle, iesmpCloudMadeNoNamesStyle, iesmpMapQuest, iesmpMapQuestOpenAerial, iesmpMigurskisTerrain };

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIESlippyMapQueueItem : public System::TObject
{
	typedef System::TObject inherited;
	
	
private:
	enum DECLSPEC_DENUM _TIESlippyMapQueueItem__1 : unsigned char { iesmqWAIT, iesmqLOAD, iesmqSAVE, iesmqEND };
	
	
public:
	System::Types::TPoint tile;
	int zoom;
	TIEBitmap* bmp;
	TIEBitmap* destBitmap;
	System::Types::TPoint destPos;
	System::TObject* io;
	_TIESlippyMapQueueItem__1 state;
	__fastcall TIESlippyMapQueueItem(const System::Types::TPoint &tile_, int zoom_, TIEBitmap* destBitmap_, const System::Types::TPoint &destPos_);
	__fastcall virtual ~TIESlippyMapQueueItem(void);
};

#pragma pack(pop)

class PASCALIMPLEMENTATION TIESlippyMap : public TIEVirtualBitmapProvider
{
	typedef TIEVirtualBitmapProvider inherited;
	
private:
	System::UnicodeString m_providerURL;
	int m_providerURLIndex;
	System::Classes::TList* m_loadQueue;
	int m_maxThreads;
	System::UnicodeString m_cachePath;
	void *m_segmentBuffer;
	int m_segmentBufferSize;
	double m_latitude;
	double m_longitude;
	System::Types::TPoint m_pointPosition;
	int m_zoom;
	int m_memoryCacheSize;
	System::Classes::TList* m_memoryCache;
	System::UnicodeString m_userKey;
	System::Uitypes::TColor m_missingTileColor;
	void __fastcall init(const System::UnicodeString providerURL, const System::UnicodeString cachePath);
	void __fastcall SetLatitude(double value);
	void __fastcall SetLongitude(double value);
	
protected:
	__classmethod int __fastcall LongitudeToTileX(double longitude, int zoom);
	__classmethod int __fastcall LatitudeToTileY(double latitude, int zoom);
	__classmethod double __fastcall TileXToLongitude(int tileX, int zoom);
	__classmethod double __fastcall TileYToLatitude(int tileY, int zoom);
	__classmethod double __fastcall CoordXToLongitude(int coordX, int tileX, int zoom);
	__classmethod double __fastcall CoordYToLatitude(int coordY, int tileY, int zoom);
	__classmethod int __fastcall LongitudeToCoordX(double longitude, int zoom);
	__classmethod int __fastcall LatitudeToCoordY(double latitude, int zoom);
	System::UnicodeString __fastcall GetProviderURL(void);
	int __fastcall GetProviderURLCount(void);
	System::UnicodeString __fastcall GetFileURL(int tileX, int tileY);
	System::UnicodeString __fastcall GetCachedFileName(int tileX, int tileY);
	bool __fastcall ProcessQueue(void);
	void __fastcall AddTileToLoadQueue(const System::Types::TPoint &tile, TIEBitmap* destBitmap, const System::Types::TPoint &destPos);
	void __fastcall WaitLoadQueue(void);
	void __fastcall ClearLoadQueue(void);
	void __fastcall ClearMemoryCache(void);
	void __fastcall AddItemToMemoryCache(TIESlippyMapQueueItem* item);
	void __fastcall CalcTopLeftTileAndPos(System::Types::TPoint &startTile, System::Types::TPoint &startPos);
	int __fastcall WrapHorizTile(int tileX);
	
public:
	__fastcall TIESlippyMap(const System::UnicodeString providerURL, const System::UnicodeString cachePath)/* overload */;
	__fastcall TIESlippyMap(TIESlippyMapProvider provider, const System::UnicodeString cachePath)/* overload */;
	__fastcall virtual ~TIESlippyMap(void);
	void __fastcall DrawTo(TIEBitmap* destBitmap);
	virtual void __fastcall Render(TIEBitmap* Container, int DestWidth, int DestHeight, Hyiedefs::PPointerArray DestScanlines, int DestX1, int DestY1, int DestX2, int DestY2, System::PInteger SrcCols, System::PInteger SrcRows, int Transparency, TIERenderOperation RenderOperation, double Opacity);
	virtual void * __fastcall GetSegment(TIEBitmap* Container, int Row, int Col, int Width);
	__property int MaxThreads = {read=m_maxThreads, write=m_maxThreads, nodefault};
	__property System::UnicodeString CachePath = {read=m_cachePath, write=m_cachePath};
	__property int MemoryCacheSize = {read=m_memoryCacheSize, write=m_memoryCacheSize, nodefault};
	__property double Latitude = {read=m_latitude, write=SetLatitude};
	__property double Longitude = {read=m_longitude, write=SetLongitude};
	__property int Zoom = {read=m_zoom, write=m_zoom, nodefault};
	__property System::Types::TPoint PointPosition = {read=m_pointPosition, write=m_pointPosition};
	__property System::UnicodeString UserKey = {read=m_userKey, write=m_userKey};
	__property System::Uitypes::TColor MissingTileColor = {read=m_missingTileColor, write=m_missingTileColor, nodefault};
	double __fastcall BmpXToLongitude(int X);
	double __fastcall BmpYToLatitude(int Y);
	int __fastcall LongitudeToBmpX(double lon);
	int __fastcall LatitudeToBmpY(double lat);
};


typedef unsigned __fastcall (*TIEStrHashFunction)(const System::WideString str, unsigned bucketCount);

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEDictionaryValueWideString : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	System::WideString value;
	__fastcall TIEDictionaryValueWideString(System::WideString value);
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TIEDictionaryValueWideString(void) { }
	
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEDictionaryValueInteger : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	int value;
	__fastcall TIEDictionaryValueInteger(int value);
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TIEDictionaryValueInteger(void) { }
	
};

#pragma pack(pop)

class PASCALIMPLEMENTATION TIEDictionaryValueDouble : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	double value;
	__fastcall TIEDictionaryValueDouble(double value);
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TIEDictionaryValueDouble(void) { }
	
};


#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEDictionaryValueBoolean : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	bool value;
	__fastcall TIEDictionaryValueBoolean(bool value);
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TIEDictionaryValueBoolean(void) { }
	
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEDictionaryBucket : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	System::WideString key;
	System::TObject* value;
	TIEDictionaryBucket* next;
	__fastcall TIEDictionaryBucket(const System::WideString key_, System::TObject* const value_, TIEDictionaryBucket* next_)/* overload */;
	__fastcall virtual ~TIEDictionaryBucket(void);
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEStrStrEnumerator : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	unsigned bucket;
	TIEDictionaryBucket* item;
	__fastcall TIEStrStrEnumerator(void);
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TIEStrStrEnumerator(void) { }
	
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEDictionary : public System::TObject
{
	typedef System::TObject inherited;
	
	
private:
	typedef System::DynamicArray<TIEDictionaryBucket*> _TIEDictionary__1;
	
	
private:
	unsigned m_bucketCount;
	_TIEDictionary__1 m_buckets;
	TIEStrHashFunction m_hashFunction;
	void __fastcall init(unsigned buckets, TIEStrHashFunction hashFunction);
	TIEDictionaryBucket* __fastcall GetInBucket(unsigned bucket, System::WideString key, /* out */ TIEDictionaryBucket* &lastItem);
	System::WideString __fastcall Dump(System::TObject* obj)/* overload */;
	System::WideString __fastcall Dump(System::Contnrs::TObjectList* obj)/* overload */;
	System::WideString __fastcall EncodeString(System::WideString Text);
	System::TObject* __fastcall FindInDictionaries(System::WideString key);
	
public:
	__fastcall TIEDictionary(unsigned buckets, TIEStrHashFunction hashFunction)/* overload */;
	__fastcall TIEDictionary(unsigned buckets)/* overload */;
	__fastcall virtual ~TIEDictionary(void);
	void __fastcall Clear(void);
	bool __fastcall IsEmpty(void);
	bool __fastcall HasKey(System::WideString key, bool recursive = false);
	System::TObject* __fastcall Get(System::WideString key, bool silent = false, bool recursive = false);
	System::WideString __fastcall GetString(System::WideString key, bool recursive = false);
	int __fastcall GetInteger(System::WideString key, bool recursive = false);
	double __fastcall GetDouble(System::WideString key, bool recursive = false);
	bool __fastcall GetBoolean(System::WideString key, bool recursive = false);
	TIEDictionary* __fastcall GetDictionary(System::WideString key, bool recursive = false);
	System::Contnrs::TObjectList* __fastcall GetList(System::WideString key, bool recursive = false);
	void __fastcall Insert(System::WideString key, System::TObject* value)/* overload */;
	void __fastcall Insert(System::WideString key, System::WideString value)/* overload */;
	void __fastcall Insert(System::WideString key, int value)/* overload */;
	void __fastcall Insert(System::WideString key, double value)/* overload */;
	void __fastcall Insert(System::WideString key, bool value)/* overload */;
	void __fastcall Insert(System::WideString key, TIEDictionary* value)/* overload */;
	void __fastcall Insert(System::WideString key, System::Contnrs::TObjectList* value)/* overload */;
	bool __fastcall Erase(System::WideString key, bool freeValue = true);
	bool __fastcall GetNext(TIEStrStrEnumerator* current);
	System::WideString __fastcall Dump(void)/* overload */;
	bool __fastcall Parse(System::WideString text);
	void __fastcall Assign(TIEDictionary* Source);
};

#pragma pack(pop)

enum DECLSPEC_DENUM TIEDictionaryParserLang : unsigned char { ieplJSON, ieplXML };

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEDictionaryParser : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::WideString m_text;
	int m_textLen;
	int m_textPos;
	bool m_abort;
	TIEDictionaryParserLang m_lang;
	void __fastcall AbortParse(void);
	bool __fastcall IsToken(System::WideChar c);
	bool __fastcall IsSpace(System::WideChar c);
	void __fastcall ByPassSpaces(void);
	bool __fastcall HasChar(void);
	System::WideChar __fastcall GetChar(void);
	System::WideChar __fastcall PeekChar(void);
	System::WideChar __fastcall GetToken(void);
	System::WideChar __fastcall PeekToken(void);
	System::WideString __fastcall GetString(void);
	TIEDictionaryValueWideString* __fastcall ParseString(void);
	System::TObject* __fastcall ParseIdentifier(void);
	int __fastcall SavePos(void);
	void __fastcall RestorePos(int pos);
	System::WideString __fastcall DecodeString(System::WideString Text);
	TIEDictionary* __fastcall JSON_ParseDictionary(TIEDictionary* mergeWith = (TIEDictionary*)(0x0));
	System::TObject* __fastcall JSON_ParseValue(void);
	System::Contnrs::TObjectList* __fastcall JSON_ParseArray(void);
	TIEDictionary* __fastcall XML_ParseContent(TIEDictionary* mergeWith = (TIEDictionary*)(0x0));
	System::WideString __fastcall XML_GetName(void);
	TIEDictionary* __fastcall XML_ParseAttributes(void);
	
public:
	__fastcall TIEDictionaryParser(System::WideString Text);
	TIEDictionary* __fastcall Parse(TIEDictionary* mergeWith = (TIEDictionary*)(0x0));
	__property bool Aborted = {read=m_abort, nodefault};
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TIEDictionaryParser(void) { }
	
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEVCLStreamProvider : public System::TInterfacedObject
{
	typedef System::TInterfacedObject inherited;
	
private:
	System::Classes::TStream* m_stream;
	
public:
	__fastcall TIEVCLStreamProvider(System::Classes::TStream* Stream);
	__fastcall virtual ~TIEVCLStreamProvider(void);
	HRESULT __safecall size(__int64 &__size_result);
	HRESULT __safecall seek(__int64 offset, Ievision::TIEVisionSeekOffset whence);
	HRESULT __safecall tell(__int64 &__tell_result);
	HRESULT __safecall silent_read(void * ptr, __int64 size, __int64 &__silent_read_result);
	HRESULT __safecall silent_write(void * ptr, __int64 size, __int64 &__silent_write_result);
	HRESULT __safecall silent_getc(int &__silent_getc_result);
	HRESULT __safecall eof(System::LongBool &__eof_result);
private:
	void *__TIEVisionCustomStreamProvider;	// Ievision::TIEVisionCustomStreamProvider 
	
public:
	operator Ievision::TIEVisionCustomStreamProvider*(void) { return (Ievision::TIEVisionCustomStreamProvider*)&__TIEVisionCustomStreamProvider; }
	
};

#pragma pack(pop)

enum DECLSPEC_DENUM TFitMethod : unsigned char { _fmFitWithinRect, _fmFillRect_WithOverlap };

enum DECLSPEC_DENUM TIEURLType : unsigned char { ieurlUNKNOWN, ieurlHTTP, ieurlHTTPS, ieurlFTP };

//-- var, const, procedure ---------------------------------------------------
static const System::Int8 IEAnnotImageEmbedded = System::Int8(0x1);
static const System::Int8 IEAnnotImageReference = System::Int8(0x2);
static const System::Int8 IEAnnotStraightLine = System::Int8(0x3);
static const System::Int8 IEAnnotFreehandLine = System::Int8(0x4);
static const System::Int8 IEAnnotHollowRectangle = System::Int8(0x5);
static const System::Int8 IEAnnotFilledRectangle = System::Int8(0x6);
static const System::Int8 IEAnnotTypedText = System::Int8(0x7);
static const System::Int8 IEAnnotTextFromFile = System::Int8(0x8);
static const System::Int8 IEAnnotTextStamp = System::Int8(0x9);
static const System::Int8 IEAnnotAttachANote = System::Int8(0xa);
static const System::Int8 IEAnnotForm = System::Int8(0xc);
static const System::Int8 IEAnnotOCRRegion = System::Int8(0xd);
static const System::Int8 IEMAXCHANNELS = System::Int8(0x4);
extern DELPHI_PACKAGE TIE_OpenColorProfile IE_OpenColorProfile;
extern DELPHI_PACKAGE TIE_CloseColorProfile IE_CloseColorProfile;
extern DELPHI_PACKAGE TIE_CreateMultiProfileTransform IE_CreateMultiProfileTransform;
extern DELPHI_PACKAGE TIE_DeleteColorTransform IE_DeleteColorTransform;
extern DELPHI_PACKAGE TIE_TranslateColors IE_TranslateColors;
static const System::Int8 IE_COLOR_GRAY = System::Int8(0x1);
static const System::Int8 IE_COLOR_RGB = System::Int8(0x2);
static const System::Int8 IE_COLOR_XYZ = System::Int8(0x3);
static const System::Int8 IE_COLOR_Yxy = System::Int8(0x4);
static const System::Int8 IE_COLOR_Lab = System::Int8(0x5);
static const System::Int8 IE_COLOR_3_CHANNEL = System::Int8(0x6);
static const System::Int8 IE_COLOR_CMYK = System::Int8(0x7);
static const System::Int8 IE_COLOR_5_CHANNEL = System::Int8(0x8);
static const System::Int8 IE_COLOR_6_CHANNEL = System::Int8(0x9);
static const System::Int8 IE_COLOR_7_CHANNEL = System::Int8(0xa);
static const System::Int8 IE_COLOR_8_CHANNEL = System::Int8(0xb);
static const System::Int8 IE_COLOR_NAMED = System::Int8(0xc);
static const System::Int8 IE_PROFILE_READ = System::Int8(0x1);
static const System::Int8 IE_PROFILE_READWRITE = System::Int8(0x2);
static const System::Int8 IE_PROFILE_FILENAME = System::Int8(0x1);
static const System::Int8 IE_PROFILE_MEMBUFFER = System::Int8(0x2);
extern DELPHI_PACKAGE System::AnsiString IE_LCS_SIGNATURE;
static const System::Int8 IE_LCS_CALIBRATED_RGB = System::Int8(0x0);
extern DELPHI_PACKAGE System::AnsiString IE_LCS_sRGB;
extern DELPHI_PACKAGE System::AnsiString IE_LCS_WINDOWS_COLOR_SPACE;
static const System::Int8 IE_LCS_GM_BUSINESS = System::Int8(0x1);
static const System::Int8 IE_LCS_GM_GRAPHICS = System::Int8(0x2);
static const System::Int8 IE_LCS_GM_IMAGES = System::Int8(0x4);
static const System::Int8 IE_LCS_GM_ABS_COLORIMETRIC = System::Int8(0x8);
static const System::Int8 IE_PROOF_MODE = System::Int8(0x1);
static const System::Int8 IE_NORMAL_MODE = System::Int8(0x2);
static const System::Int8 IE_BEST_MODE = System::Int8(0x3);
static const int IE_ENABLE_GAMUT_CHECKING = int(0x10000);
static const int IE_USE_RELATIVE_COLORIMETRIC = int(0x20000);
static const int IE_FAST_TRANSLATE = int(0x40000);
static const System::Int8 IE_INDEX_DONT_CARE = System::Int8(0x0);
static const System::Int8 IE_INTENT_PERCEPTUAL = System::Int8(0x0);
static const System::Int8 IE_INTENT_RELATIVE_COLORIMETRIC = System::Int8(0x1);
static const System::Int8 IE_INTENT_SATURATION = System::Int8(0x2);
static const System::Int8 IE_INTENT_ABSOLUTE_COLORIMETRIC = System::Int8(0x3);
extern DELPHI_PACKAGE System::StaticArray<unsigned, 9> IE_CS2IF;
extern DELPHI_PACKAGE System::LongBool __stdcall (*IEGetGestureInfo)(NativeUInt hGestureInfo, Hyiedefs::PIEGESTUREINFO pGestureInfo);
extern DELPHI_PACKAGE System::LongBool __stdcall (*IECloseGestureInfoHandle)(NativeUInt hGestureInfo);
extern DELPHI_PACKAGE System::LongBool __stdcall (*IESetGestureConfig)(NativeUInt hwnd, unsigned dwReserved, unsigned cIDS, Hyiedefs::PIEGESTURECONFIG pGestureConfig, unsigned cbSize);
extern DELPHI_PACKAGE System::LongBool __stdcall (*IEUnregisterTouchWindow)(NativeUInt hwnd);
extern DELPHI_PACKAGE System::StaticArray<System::Byte, 8> iebitmask1;
extern DELPHI_PACKAGE System::StaticArray<System::Byte, 256> ierevertbyte;
extern DELPHI_PACKAGE bool __fastcall IEDirectoryExists(const System::UnicodeString Name);
extern DELPHI_PACKAGE void __fastcall IEForceDirectories(System::UnicodeString Dir);
extern DELPHI_PACKAGE int __fastcall _GetBitCount(int b);
extern DELPHI_PACKAGE int __fastcall _NColToBitsPixel(int NCol);
extern DELPHI_PACKAGE __int64 __fastcall IEBitmapRowLen(int Width, int BitCount, int align);
extern DELPHI_PACKAGE int __fastcall _Pixelformat2BitCount(Vcl::Graphics::TPixelFormat PixelFormat);
extern DELPHI_PACKAGE TIEPixelFormat __fastcall IEVCLPixelFormat2ImageEnPixelFormat(Vcl::Graphics::TPixelFormat PixelFormat);
extern DELPHI_PACKAGE int __fastcall _PixelFormat2RowLen(int Width, Vcl::Graphics::TPixelFormat PixelFormat);
extern DELPHI_PACKAGE Vcl::Graphics::TPixelFormat __fastcall _Bitcount2Pixelformat(int Bitcount);
extern DELPHI_PACKAGE void __fastcall ReverseBitsB(System::Byte &inp);
extern DELPHI_PACKAGE void __fastcall ReverseBits(unsigned &inp);
extern DELPHI_PACKAGE double __fastcall IEPower2(const double Base, const double Exponent);
extern DELPHI_PACKAGE void __fastcall DrawDibDrawEmu(NativeUInt hdd, NativeUInt hDC, int xDst, int yDst, int dxDst, int dyDst, tagBITMAPINFOHEADER &lpbi, void * Bits, int xSrc, int ySrc, int dxSrc, int dySrc, unsigned wFlags);
extern DELPHI_PACKAGE void __fastcall DrawDib(NativeUInt hDC, int xDst, int yDst, int dxDst, int dyDst, tagBITMAPINFOHEADER &lpbi, void * Bits, int xSrc, int ySrc, int dxSrc, int dySrc);
extern DELPHI_PACKAGE System::Word __fastcall IESwapWord(System::Word i);
extern DELPHI_PACKAGE void __fastcall IEChangeEndiannessWordArray(PWORD buffer, int items);
extern DELPHI_PACKAGE void __fastcall IEChangeEndiannessDWordArray(unsigned* buffer, int items);
extern DELPHI_PACKAGE int __fastcall IESwapDWord(int i);
extern DELPHI_PACKAGE __int64 __fastcall IESwapInt64(__int64 i);
extern DELPHI_PACKAGE void __fastcall _CastPolySelCC(const int x1, const int y1, int &x2, int &y2);
extern DELPHI_PACKAGE bool __fastcall _RectXRect(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2);
extern DELPHI_PACKAGE int __fastcall _RectPRect(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2);
extern DELPHI_PACKAGE bool __fastcall IEPointInRect(int xx, int yy, int x1, int y1, int x2, int y2)/* overload */;
extern DELPHI_PACKAGE bool __fastcall IEPointInRect(int xx, int yy, const System::Types::TRect &ARect)/* overload */;
extern DELPHI_PACKAGE bool __fastcall _InRectO(int xx, int yy, int x1, int y1, int x2, int y2);
extern DELPHI_PACKAGE __int64 __fastcall IEGetFileSize(const System::UnicodeString FileName);
extern DELPHI_PACKAGE bool __fastcall PromptForColor(System::Uitypes::TColor &AColor);
extern DELPHI_PACKAGE HWND __fastcall IEFindHandle(System::Classes::TComponent* cmp);
extern DELPHI_PACKAGE void __fastcall IERightShadow(Vcl::Graphics::TCanvas* Canvas, Vcl::Graphics::TBitmap* DestBitmap, int x1, int y1, int x2, int y2, TIEShadowType st, System::Uitypes::TColor dstColor);
extern DELPHI_PACKAGE void __fastcall IEBottomShadow(Vcl::Graphics::TCanvas* Canvas, Vcl::Graphics::TBitmap* DestBitmap, int x1, int y1, int x2, int y2, TIEShadowType st, System::Uitypes::TColor dstColor);
extern DELPHI_PACKAGE void __fastcall IERectShadow(Vcl::Graphics::TBitmap* Bitmap, int x1, int y1, int x2, int y2, System::Uitypes::TColor dstColor);
extern DELPHI_PACKAGE void __fastcall IESaveStringToStream(System::Classes::TStream* Stream, const System::AnsiString ss);
extern DELPHI_PACKAGE void __fastcall IELoadStringFromStream(System::Classes::TStream* Stream, System::AnsiString &ss);
extern DELPHI_PACKAGE void __fastcall IESaveStringToStreamW(System::Classes::TStream* Stream, const System::WideString ss);
extern DELPHI_PACKAGE void __fastcall IELoadStringFromStreamW(System::Classes::TStream* Stream, System::WideString &ss);
extern DELPHI_PACKAGE void __fastcall IESaveStringListToStream(System::Classes::TStream* Stream, System::Classes::TStringList* sl);
extern DELPHI_PACKAGE void __fastcall IELoadStringListFromStream(System::Classes::TStream* Stream, System::Classes::TStringList* sl);
extern DELPHI_PACKAGE int __fastcall _GetNumCol(int BitsPerSample, int SamplesPerPixel);
extern DELPHI_PACKAGE void __fastcall IESetTranslationWord(const Hyiedefs::TMsgLanguage lang, const Hyiedefs::TMsgLanguageWords msg, const System::AnsiString trans);
extern DELPHI_PACKAGE void __fastcall IESetTranslationWordU(const Hyiedefs::TMsgLanguage lang, const Hyiedefs::TMsgLanguageWords msg, const System::UnicodeString trans);
extern DELPHI_PACKAGE System::WideString __fastcall iemsg(const Hyiedefs::TMsgLanguageWords msg);
extern DELPHI_PACKAGE int __fastcall IEFloor(System::Extended X);
extern DELPHI_PACKAGE double __fastcall _DistPoint2Point(int x1, int y1, int x2, int y2);
extern DELPHI_PACKAGE double __fastcall _DistPoint2Line(int xp, int yp, int x1, int y1, int x2, int y2);
extern DELPHI_PACKAGE double __fastcall _DistPoint2Seg(int xp, int yp, int x1, int y1, int x2, int y2);
extern DELPHI_PACKAGE double __fastcall _DistPoint2Polyline(int x, int y, Hyiedefs::PPointArray PolyPoints, int PolyPointsCount, int ToSubX, int ToSubY, int ToAddX, int ToAddY, double ToMulX, double ToMulY, int penWidth, bool closed);
extern DELPHI_PACKAGE System::ByteBool __fastcall IEMMXSupported(void);
extern DELPHI_PACKAGE void __fastcall SafeStreamWrite(System::Classes::TStream* Stream, bool &Aborting, const void *Buffer, int Count);
extern DELPHI_PACKAGE void __fastcall IEBitmapMapXCopy(System::PByte map, unsigned maprowlen, unsigned mapbitcount, Vcl::Graphics::TBitmap* bitmap, unsigned mapx, unsigned mapy, unsigned bitmapx, unsigned bitmapy, unsigned dx, unsigned dy, int dir);
extern DELPHI_PACKAGE void __fastcall IECopyEXIF(System::TObject* source_, System::TObject* dest_, bool copyBitmap);
extern DELPHI_PACKAGE void __fastcall SaveEXIFToStandardBuffer(System::TObject* params, void * &Buffer, int &BufferLength, bool savePreamble);
extern DELPHI_PACKAGE bool __fastcall CheckEXIFFromStandardBuffer(void * Buffer, int BufferLength);
extern DELPHI_PACKAGE bool __fastcall LoadEXIFFromStandardBuffer(void * Buffer, int BufferLength, System::TObject* params);
extern DELPHI_PACKAGE __int64 __fastcall IESearchEXIFInfo(System::Classes::TStream* Stream);
extern DELPHI_PACKAGE bool __fastcall IELoadEXIFFromTIFF(System::Classes::TStream* Stream, System::TObject* params, bool loadXMP)/* overload */;
extern DELPHI_PACKAGE bool __fastcall IELoadParamsFromTIFF(System::Classes::TStream* Stream, System::TObject* params, int page)/* overload */;
extern DELPHI_PACKAGE System::TDateTime __fastcall EXIFDateToDateTime(System::UnicodeString sEXIFDate);
extern DELPHI_PACKAGE System::UnicodeString __fastcall DateTimeToEXIFDate(System::TDateTime ADateTime);
extern DELPHI_PACKAGE bool __fastcall IEReadEXIFFromMOV(const System::WideString FileName, System::TObject* OutParams)/* overload */;
extern DELPHI_PACKAGE bool __fastcall IEReadEXIFFromMOV(System::Classes::TStream* Stream, System::TObject* OutParams)/* overload */;
extern DELPHI_PACKAGE TIEOpSys __fastcall IEGetOpSys(void);
extern DELPHI_PACKAGE int __fastcall IEGetDisplayOrientation(void);
extern DELPHI_PACKAGE System::Extended __fastcall IEStrToFloatDefA(System::AnsiString s, System::Extended Def);
extern DELPHI_PACKAGE System::Extended __fastcall IEStrToFloatDefW(System::WideString s, System::Extended Def);
extern DELPHI_PACKAGE System::Extended __fastcall IEStrToFloatDefS(System::UnicodeString s, System::Extended Def);
extern DELPHI_PACKAGE System::Extended __fastcall IEStrToFloatDef(System::UnicodeString s, System::Extended Def);
extern DELPHI_PACKAGE unsigned __fastcall IEStrLen(const char * Str);
extern DELPHI_PACKAGE unsigned __fastcall IEStrLenW(System::WideChar * Str);
extern DELPHI_PACKAGE char * __fastcall IEStrCopy(char * Dest, const char * Source);
extern DELPHI_PACKAGE System::WideChar * __fastcall IEStrCopyW(System::WideChar * Dest, System::WideChar * Source);
extern DELPHI_PACKAGE char * __fastcall IEStrPCopy(char * Dest, const System::AnsiString Source);
extern DELPHI_PACKAGE System::WideChar * __fastcall IEStrPCopyW(System::WideChar * Dest, const System::WideString Source);
extern DELPHI_PACKAGE char * __fastcall IEStrMove(char * Dest, const char * Source, unsigned Count);
extern DELPHI_PACKAGE char * __fastcall IEAnsiStrScan(char * Str, char Chr);
extern DELPHI_PACKAGE char * __fastcall IEStrScan(const char * Str, char Chr);
extern DELPHI_PACKAGE char * __fastcall IEStrRScan(const char * Str, char Chr);
extern DELPHI_PACKAGE bool __fastcall IETextToFloat(char * Buffer, void *Value, System::Sysutils::TFloatValue ValueType)/* overload */;
extern DELPHI_PACKAGE Hyiedefs::TIEArrayOfByte __fastcall IECopyArrayOfByte(const Hyiedefs::TIEArrayOfByte Input);
extern DELPHI_PACKAGE Hyiedefs::TIEArrayOfInteger __fastcall IECopyArrayOfInteger(const Hyiedefs::TIEArrayOfInteger Input);
extern DELPHI_PACKAGE Hyiedefs::TCIELab __fastcall IERGB2CIELAB(Hyiedefs::TRGB rgb);
extern DELPHI_PACKAGE Hyiedefs::TRGB __fastcall IECIELAB2RGB(const Hyiedefs::TCIELab lab);
extern DELPHI_PACKAGE void __fastcall IEDraw3DRect(Vcl::Graphics::TCanvas* Canvas, int x1, int y1, int x2, int y2, System::Uitypes::TColor cl1, System::Uitypes::TColor cl2);
extern DELPHI_PACKAGE void __fastcall IEDraw3DRect2(System::TObject* Canvas, int x1, int y1, int x2, int y2, System::Uitypes::TColor cl1, System::Uitypes::TColor cl2);
extern DELPHI_PACKAGE void __fastcall IEBlendRGBA(Hyiedefs::TRGBA &src, Hyiedefs::TRGBA &dst, TIERenderOperation RenderOperation, int row);
extern DELPHI_PACKAGE void __fastcall IEBlend(Hyiedefs::TRGB &src, Hyiedefs::TRGB &dst, TIERenderOperation RenderOperation, int row);
extern DELPHI_PACKAGE void __fastcall IEDrawHint(Vcl::Graphics::TCanvas* Canvas, int &x, int &y, const System::UnicodeString ss, Vcl::Graphics::TFont* Font, Vcl::Graphics::TBrush* Brush, Vcl::Graphics::TBitmap* &SaveBitmap, int MaxWidth, int MaxHeight, System::Uitypes::TColor Border1, System::Uitypes::TColor Border2);
extern DELPHI_PACKAGE void __fastcall IEDrawHint2(Vcl::Graphics::TCanvas* Canvas, int &x, int &y, const System::UnicodeString ss, const System::UnicodeString minText);
extern DELPHI_PACKAGE bool __fastcall IEDrawDibClose(NativeUInt hdd);
extern DELPHI_PACKAGE bool __fastcall IEDrawDibDraw(NativeUInt hdd, NativeUInt hDC, int xDst, int yDst, int dxDst, int dyDst, tagBITMAPINFOHEADER &lpbi, void * Bits, int xSrc, int ySrc, int dxSrc, int dySrc, unsigned wFlags);
extern DELPHI_PACKAGE NativeUInt __fastcall IEDrawDibOpen(void);
extern DELPHI_PACKAGE unsigned __fastcall IEDrawDibRealize(NativeUInt hdd, NativeUInt hDC, System::LongBool fBackground);
extern DELPHI_PACKAGE void __fastcall IECenterWindow(HWND Wnd);
extern DELPHI_PACKAGE __int64 __fastcall IEGetMemory(bool freememory);
extern DELPHI_PACKAGE void __fastcall IESetplim(System::Types::TRect &plim, int x, int y);
extern DELPHI_PACKAGE System::Extended __fastcall IEArcCos(System::Extended X);
extern DELPHI_PACKAGE double __fastcall IEAngle(int x1, int y1, int x2, int y2, int x3, int y3);
extern DELPHI_PACKAGE double __fastcall IEAngle2(int x1, int y1, int x2, int y2);
extern DELPHI_PACKAGE double __fastcall IEAngle3(int x1, int y1, int xc, int yc, int x2, int y2);
extern DELPHI_PACKAGE double __fastcall IEGetReferenceAngle(double Angle);
extern DELPHI_PACKAGE System::Uitypes::TFontStyles __fastcall IEExtractStylesFromLogFont(Winapi::Windows::PLogFontA logfont);
extern DELPHI_PACKAGE System::Uitypes::TFontStyles __fastcall IEExtractStylesFromLogFontW(Winapi::Windows::PLogFontW logfont);
extern DELPHI_PACKAGE void __fastcall IECopyLogFont(Winapi::Windows::PLogFontA src, Winapi::Windows::PLogFontW dst);
extern DELPHI_PACKAGE bool __fastcall CompareGUID(const GUID &g1, const GUID &g2);
extern DELPHI_PACKAGE System::AnsiString __fastcall IEConvertGUIDToString(System::PGUID g);
extern DELPHI_PACKAGE void __fastcall IEConvertWStringToGUID(System::WideString invar, System::PGUID gg);
extern DELPHI_PACKAGE void __fastcall IEConvertAStringToGUID(System::AnsiString invar, System::PGUID gg);
extern DELPHI_PACKAGE void __fastcall IEResetPrinter(void);
extern DELPHI_PACKAGE void __fastcall IEGetFitResampleSize(int owidth, int oheight, int fwidth, int fheight, /* out */ int &rwidth, /* out */ int &rheight);
extern DELPHI_PACKAGE void __fastcall IEGetFitResampleSizeWithAutoCrop(int iImageWidth, int iImageHeight, int iAvailableWidth, int iAvailableHeight, /* out */ int &RWidth, /* out */ int &RHeight, int iAutoCropPercent, /* out */ int &RAutoWidth, /* out */ int &RAutoHeight);
extern DELPHI_PACKAGE int __fastcall IEASCII85EncodeBlock(System::PByte &inbytes, int buflen, char * &outstr, int &asciilen);
extern DELPHI_PACKAGE int __fastcall IEASCII85DecodeBlock(char * &instr, int buflen, System::PByte &outbytes);
extern DELPHI_PACKAGE int __fastcall IEPSRunLengthEncode(System::Sysutils::PByteArray inbytes, int inlen, System::Sysutils::PByteArray outbytes);
extern DELPHI_PACKAGE void __fastcall IEWriteStrLn(System::Classes::TStream* s, System::AnsiString ss);
extern DELPHI_PACKAGE void __fastcall IERegisterFormats(void);
extern DELPHI_PACKAGE void __fastcall IEUnregisterFormats(void);
extern DELPHI_PACKAGE void __fastcall iepdf_WriteLn(System::Classes::TStream* Stream, System::AnsiString line);
extern DELPHI_PACKAGE void __fastcall iepdf_Write(System::Classes::TStream* Stream, System::AnsiString line);
extern DELPHI_PACKAGE void __fastcall iepdf_WriteHeader(System::Classes::TStream* Stream);
extern DELPHI_PACKAGE void __fastcall iepdf_WriteFooter(System::Classes::TStream* Stream, System::Classes::TList* IndirectObjects, TIEPDFObject* info);
extern DELPHI_PACKAGE void __fastcall iepdf_AddIndirectObject(System::Classes::TList* IndirectObjects, TIEPDFObject* obj);
extern DELPHI_PACKAGE void __fastcall iepdf_WriteIndirectObjects(System::Classes::TStream* Stream, System::Classes::TList* IndirectObjects);
extern DELPHI_PACKAGE TIEPDFDictionaryObject* __fastcall iepdf_AddCatalog(System::Classes::TList* IndirectObjects);
extern DELPHI_PACKAGE TIEPDFDictionaryObject* __fastcall iepdf_AddPageTree(System::Classes::TList* IndirectObjects, System::Classes::TList* pages);
extern DELPHI_PACKAGE void __fastcall iepdf_AddPage(System::Classes::TList* IndirectObjects, System::Classes::TList* pages, TIEPDFDictionaryObject* Resources, TIEPDFArrayObject* MediaBox, int Content);
extern DELPHI_PACKAGE int __fastcall IEPDFFrameCount(System::Classes::TStream* Stream)/* overload */;
extern DELPHI_PACKAGE int __fastcall IEPDFFrameCount(const System::WideString Filename)/* overload */;
extern DELPHI_PACKAGE bool __fastcall IEIsRemoteSession(void);
extern DELPHI_PACKAGE void __fastcall IEBezier2D4Controls(const System::Types::TPoint &p0, const System::Types::TPoint &c0, const System::Types::TPoint &c1, const System::Types::TPoint &p1, Hyiedefs::PPointArray pResultArray, int nSteps);
extern DELPHI_PACKAGE void __fastcall IEEncode64(System::Classes::TStream* SrcStream, System::Classes::TStream* DstStream, int linesize)/* overload */;
extern DELPHI_PACKAGE System::AnsiString __fastcall IEEncode64(System::PByte SrcBuffer, int SrcBufferLength, int linesize)/* overload */;
extern DELPHI_PACKAGE void __fastcall IEDecode64(System::Classes::TStream* SrcStream, System::Classes::TStream* DstStream)/* overload */;
extern DELPHI_PACKAGE Hyiedefs::TIEArrayOfByte __fastcall IEDecode64(System::AnsiString SrcString)/* overload */;
extern DELPHI_PACKAGE void __fastcall IESetScrollBar(HWND hWnd, int nBar, int nMinPos, int nMaxPos, int PageSize, int nPos, bool bRedraw, bool flat);
extern DELPHI_PACKAGE System::LongBool __fastcall IESetScrollRange(HWND hWnd, int nBar, int nMinPos, int nMaxPos, System::LongBool bRedraw, bool flat);
extern DELPHI_PACKAGE int __fastcall IESetScrollPos(HWND hWnd, int nBar, int nPos, System::LongBool bRedraw, bool flat);
extern DELPHI_PACKAGE void __fastcall IESetSBPageSize(NativeUInt HScrollBar, int fnBar, int PageSize, bool Redraw, bool flat);
extern DELPHI_PACKAGE int __fastcall IESetScrollInfo(HWND hWnd, int BarFlag, const tagSCROLLINFO &ScrollInfo, System::LongBool Redraw, bool flat);
extern DELPHI_PACKAGE System::LongBool __fastcall IEEnableScrollBar(HWND hWnd, unsigned wSBflags, unsigned wArrows, bool flat);
extern DELPHI_PACKAGE System::LongBool __fastcall IEShowScrollBar(HWND hWnd, int wBar, System::LongBool bShow, bool flat);
extern DELPHI_PACKAGE int __fastcall IEIFI(bool cond, int val1, int val2);
extern DELPHI_PACKAGE double __fastcall IEIFD(bool cond, double val1, double val2);
extern DELPHI_PACKAGE TIEBitmap* __fastcall IEIFB(bool cond, TIEBitmap* val1, TIEBitmap* val2);
extern DELPHI_PACKAGE void __fastcall IEAdjustEXIFOrientation(TIEBitmap* Bitmap, int Orientation);
extern DELPHI_PACKAGE System::Types::TPoint __fastcall GetImageSizeWithinArea(int iImageWidth, int iImageHeight, int iAvailableWidth, int iAvailableHeight, bool bAllowStretching = true, TFitMethod FitMethod = (TFitMethod)(0x0));
extern DELPHI_PACKAGE System::Types::TRect __fastcall GetImageRectWithinArea(int iImageWidth, int iImageHeight, int iAvailableWidth, int iAvailableHeight, int iHorzOffset = 0x0, int iVertOffset = 0x0, bool bAllowStretching = true, bool bAllowShrinking = true, bool bCenterHorz = true, bool bCenterVert = true, int iAutoCropPercent = 0x0, TFitMethod FitMethod = (TFitMethod)(0x0))/* overload */;
extern DELPHI_PACKAGE System::Types::TRect __fastcall GetImageRectWithinArea(int iImageWidth, int iImageHeight, const System::Types::TRect &ADestRect, bool bAllowStretching = true, bool bAllowShrinking = true, bool bCenterHorz = true, bool bCenterVert = true, int iAutoCropPercent = 0x0, TFitMethod FitMethod = (TFitMethod)(0x0))/* overload */;
extern DELPHI_PACKAGE System::Types::TRect __fastcall AdjustRectToAspectRatio(const System::Types::TRect &InRect, int iDisplayWidth, int iDisplayHeight, int iImageWidth, int iImageHeight);
extern DELPHI_PACKAGE void __fastcall IEDrawComboListBoxItem(Vcl::Controls::TWinControl* TheControl, const System::Types::TRect &CanvasRect, const System::UnicodeString sText, Vcl::Controls::TImageList* AnImageList = (Vcl::Controls::TImageList*)(0x0), short iGlyph = (short)(0xffffffff));
extern DELPHI_PACKAGE double __fastcall GetNextZoomValue(double iCurrentZoom, bool bZoomIn, double iIdealZoom = 0.000000E+00);
extern DELPHI_PACKAGE Hyiedefs::TResampleFilter __fastcall QualityToZoomFilter(TIEQuality Quality);
extern DELPHI_PACKAGE System::Word __fastcall IECSwapWord(System::Word i, bool sc);
extern DELPHI_PACKAGE int __fastcall IECSwapDWord(int i, bool sc);
extern DELPHI_PACKAGE __int64 __fastcall IECSwapInt64(__int64 i, bool sc);
extern DELPHI_PACKAGE System::Word __fastcall IEStreamReadWord(System::Classes::TStream* Stream, bool bigEndian);
extern DELPHI_PACKAGE unsigned __fastcall IEStreamReadDWord(System::Classes::TStream* Stream, bool bigEndian);
extern DELPHI_PACKAGE __int64 __fastcall IEStreamReadInt64(System::Classes::TStream* Stream, bool bigEndian);
extern DELPHI_PACKAGE int __fastcall IEStreamWordAlign(System::Classes::TStream* Stream, bool &Aborting);
extern DELPHI_PACKAGE void __fastcall IEStreamWriteLn(System::Classes::TStream* Stream, System::AnsiString Text);
extern DELPHI_PACKAGE void __fastcall IEStreamWriteByte(System::Classes::TStream* Stream, System::Byte Value);
extern DELPHI_PACKAGE void __fastcall IEQuickSort(int ItemsCount, TIECompareFunction CompareFunction, TIESwapFunction SwapFunction);
extern DELPHI_PACKAGE System::UnicodeString __fastcall IEGetTempFileName(const System::UnicodeString Descriptor, const System::UnicodeString Directory);
extern DELPHI_PACKAGE System::UnicodeString __fastcall IEGetTempFileName2(void);
extern DELPHI_PACKAGE System::WideChar __fastcall IEGetDecimalSeparator(void);
extern DELPHI_PACKAGE void __fastcall IESetDecimalSeparator(System::WideChar c);
extern DELPHI_PACKAGE System::AnsiString __fastcall IEFloatToStrA(System::Extended Value);
extern DELPHI_PACKAGE System::UnicodeString __fastcall IEFloatToStrS(System::Extended Value);
extern DELPHI_PACKAGE System::WideString __fastcall IEFloatToStrW(System::Extended Value);
extern DELPHI_PACKAGE bool __fastcall IEIsSpace(char c);
extern DELPHI_PACKAGE System::AnsiString __fastcall IERemoveCtrlCharsA(const System::AnsiString text);
extern DELPHI_PACKAGE System::UnicodeString __fastcall IERemoveCtrlCharsS(const System::UnicodeString text);
extern DELPHI_PACKAGE System::WideString __fastcall IERemoveCtrlCharsW(const System::WideString text);
extern DELPHI_PACKAGE bool __fastcall IERGBColorsMatch(Hyiedefs::TRGB rgb1, Hyiedefs::TRGB rgb2, int Tolerance = 0x0);
extern DELPHI_PACKAGE System::UnicodeString __fastcall IERGB2StrS(Hyiedefs::TRGB c);
extern DELPHI_PACKAGE System::WideString __fastcall IERGB2StrW(Hyiedefs::TRGB c);
extern DELPHI_PACKAGE System::UnicodeString __fastcall IEBool2StrS(bool v);
extern DELPHI_PACKAGE System::WideString __fastcall IEBool2StrW(bool v);
extern DELPHI_PACKAGE Hyiedefs::TRGB __fastcall IEStr2RGBW(const System::WideString rgbstr);
extern DELPHI_PACKAGE Hyiedefs::TRGB __fastcall IEStr2RGBS(const System::UnicodeString rgbstr);
extern DELPHI_PACKAGE bool __fastcall IEStr2BoolS(const System::UnicodeString v);
extern DELPHI_PACKAGE bool __fastcall IEStr2BoolW(const System::WideString v);
extern DELPHI_PACKAGE bool __fastcall IEStr2BoolA(const System::AnsiString v);
extern DELPHI_PACKAGE System::Uitypes::TColor __fastcall IEStr2ColorDefS(const System::UnicodeString v, System::Uitypes::TColor ADefault);
extern DELPHI_PACKAGE HPALETTE __fastcall IECreateGrayPalette(void);
extern DELPHI_PACKAGE void __fastcall IESetGrayPalette(Vcl::Graphics::TBitmap* Bitmap);
extern DELPHI_PACKAGE bool __fastcall IEIsGrayPalette(Vcl::Graphics::TBitmap* Bitmap);
extern DELPHI_PACKAGE void __fastcall IECopyTBitmapPaletteToTIEBitmap(Vcl::Graphics::TBitmap* source, TIEBitmap* dest);
extern DELPHI_PACKAGE void __fastcall IERGB2YCbCr(Hyiedefs::TRGB rgb, int &Y, int &Cb, int &Cr);
extern DELPHI_PACKAGE void __fastcall IEYCbCr2RGB(Hyiedefs::TRGB &rgb, int Y, int Cb, int Cr);
extern DELPHI_PACKAGE void * __fastcall IESystemAlloc(__int64 ASize);
extern DELPHI_PACKAGE void __fastcall IESystemFree(void *P);
extern DELPHI_PACKAGE void * __fastcall IEAutoAlloc(__int64 ASize);
extern DELPHI_PACKAGE void __fastcall IEAutoFree(void *P);
extern DELPHI_PACKAGE void __fastcall IESilentGetMem(void *P, int Size);
extern DELPHI_PACKAGE System::PByte __fastcall IEFindXMPFromJpegTag(void * Buffer, int BufferLength);
extern DELPHI_PACKAGE bool __fastcall IELoadXMPFromJpegTag(void * Buffer, int BufferLength, System::TObject* params);
extern DELPHI_PACKAGE void __fastcall IESaveXMPToJpegTag(System::TObject* params, void * &Buffer, int &BufferLength);
extern DELPHI_PACKAGE void __fastcall IECreateOSXBackgroundPaper(Vcl::Graphics::TBitmap* bmp, int width, int height);
extern DELPHI_PACKAGE void __fastcall IECreateOSXBackgroundMetal(Vcl::Graphics::TBitmap* bmp, int width, int height);
extern DELPHI_PACKAGE System::Classes::TStringList* __fastcall IEEnumClipboardNames(void);
extern DELPHI_PACKAGE NativeUInt __fastcall IEGetClipboardDataByName(const System::UnicodeString name);
extern DELPHI_PACKAGE TIEDicomTagType __fastcall DicomStrToTag(System::AnsiString s);
extern DELPHI_PACKAGE TDicomStr __fastcall DicomTagToStr(TIEDicomTagType dt);
extern DELPHI_PACKAGE bool __fastcall IEOpenClipboard(void);
extern DELPHI_PACKAGE int __fastcall IEAlphaToOpacity(int Alpha);
extern DELPHI_PACKAGE int __fastcall IEOpacityToAlpha(int Opacity);
extern DELPHI_PACKAGE System::WideChar * __fastcall IEWStrCopy(System::WideChar * Dest, const System::WideChar * Source);
extern DELPHI_PACKAGE void __fastcall IERotatePoints(System::Types::TPoint *rpt, const int rpt_High, double angle, int CenterX, int CenterY);
extern DELPHI_PACKAGE void __fastcall IERotatePoint(int &px, int &py, double angle, int CenterX, int CenterY);
extern DELPHI_PACKAGE bool __fastcall IEISPointInPoly(int x, int y, System::Types::TPoint *poly, const int poly_High);
extern DELPHI_PACKAGE bool __fastcall IEISPointInPoly2(int x, int y, Hyiedefs::PPointArray PolyPoints, int PolyPointsCount, int ToSubX, int ToSubY, int ToAddX, int ToAddY, double ToMulX, double ToMulY);
extern DELPHI_PACKAGE bool __fastcall IEIsLeftMouseButtonPressed(void);
extern DELPHI_PACKAGE System::AnsiString __fastcall IERGBToStr(Hyiedefs::TRGB rgb);
extern DELPHI_PACKAGE TIEURLType __fastcall IEGetURLTypeW(const System::WideString URL);
extern DELPHI_PACKAGE TIEURLType __fastcall IEGetURLTypeA(const System::AnsiString URL);
extern DELPHI_PACKAGE double __fastcall IEDistPoint2Ellipse(int x, int y, int x1, int y1, int x2, int y2, bool filled, int penWidth);
extern DELPHI_PACKAGE double __fastcall IEDist2Box(int x, int y, int x1, int y1, int x2, int y2, bool filled, int penWidth);
extern DELPHI_PACKAGE System::AnsiString __fastcall IETrim(const System::AnsiString v);
extern DELPHI_PACKAGE System::UnicodeString __fastcall IEExtractFileExtS(const System::UnicodeString FileName, bool includeDot = true);
extern DELPHI_PACKAGE System::AnsiString __fastcall IEExtractFileExtA(const System::AnsiString FileName, bool includeDot = true);
extern DELPHI_PACKAGE System::WideString __fastcall IEExtractFileExtW(const System::WideString FileName, bool includeDot = true);
extern DELPHI_PACKAGE bool __fastcall IEFilenameInExtensions(const System::UnicodeString sFileName, const System::UnicodeString sExtensions);
extern DELPHI_PACKAGE bool __fastcall IEFileExtInExtensions(System::UnicodeString sFileExt, const System::UnicodeString sExtensions);
extern DELPHI_PACKAGE System::AnsiString __fastcall IEUpperCase(const System::AnsiString v);
extern DELPHI_PACKAGE System::AnsiString __fastcall IELowerCase(const System::AnsiString v);
extern DELPHI_PACKAGE System::AnsiString __fastcall IEIntToStr(int v);
extern DELPHI_PACKAGE System::AnsiString __fastcall IEIntToFormattedStr(int v);
extern DELPHI_PACKAGE System::AnsiString __fastcall IEBytesToStr(int v, int iThreshold = 0x19000);
extern DELPHI_PACKAGE System::AnsiString __fastcall IEBytesToStr2(__int64 iBytes);
extern DELPHI_PACKAGE int __fastcall IEStrToIntDef(const System::AnsiString s, int def);
extern DELPHI_PACKAGE System::AnsiString __fastcall IECopy(System::AnsiString S, int Index, int Count);
extern DELPHI_PACKAGE System::AnsiString __fastcall IEFloatToStrFA(System::Extended Value, System::Sysutils::TFloatFormat Format, int Precision, int Digits);
extern DELPHI_PACKAGE System::UnicodeString __fastcall IEFloatToStrFS(System::Extended Value, System::Sysutils::TFloatFormat Format, int Precision, int Digits);
extern DELPHI_PACKAGE System::AnsiString __fastcall IEIntToHex(int Value, int Digits);
extern DELPHI_PACKAGE int __fastcall IEPos(System::AnsiString Substr, System::AnsiString S);
extern DELPHI_PACKAGE System::AnsiString __fastcall IEExtractFilePathA(const System::AnsiString FileName);
extern DELPHI_PACKAGE System::WideString __fastcall IEExtractFilePathW(const System::WideString FileName);
extern DELPHI_PACKAGE System::WideString __fastcall IEExtractFileNameW(const System::WideString FileName);
extern DELPHI_PACKAGE char * __fastcall IEStrDup(char * s);
extern DELPHI_PACKAGE System::WideChar * __fastcall IEStrDupW(System::WideChar * s);
extern DELPHI_PACKAGE bool __fastcall IEFileExists(const System::UnicodeString FileName);
extern DELPHI_PACKAGE bool __fastcall IEFileExistsW(const System::WideString FileName);
extern DELPHI_PACKAGE void __fastcall IEDrawGrayedOut(Vcl::Graphics::TCanvas* Canvas, int XDst, int YDst, int WidthDst, int HeightDst, int SX1, int SY1, int SX2, int SY2);
extern DELPHI_PACKAGE __int64 __fastcall IECopyFrom(System::Classes::TStream* Dest, System::Classes::TStream* Source, __int64 Count);
extern DELPHI_PACKAGE void __fastcall IEDecimalToFraction(double value, int &numerator, int &denominator, double accuracy = 5.000000E-09);
extern DELPHI_PACKAGE void __fastcall IECopyTList(System::Classes::TList* source, System::Classes::TList* dest);
extern DELPHI_PACKAGE NativeInt __fastcall IESendMessageTimeout(HWND hWnd, unsigned Msg, NativeUInt wParam, NativeInt lParam, unsigned fuFlags, unsigned uTimeout, void * lpdwResult);
extern DELPHI_PACKAGE int __fastcall IEGetCoresCount(void);
extern DELPHI_PACKAGE bool __fastcall IEIsWindowsVistaOrNewer(void);
extern DELPHI_PACKAGE Vcl::Graphics::TFont* __fastcall IEGetDefaultDialogFont(void);
extern DELPHI_PACKAGE int __fastcall IETextWidthW(Vcl::Graphics::TCanvas* Canvas, const System::WideString Text);
extern DELPHI_PACKAGE int __fastcall IETextHeightW(Vcl::Graphics::TCanvas* Canvas, const System::WideString Text);
extern DELPHI_PACKAGE System::WideString __fastcall IETruncateStr(System::WideString sCaption, TIEMTruncSide TruncSide, Vcl::Graphics::TCanvas* ACanvas, int iMaxWidth);
extern DELPHI_PACKAGE System::TDateTime __fastcall IEFileTimeToDateTime(const _FILETIME &ft);
extern DELPHI_PACKAGE __int64 __fastcall IELargeFileSize(unsigned nFileSizeHigh, unsigned nFileSizeLow);
extern DELPHI_PACKAGE bool __fastcall IEGetFileDetails(const System::UnicodeString sFilename, /* out */ __int64 &iFileSizeBytes, /* out */ System::TDateTime &dtCreateDate, /* out */ System::TDateTime &dtEditDate);
extern DELPHI_PACKAGE bool __fastcall IEFileSetDate(const System::UnicodeString sFilename, System::TDateTime DateTime);
extern DELPHI_PACKAGE System::UnicodeString __fastcall IEFloatToFormatString(System::Extended Value, int iDecimalCount, bool bStripZeros);
extern DELPHI_PACKAGE Hyiedefs::TIERectangle __fastcall IERectangle(int x, int y, int width, int height)/* overload */;
extern DELPHI_PACKAGE Hyiedefs::TIERectangle __fastcall IERectangle(const System::Types::TRect &Rect)/* overload */;
extern DELPHI_PACKAGE bool __fastcall IEIsPrime(int x);
extern DELPHI_PACKAGE int __fastcall IENextPrime(int x);
extern DELPHI_PACKAGE unsigned __fastcall IE_ELFHash(const System::WideString str, unsigned bucketCount);
extern DELPHI_PACKAGE unsigned __fastcall IE_RSHash(const System::WideString str, unsigned bucketCount);
extern DELPHI_PACKAGE unsigned __fastcall IE_JSHash(const System::WideString str, unsigned bucketCount);
extern DELPHI_PACKAGE Hyiedefs::TIE2DPoint __fastcall IE2DPoint(double X, double Y);
extern DELPHI_PACKAGE Hyiedefs::TRGB __fastcall IEVisionBGR8ToTRGB(Ievision::TIEVisionBGR8 visionBGR8);
extern DELPHI_PACKAGE Ievision::TIEVisionBGR8 __fastcall IETRGBToVisionBGR8(Hyiedefs::TRGB rgb);
extern DELPHI_PACKAGE bool __fastcall IEDrawGradient(const System::Types::TRect &R, HDC DC, System::Uitypes::TColor ColorStart, System::Uitypes::TColor ColorStop, bool bVertical);
extern DELPHI_PACKAGE unsigned __fastcall IESetupTimeout(void);
extern DELPHI_PACKAGE bool __fastcall IEIsTimeoutExpired(unsigned startTime, unsigned timeout);
extern DELPHI_PACKAGE void __fastcall IEInitialize_gestures(void);
extern DELPHI_PACKAGE void __fastcall IEFinalize_gestures(void);
extern DELPHI_PACKAGE bool __fastcall IEHasGestures(void);
extern DELPHI_PACKAGE __int64 __fastcall IEStreamFindString(System::Classes::TStream* Stream, System::AnsiString Text, __int64 StopAtPos);
extern DELPHI_PACKAGE System::AnsiString __fastcall IEGetDosOutput(System::AnsiString CommandLine, System::AnsiString Work = "C:\\");
extern DELPHI_PACKAGE double __fastcall IEGPSConvertDMSToDegDec(double degrees, double minutes, double seconds, System::AnsiString ref);
extern DELPHI_PACKAGE void __fastcall IEGPSConvertDegDecToDMS(System::AnsiString dir, double value, double &degrees, double &minutes, double &seconds, System::AnsiString &ref);
extern DELPHI_PACKAGE System::Word __fastcall IETIFFCalcTagSize(int tagType);
extern DELPHI_PACKAGE int __fastcall IEFindNearestColor(Hyiedefs::TRGB color, Hyiedefs::TIEArrayOfTRGB palette, int colorCount);
extern DELPHI_PACKAGE void __fastcall IESwap(int &a, int &b)/* overload */;
extern DELPHI_PACKAGE void __fastcall IESwap(double &a, double &b)/* overload */;
extern DELPHI_PACKAGE void __fastcall IESwap(bool &a, bool &b)/* overload */;
extern DELPHI_PACKAGE void __fastcall IESwap(TIEBitmap* &a, TIEBitmap* &b)/* overload */;
extern DELPHI_PACKAGE void __fastcall IESwap(Hyiedefs::TIELayerMagnification &a, Hyiedefs::TIELayerMagnification &b)/* overload */;
extern DELPHI_PACKAGE void __fastcall IESwap(TIERenderOperation &a, TIERenderOperation &b)/* overload */;
extern DELPHI_PACKAGE void __fastcall IESwap(void * &a, void * &b)/* overload */;
extern DELPHI_PACKAGE void __fastcall IESwap(Hyiedefs::TResampleFilter &a, Hyiedefs::TResampleFilter &b)/* overload */;
extern DELPHI_PACKAGE void __fastcall IESwap(System::AnsiString &a, System::AnsiString &b)/* overload */;
extern DELPHI_PACKAGE void __fastcall IESwap(GUID &a, GUID &b)/* overload */;
extern DELPHI_PACKAGE void __fastcall IESwap(Hyiedefs::TIEArrayOfTRGB &a, Hyiedefs::TIEArrayOfTRGB &b)/* overload */;
extern DELPHI_PACKAGE void __fastcall IEInitializeImageEn(void);
extern DELPHI_PACKAGE void __fastcall IEFinalizeImageEn(void);
extern DELPHI_PACKAGE void __fastcall IEInitialize_hyieutils(void);
extern DELPHI_PACKAGE void __fastcall IEFinalize_hyieutils(void);
}	/* namespace Hyieutils */
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_HYIEUTILS)
using namespace Hyieutils;
#endif
#pragma pack(pop)
#pragma option pop

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