frxpngimage.hpp

这个是功能强大的报表软件

	unsigned fDataSize;
	TPNGObject* fOwner;
	char fName[4];
	TChunkIHDR* __fastcall GetHeader(void);
	int __fastcall GetIndex(void);
	#pragma option push -w-inl
	/* virtual class method */ virtual AnsiString __fastcall GetName() { return GetName(__classid(TChunk)); }
	#pragma option pop
	/*         class method */ static 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, char const * 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
{
	
public:
	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;
	HPALETTE ImagePalette;
	bool HasPalette;
	#pragma pack(push,1)
	TMAXBITMAPINFO BitmapInfo;
	#pragma pack(pop)
	void *ExtraImageData;
	void *ImageData;
	void *ImageAlpha;
	#pragma pack(push,1)
	TIHDRData IHDRData;
	#pragma pack(pop)
	
protected:
	int BytesPerRow;
	HPALETTE __fastcall CreateGrayscalePalette(int Bitdepth);
	void __fastcall PaletteToDIB(HPALETTE Palette);
	void __fastcall PrepareImageData(void);
	void __fastcall FreeImageData(void);
	
public:
	__property HBITMAP ImageHandleValue = {read=ImageHandle, nodefault};
	__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, char const * 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);
};


#pragma option push -b-
enum TUnitType { utUnknown, utMeter };
#pragma option pop

typedef TUnitType *pUnitType;

