pngimage.hpp

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

};


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, const char * 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
{
	Pngzlib::TZStreamRec ZLIB;
	void *Data;
	Classes::TStream* fStream;
} ;
#pragma pack(pop)

class DELPHICLASS TChunkPLTE;
class PASCALIMPLEMENTATION TChunkPLTE : public TChunk 
{
	typedef TChunk inherited;
	
private:
	int fCount;
	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, const char * 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, const char * 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);
	void __fastcall CopyNonInterlacedRGB16(char * Src, char * Dest, char * Trans);
	void __fastcall CopyNonInterlacedPalette148(char * Src, char * Dest, char * Trans);
	void __fastcall CopyNonInterlacedPalette2(char * Src, char * Dest, char * Trans);
	void __fastcall CopyNonInterlacedGray2(char * Src, char * Dest, char * Trans);
	void __fastcall CopyNonInterlacedGrayscale16(char * Src, char * Dest, char * Trans);
	void __fastcall CopyNonInterlacedRGBAlpha8(char * Src, char * Dest, char * Trans);
	void __fastcall CopyNonInterlacedRGBAlpha16(char * Src, char * Dest, char * Trans);
	void __fastcall CopyNonInterlacedGrayscaleAlpha8(char * Src, char * Dest, char * Trans);
	void __fastcall CopyNonInterlacedGrayscaleAlpha16(char * Src, char * Dest, char * Trans);
	void __fastcall CopyInterlacedRGB8(const Byte Pass, char * Src, char * Dest, char * Trans);
	void __fastcall CopyInterlacedRGB16(const Byte Pass, char * Src, char * Dest, char * Trans);
	void __fastcall CopyInterlacedPalette148(const Byte Pass, char * Src, char * Dest, char * Trans);
	void __fastcall CopyInterlacedPalette2(const Byte Pass, char * Src, char * Dest, char * Trans);
	void __fastcall CopyInterlacedGray2(const Byte Pass, char * Src, char * Dest, char * Trans);
	void __fastcall CopyInterlacedGrayscale16(const Byte Pass, char * Src, char * Dest, char * Trans);
	void __fastcall CopyInterlacedRGBAlpha8(const Byte Pass, char * Src, char * Dest, char * Trans);
	void __fastcall CopyInterlacedRGBAlpha16(const Byte Pass, char * Src, char * Dest, char * Trans);
	void __fastcall CopyInterlacedGrayscaleAlpha8(const Byte Pass, char * Src, char * Dest, char * Trans);
	void __fastcall CopyInterlacedGrayscaleAlpha16(const Byte Pass, char * Src, char * Dest, char * Trans);
	void __fastcall EncodeNonInterlacedRGB8(char * Src, char * Dest, char * Trans);
	void __fastcall EncodeNonInterlacedRGB16(char * Src, char * Dest, char * Trans);
	void __fastcall EncodeNonInterlacedGrayscale16(char * Src, char * Dest, char * Trans);
	void __fastcall EncodeNonInterlacedPalette148(char * Src, char * Dest, char * Trans);
	void __fastcall EncodeNonInterlacedRGBAlpha8(char * Src, char * Dest, char * Trans);
	void __fastcall EncodeNonInterlacedRGBAlpha16(char * Src, char * Dest, char * Trans);
	void __fastcall EncodeNonInterlacedGrayscaleAlpha8(char * Src, char * Dest, char * Trans);
	void __fastcall EncodeNonInterlacedGrayscaleAlpha16(char * Src, char * Dest, char * Trans);
	void __fastcall EncodeInterlacedRGB8(const Byte Pass, char * Src, char * Dest, char * Trans);
	void __fastcall EncodeInterlacedRGB16(const Byte Pass, char * Src, char * Dest, char * Trans);
	void __fastcall EncodeInterlacedPalette148(const Byte Pass, char * Src, char * Dest, char * Trans);
	void __fastcall EncodeInterlacedGrayscale16(const Byte Pass, char * Src, char * Dest, char * Trans);
	void __fastcall EncodeInterlacedRGBAlpha8(const Byte Pass, char * Src, char * Dest, char * Trans);
	void __fastcall EncodeInterlacedRGBAlpha16(const Byte Pass, char * Src, char * Dest, char * Trans);
	void __fastcall EncodeInterlacedGrayscaleAlpha8(const Byte Pass, char * Src, char * Dest, char * Trans);
	void __fastcall EncodeInterlacedGrayscaleAlpha16(const Byte Pass, char * Src, char * Dest, char * Trans);
	
