pngimage.hpp

Iocomp Ultra Pack v3.0.2 Sources.For.Delphi 数据显示编程插件,可用于工业控制

#pragma option push -b-
enum TPNGTransparencyMode { ptmNone, ptmBit, ptmPartial };
#pragma option pop

typedef unsigned *pCardinal;

struct TRGBPixel;
typedef TRGBPixel *pRGBPixel;

#pragma pack(push, 1)
struct TRGBPixel
{
	Byte B;
	Byte G;
	Byte R;
} ;
#pragma pack(pop)

typedef Byte TByteArray[65536];

typedef Byte *pByteArray;

typedef void *TPointerArray[65536];

typedef void * *pPointerArray;

class DELPHICLASS TPNGPointerList;
class DELPHICLASS TPNGObject;
#pragma option push -b-
enum TFilter { pfNone, pfSub, pfUp, pfAverage, pfPaeth };
#pragma option pop

typedef Set<TFilter, pfNone, pfPaeth>  TFilters;

typedef Shortint TCompressionLevel;

#pragma option push -b-
enum TInterlaceMethod { imNone, imAdam7 };
#pragma option pop

class DELPHICLASS TPNGList;
class PASCALIMPLEMENTATION TPNGPointerList : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	TPNGObject* fOwner;
	unsigned fCount;
	void * *fMemory;
	void * __fastcall GetItem(unsigned Index);
	void __fastcall SetItem(unsigned Index, const void * Value);
	
protected:
	virtual void * __fastcall Remove(void * Value);
	void __fastcall Insert(void * Value, unsigned Position);
	void __fastcall Add(void * Value);
	__property void * Item[unsigned Index] = {read=GetItem, write=SetItem};
	void __fastcall SetSize(const unsigned Size);
	__property TPNGObject* Owner = {read=fOwner};
	
public:
	__property unsigned Count = {read=fCount, write=SetSize, nodefault};
	__fastcall TPNGPointerList(TPNGObject* AOwner);
	__fastcall virtual ~TPNGPointerList(void);
};


class DELPHICLASS TChunk;
typedef TMetaClass*TChunkClass;