class PASCALIMPLEMENTATION TChunkpHYs : public TChunk 
{
	typedef TChunk inherited;
	
private:
	unsigned fPPUnitX;
	unsigned fPPUnitY;
	TUnitType fUnit;
	
public:
	__property unsigned PPUnitX = {read=fPPUnitX, write=fPPUnitX, nodefault};
	__property unsigned PPUnitY = {read=fPPUnitY, write=fPPUnitY, nodefault};
	__property TUnitType UnitType = {read=fUnit, write=fUnit, nodefault};
	virtual bool __fastcall LoadFromStream(Classes::TStream* Stream, char const * ChunkName, int Size);
	virtual bool __fastcall SaveToStream(Classes::TStream* Stream);
	virtual void __fastcall Assign(TChunk* Source);
public:
	#pragma option push -w-inl
	/* TChunk.Create */ inline __fastcall virtual TChunkpHYs(TPNGObject* Owner) : TChunk(Owner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TChunk.Destroy */ inline __fastcall virtual ~TChunkpHYs(void) { }
	#pragma option pop
	
};


class DELPHICLASS TChunkgAMA;
class PASCALIMPLEMENTATION TChunkgAMA : public TChunk 
{
	typedef TChunk inherited;
	
private:
	unsigned __fastcall GetValue(void);
	void __fastcall SetValue(const unsigned Value);
	
public:
	__property unsigned Gamma = {read=GetValue, write=SetValue, nodefault};
	virtual bool __fastcall LoadFromStream(Classes::TStream* Stream, char const * ChunkName, int Size);
	__fastcall virtual TChunkgAMA(TPNGObject* Owner);
	virtual void __fastcall Assign(TChunk* Source);
public:
	#pragma option push -w-inl
	/* TChunk.Destroy */ inline __fastcall virtual ~TChunkgAMA(void) { }
	#pragma option pop
	
};


#pragma pack(push,1)
struct TZStreamRec2
{
	
public:
	#pragma pack(push,1)
	Frxzlib::TZStreamRec ZLIB;
	#pragma pack(pop)
	void *Data;
	Classes::TStream* fStream;
} ;
#pragma pack(pop)

class DELPHICLASS TChunkPLTE;
class PASCALIMPLEMENTATION TChunkPLTE : public TChunk 
{
	typedef TChunk inherited;
	
protected:
	int fCount;
	
private:
	tagRGBQUAD __fastcall GetPaletteItem(Byte Index);
	
public:
	__property tagRGBQUAD Item[Byte Index] = {read=GetPaletteItem};
	__property int Count = {read=fCount, nodefault};
	virtual bool __fastcall LoadFromStream(Classes::TStream* Stream, char const * ChunkName, int Size);
	virtual bool __fastcall SaveToStream(Classes::TStream* Stream);
	virtual void __fastcall Assign(TChunk* Source);
public:
	#pragma option push -w-inl
	/* TChunk.Create */ inline __fastcall virtual TChunkPLTE(TPNGObject* Owner) : TChunk(Owner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TChunk.Destroy */ inline __fastcall virtual ~TChunkPLTE(void) { }
	#pragma option pop
	
};


class DELPHICLASS TChunktRNS;
class PASCALIMPLEMENTATION TChunktRNS : public TChunk 
{
	typedef TChunk inherited;
	
private:
	bool fBitTransparency;
	unsigned __fastcall GetTransparentColor(void);
	void __fastcall SetTransparentColor(const unsigned Value);
	
public:
	Byte PaletteValues[256];
	__property bool BitTransparency = {read=fBitTransparency, nodefault};
	__property unsigned TransparentColor = {read=GetTransparentColor, write=SetTransparentColor, nodefault};
	virtual bool __fastcall LoadFromStream(Classes::TStream* Stream, char const * ChunkName, int Size);
	virtual bool __fastcall SaveToStream(Classes::TStream* Stream);
	virtual void __fastcall Assign(TChunk* Source);
public:
	#pragma option push -w-inl
	/* TChunk.Create */ inline __fastcall virtual TChunktRNS(TPNGObject* Owner) : TChunk(Owner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TChunk.Destroy */ inline __fastcall virtual ~TChunktRNS(void) { }
	#pragma option pop
	
};


class DELPHICLASS TChunkIDAT;
class PASCALIMPLEMENTATION TChunkIDAT : public TChunk 
{
	typedef TChunk inherited;
	
private:
	TChunkIHDR* Header;
	int ImageWidth;
	int ImageHeight;
	unsigned Row_Bytes;
	unsigned Offset;
	Byte *Encode_Buffer[6];
	Byte *Row_Buffer[2];
	bool RowUsed;
	int EndPos;
	void __fastcall FilterRow(void);
	Byte __fastcall FilterToEncode(void);
	int __fastcall IDATZlibRead(TZStreamRec2 &ZLIBStream, void * Buffer, int Count, int &EndPos, unsigned &crcfile);
	void __fastcall IDATZlibWrite(TZStreamRec2 &ZLIBStream, void * Buffer, const unsigned Length);
	void __fastcall FinishIDATZlib(TZStreamRec2 &ZLIBStream);
	void __fastcall PreparePalette(void);
	
protected:
	void __fastcall DecodeInterlacedAdam7(Classes::TStream* Stream, TZStreamRec2 &ZLIBStream, const int Size, unsigned &crcfile);
	void __fastcall DecodeNonInterlaced(Classes::TStream* Stream, TZStreamRec2 &ZLIBStream, const int Size, unsigned &crcfile);
	void __fastcall EncodeNonInterlaced(Classes::TStream* Stream, TZStreamRec2 &ZLIBStream);
	void __fastcall EncodeInterlacedAdam7(Classes::TStream* Stream, TZStreamRec2 &ZLIBStream);
	void __fastcall CopyNonInterlacedRGB8(char * Src, char * Dest, char * Trans, char * Extra);
	void __fastcall CopyNonInterlacedRGB16(char * Src, char * Dest, char * Trans, char * Extra);
	void __fastcall CopyNonInterlacedPalette148(char * Src, char * Dest, char * Trans, char * Extra);
	void __fastcall CopyNonInterlacedPalette2(char * Src, char * Dest, char * Trans, char * Extra);
	void __fastcall CopyNonInterlacedGray2(char * Src, char * Dest, char * Trans, char * Extra);
	void __fastcall CopyNonInterlacedGrayscale16(char * Src, char * Dest, char * Trans, char * Extra);
	void __fastcall CopyNonInterlacedRGBAlpha8(char * Src, char * Dest, char * Trans, char * Extra);
	void __fastcall CopyNonInterlacedRGBAlpha16(char * Src, char * Dest, char * Trans, char * Extra);
	void __fastcall CopyNonInterlacedGrayscaleAlpha8(char * Src, char * Dest, char * Trans, char * Extra);
	void __fastcall CopyNonInterlacedGrayscaleAlpha16(char * Src, char * Dest, char * Trans, char * Extra);
	void __fastcall CopyInterlacedRGB8(const Byte Pass, char * Src, char * Dest, char * Trans, char * Extra);
	void __fastcall CopyInterlacedRGB16(const Byte Pass, char * Src, char * Dest, char * Trans, char * Extra);
	void __fastcall CopyInterlacedPalette148(const Byte Pass, char * Src, char * Dest, char * Trans, char * Extra);
	void __fastcall CopyInterlacedPalette2(const Byte Pass, char * Src, char * Dest, char * Trans, char * Extra);
	void __fastcall CopyInterlacedGray2(const Byte Pass, char * Src, char * Dest, char * Trans, char * Extra);
	void __fastca