public:
	virtual bool __fastcall LoadFromStream(Classes::TStream* Stream, const char * ChunkName, int Size);
	virtual bool __fastcall SaveToStream(Classes::TStream* Stream);
public:
	#pragma option push -w-inl
	/* TChunk.Create */ inline __fastcall virtual TChunkIDAT(TPNGObject* Owner) : TChunk(Owner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TChunk.Destroy */ inline __fastcall virtual ~TChunkIDAT(void) { }
	#pragma option pop
	
};


class DELPHICLASS TChunktIME;
class PASCALIMPLEMENTATION TChunktIME : public TChunk 
{
	typedef TChunk inherited;
	
private:
	Word fYear;
	Byte fMonth;
	Byte fDay;
	Byte fHour;
	Byte fMinute;
	Byte fSecond;
	
public:
	__property Word Year = {read=fYear, write=fYear, nodefault};
	__property Byte Month = {read=fMonth, write=fMonth, nodefault};
	__property Byte Day = {read=fDay, write=fDay, nodefault};
	__property Byte Hour = {read=fHour, write=fHour, nodefault};
	__property Byte Minute = {read=fMinute, write=fMinute, nodefault};
	__property Byte Second = {read=fSecond, write=fSecond, nodefault};
	virtual bool __fastcall LoadFromStream(Classes::TStream* Stream, const char * ChunkName, int Size);
	virtual bool __fastcall SaveToStream(Classes::TStream* Stream);
public:
	#pragma option push -w-inl
	/* TChunk.Create */ inline __fastcall virtual TChunktIME(TPNGObject* Owner) : TChunk(Owner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TChunk.Destroy */ inline __fastcall virtual ~TChunktIME(void) { }
	#pragma option pop
	
};


class DELPHICLASS TChunktEXt;
class PASCALIMPLEMENTATION TChunktEXt : public TChunk 
{
	typedef TChunk inherited;
	
private:
	AnsiString fKeyword;
	AnsiString fText;
	
public:
	__property AnsiString Keyword = {read=fKeyword, write=fKeyword};
	__property AnsiString Text = {read=fText, write=fText};
	virtual bool __fastcall LoadFromStream(Classes::TStream* Stream, const char * 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 TChunktEXt(TPNGObject* Owner) : TChunk(Owner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TChunk.Destroy */ inline __fastcall virtual ~TChunktEXt(void) { }
	#pragma option pop
	
};


class DELPHICLASS TChunkzTXt;
class PASCALIMPLEMENTATION TChunkzTXt : public TChunktEXt 
{
	typedef TChunktEXt inherited;
	
public:
	virtual bool __fastcall LoadFromStream(Classes::TStream* Stream, const char * ChunkName, int Size);
	virtual bool __fastcall SaveToStream(Classes::TStream* Stream);
public:
	#pragma option push -w-inl
	/* TChunk.Create */ inline __fastcall virtual TChunkzTXt(TPNGObject* Owner) : TChunktEXt(Owner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TChunk.Destroy */ inline __fastcall virtual ~TChunkzTXt(void) { }
	#pragma option pop
	
};


//-- var, const, procedure ---------------------------------------------------
extern PACKAGE AnsiString ZLIBErrors[9];
static const Shortint Z_NO_FLUSH = 0x0;
static const Shortint Z_FINISH = 0x4;
static const Shortint Z_STREAM_END = 0x1;
static const Shortint FILTER_NONE = 0x0;
static const Shortint FILTER_SUB = 0x1;
static const Shortint FILTER_UP = 0x2;
static const Shortint FILTER_AVERAGE = 0x3;
static const Shortint FILTER_PAETH = 0x4;
static const Shortint COLOR_GRAYSCALE = 0x0;
static const Shortint COLOR_RGB = 0x2;
static const Shortint COLOR_PALETTE = 0x3;
static const Shortint COLOR_GRAYSCALEALPHA = 0x4;
static const Shortint COLOR_RGBALPHA = 0x6;
extern PACKAGE unsigned __fastcall update_crc(unsigned crc, pByteArray buf, int len);
extern PACKAGE int __fastcall ByteSwap(const int a);
extern PACKAGE void __fastcall RegisterChunk(TMetaClass* ChunkClass);

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

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