class PASCALIMPLEMENTATION TPNGList : public TPNGPointerList 
{
	typedef TPNGPointerList inherited;
	
private:
	HIDESBASE TChunk* __fastcall GetItem(unsigned Index);
	
public:
	void __fastcall RemoveChunk(TChunk* Chunk)/* overload */;
	HIDESBASE TChunk* __fastcall Add(TMetaClass* ChunkClass);
	TChunk* __fastcall ItemFromClass(TMetaClass* ChunkClass);
	__property TChunk* Item[unsigned Index] = {read=GetItem};
public:
	#pragma option push -w-inl
	/* TPNGPointerList.Create */ inline __fastcall TPNGList(TPNGObject* AOwner) : TPNGPointerList(AOwner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TPNGPointerList.Destroy */ inline __fastcall virtual ~TPNGList(void) { }
	#pragma option pop
	
};


class DELPHICLASS TChunkIHDR;
class PASCALIMPLEMENTATION TPNGObject : public Graphics::TGraphic 
{
	typedef Graphics::TGraphic inherited;
	
protected:
	Byte GammaTable[256];
	Byte InverseGamma[256];
	void __fastcall InitializeGamma(void);
	
private:
	HPALETTE TempPalette;
	TFilters fFilters;
	TCompressionLevel fCompressionLevel;
	unsigned fMaxIdatSize;
	TInterlaceMethod fInterlaceMethod;
	TPNGList* fChunkList;
	void __fastcall ClearChunks(void);
	bool __fastcall HeaderPresent(void);
	void __fastcall GetPixelInfo(unsigned &LineSize, unsigned &Offset);
	void __fastcall SetMaxIdatSize(const unsigned Value);
	pByteArray __fastcall GetAlphaScanline(const int LineIndex);
	void * __fastcall GetScanline(const int LineIndex);
	TPNGTransparencyMode __fastcall GetTransparencyMode(void);
	Graphics::TColor __fastcall GetTransparentColor(void);
	void __fastcall SetTransparentColor(const Graphics::TColor Value);
	
protected:
	virtual HPALETTE __fastcall GetPalette(void);
	virtual int __fastcall GetWidth(void);
	virtual int __fastcall GetHeight(void);
	virtual void __fastcall SetWidth(int Value);
	virtual void __fastcall SetHeight(int Value);
	void __fastcall AssignPNG(TPNGObject* Source);
	virtual bool __fastcall GetEmpty(void);
	TChunkIHDR* __fastcall GetHeader(void);
	void __fastcall DrawPartialTrans(HDC DC, const Types::TRect &Rect);
	virtual bool __fastcall GetTransparent(void);
	virtual Graphics::TColor __fastcall GetPixels(const int X, const int Y);
	virtual void __fastcall SetPixels(const int X, const int Y, const Graphics::TColor Value);
	
public:
	void __fastcall CreateAlpha(void);
	void __fastcall RemoveTransparency(void);
	__property Graphics::TColor TransparentColor = {read=GetTransparentColor, write=SetTransparentColor, nodefault};
	void __fastcall AddtEXt(const AnsiString Keyword, const AnsiString Text);
	void __fastcall AddzTXt(const AnsiString Keyword, const AnsiString Text);
	virtual void __fastcall SaveToClipboardFormat(Word &AFormat, unsigned &AData, HPALETTE &APalette);
	virtual void __fastcall LoadFromClipboardFormat(Word AFormat, unsigned AData, HPALETTE APalette);
	void __fastcall RaiseError(TMetaClass* ExceptionClass, AnsiString Text);
	__property void * Scanline[int Index] = {read=GetScanline};
	__property pByteArray AlphaScanline[int Index] = {read=GetAlphaScanline};
	__property TChunkIHDR* Header = {read=GetHeader};
	__property TPNGTransparencyMode TransparencyMode = {read=GetTransparencyMode, nodefault};
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
	void __fastcall AssignHandle(HBITMAP Handle, bool Transparent, unsigned TransparentColor);
	virtual void __fastcall Draw(Graphics::TCanvas* ACanvas, const Types::TRect &Rect);
	__property int Width = {read=GetWidth, nodefault};
	__property int Height = {read=GetHeight, nodefault};
	__property TInterlaceMethod InterlaceMethod = {read=fInterlaceMethod, write=fInterlaceMethod, nodefault};
	__property TFilters Filters = {read=fFilters, write=fFilters, nodefault};
	__property unsigned MaxIdatSize = {read=fMaxIdatSize, write=SetMaxIdatSize, nodefault};
	__property bool Empty = {read=GetEmpty, nodefault};
	__property TCompressionLevel CompressionLevel = {read=fCompressionLevel, write=fCompressionLevel, nodefault};
	__property TPNGList* Chunks = {read=fChunkList};
	__fastcall virtual TPNGObject(void);
	__fastcall virtual ~TPNGObject(void);
	virtual void __fastcall LoadFromStream(Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(Classes::TStream* Stream);
	void __fastcall LoadFromResourceName(unsigned Instance, const AnsiString Name);
	void __fastcall LoadFromResourceID(unsigned Instance, int ResID);
	__property Graphics::TColor Pixels[int X][int Y] = {read=GetPixels, write=SetPixels};
};



typedef char TChunkName[4];

class PASCALIMPLEMENTATION TChunk : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	void *fData;
	unsigned fDataSize;
	TPNGObject* fOwner;
	char fName[4];
	TChunkIHDR* __fastcall GetHeader(void);
	int __fastcall GetIndex(void);
	/* virtual class method */ virtual AnsiString __fastcall GetName(TMetaClass* vmt);
	AnsiString __fastcall GetChunkName();
	
public:
	__property int Index = {read=GetIndex, nodefault};
	__property TChunkIHDR* Header = {read=GetHeader};
	void __fastcall ResizeData(const unsigned NewSize);
	__property void * Data = {read=fData};
	__property unsigned DataSize = {read=fDataSize, nodefault};
	virtual void __fastcall Assign(TChunk* Source);
	__property TPNGObject* Owner = {read=fOwner};
	__fastcall virtual TChunk(TPNGObject* Owner);
	__fastcall virtual ~TChunk(void);
	__property AnsiString Name = {read=GetChunkName};
	virtual bool __fastcall LoadFromStream(Classes::TStream* Stream, const char * ChunkName, int Size);
	bool __fastcall SaveData(Classes::TStream* Stream);
	virtual bool __fastcall SaveToStream(Classes::TStream* Stream);
};


class DELPHICLASS TChunkIEND;
class PASCALIMPLEMENTATION TChunkIEND : public TChunk 
{
	typedef TChunk inherited;
	
public:
	#pragma option push -w-inl
	/* TChunk.Create */ inline __fastcall virtual TChunkIEND(TPNGObject* Owner) : TChunk(Owner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TChunk.Destroy */ inline __fastcall virtual ~TChunkIEND(void) { }
	#pragma option pop
	
};


struct TIHDRData;
typedef TIHDRData *pIHDRData;

#pragma pack(push, 1)
struct TIHDRData
{
	unsigned Width;
	unsigned Height;
	Byte BitDepth;
	Byte ColorType;
	Byte CompressionMethod;
	Byte FilterMethod;
	Byte InterlaceMethod;
} ;
#pragma pack(pop)

class PASCALIMPLEMENTATION TChunkIHDR : public TChunk 
{
	typedef TChunk inherited;
	
private:
	HBITMAP ImageHandle;
	HDC ImageDC;
	bool HasPalette;
	#pragma pack(push, 1)
	TMAXBITMAPINFO BitmapInfo;
	#pragma pack(pop)
	
	int BytesPerRow;
	void *ImageData;
	void *ImageAlpha;
	#pragma pack(push, 1)
	TIHDRData IHDRData;
	#pragma pack(pop)
	
	
protected:
	void __fastcall PrepareImageData(void);
	void __fastcall FreeImageData(void);
	
public:
	__property unsigned Width = {read=IHDRData.Width, write=IHDRData.Width, nodefault};
	__property unsigned Height = {read=IHDRData.Height, write=IHDRData.Height, nodefault};
	__property Byte BitDepth = {read=IHDRData.BitDepth, write=IHDRData.BitDepth, nodefault};
	__property Byte ColorType = {read=IHDRData.ColorType, write=IHDRData.ColorType, nodefault};
	__property Byte CompressionMethod = {read=IHDRData.CompressionMethod, write=IHDRData.CompressionMethod, nodefault};
	__property Byte FilterMethod = {read=IHDRData.FilterMethod, write=IHDRData.FilterMethod, nodefault};
	__property Byte InterlaceMethod = {read=IHDRData.InterlaceMethod, write=IHDRData.InterlaceMethod, nodefault};
	virtual bool __fastcall LoadFromStream(Classes::TStream* Stream, const char * ChunkName, int Size);
	virtual bool __fastcall SaveToStream(Classes::TStream* Stream);
	__fastcall virtual TChunkIHDR(TPNGObject* Owner);
	__fastcall virtual ~TChunkIHDR(void);
	virtual void __fastcall Assign(TChunk* Source);