// Borland C++ Builder
// Copyright (c) 1995, 1999 by Borland International
// All rights reserved

// (DO NOT EDIT: machine generated header) 'EnTransf.pas' rev: 5.00

#ifndef EnTransfHPP
#define EnTransfHPP

#pragma delphiheader begin
#pragma option push -w-
#pragma option push -Vx
#include <EnDiGrph.hpp>	// Pascal unit
#include <EnMisc.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <SysInit.hpp>	// Pascal unit
#include <System.hpp>	// Pascal unit

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

namespace Entransf
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TImageTransform;
class PASCALIMPLEMENTATION TImageTransform : public System::TObject 
{
	typedef System::TObject inherited;
	
protected:
	Enmisc::TEnvisionProgressEvent FOnProgress;
	Shortint FLastPercent;
	
public:
	virtual void __fastcall Apply(const Endigrph::TDibGraphic* DibGraphic);
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	__property Enmisc::TEnvisionProgressEvent OnProgress = {read=FOnProgress, write=FOnProgress};
public:
		
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TImageTransform(void) : System::TObject() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TImageTransform(void) { }
	#pragma option pop
	
};


class DELPHICLASS TAntiAliasTransform;
class PASCALIMPLEMENTATION TAntiAliasTransform : public TImageTransform 
{
	typedef TImageTransform inherited;
	
protected:
	int FWidth;
	int FHeight;
	
public:
	__fastcall TAntiAliasTransform(void);
	virtual void __fastcall Apply(const Endigrph::TDibGraphic* DibGraphic);
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	__property int Width = {read=FWidth, write=FWidth, nodefault};
	__property int Height = {read=FHeight, write=FHeight, nodefault};
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TAntiAliasTransform(void) { }
	#pragma option pop
	
};


class DELPHICLASS TConvolutionTransform;
class PASCALIMPLEMENTATION TConvolutionTransform : public TImageTransform 
{
	typedef TImageTransform inherited;
	
public:
	Shortint A1;
	Shortint A2;
	Shortint A3;
	Shortint B1;
	Shortint B2;
	Shortint B3;
	Shortint C1;
	Shortint C2;
	Shortint C3;
	Shortint Divisor;
	__fastcall TConvolutionTransform(void);
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TConvolutionTransform(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSharpenTransform;
class PASCALIMPLEMENTATION TSharpenTransform : public TConvolutionTransform 
{
	typedef TConvolutionTransform inherited;
	
protected:
	Byte FFactor;
	
public:
	__fastcall TSharpenTransform(void);
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	__property Byte Factor = {read=FFactor, write=FFactor, nodefault};
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TSharpenTransform(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSmoothTransform;
class PASCALIMPLEMENTATION TSmoothTransform : public TConvolutionTransform 
{
	typedef TConvolutionTransform inherited;
	
protected:
	Byte FFactor;
	
public:
	__fastcall TSmoothTransform(void);
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	__property Byte Factor = {read=FFactor, write=FFactor, nodefault};
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TSmoothTransform(void) { }
	#pragma option pop
	
};


class DELPHICLASS TEdgeTransform;
class PASCALIMPLEMENTATION TEdgeTransform : public TConvolutionTransform 
{
	typedef TConvolutionTransform inherited;
	
public:
	__fastcall TEdgeTransform(void);
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TEdgeTransform(void) { }
	#pragma option pop
	
};


class DELPHICLASS TEmbossTransform;
class PASCALIMPLEMENTATION TEmbossTransform : public TConvolutionTransform 
{
	typedef TConvolutionTransform inherited;
	
public:
	__fastcall TEmbossTransform(void);
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TEmbossTransform(void) { }
	#pragma option pop
	
};


class DELPHICLASS TFlipHorizontalTransform;
class PASCALIMPLEMENTATION TFlipHorizontalTransform : public TImageTransform 
{
	typedef TImageTransform inherited;
	
public:
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TFlipHorizontalTransform(void) : TImageTransform() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TFlipHorizontalTransform(void) { }
	#pragma option pop
	
};


class DELPHICLASS TFlipVerticalTransform;
class PASCALIMPLEMENTATION TFlipVerticalTransform : public TImageTransform 
{
	typedef TImageTransform inherited;
	
public:
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TFlipVerticalTransform(void) : TImageTransform() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TFlipVerticalTransform(void) { }
	#pragma option pop
	
};


class DELPHICLASS TRotateTransform;
class PASCALIMPLEMENTATION TRotateTransform : public TImageTransform 
{
	typedef TImageTransform inherited;
	
protected:
	double FAngle;
	#pragma pack(push, 1)
	Endigrph::TRgb FBackgroundColor;
	#pragma pack(pop)
	
	DYNAMIC void __fastcall Rotate90(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	DYNAMIC void __fastcall Rotate180(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	DYNAMIC void __fastcall Rotate270(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	DYNAMIC void __fastcall RotateArbitrary(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	
public:
	__fastcall TRotateTransform(void);
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	__property double Angle = {read=FAngle, write=FAngle};
	__property Endigrph::TRgb BackgroundColor = {read=FBackgroundColor, write=FBackgroundColor};
public:
		
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TRotateTransform(void) { }
	#pragma option pop
	
};


class DELPHICLASS TShearTransform;
class PASCALIMPLEMENTATION TShearTransform : public TImageTransform 
{
	typedef TImageTransform inherited;
	
protected:
	bool FHorz;
	double FAngle;
	void __fastcall ShearX(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* Dest);
	void __fastcall ShearY(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* Dest);
	
public:
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	__property double Angle = {read=FAngle, write=FAngle};
	__property bool Horz = {read=FHorz, write=FHorz, nodefault};
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TShearTransform(void) : TImageTransform() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TShearTransform(void) { }
	#pragma option pop
	
};


class DELPHICLASS TNegativeTransform;
class PASCALIMPLEMENTATION TNegativeTransform : public TImageTransform 
{
	typedef TImageTransform inherited;
	
public:
	virtual void __fastcall Apply(const Endigrph::TDibGraphic* DibGraphic);
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	
protected:
	void __fastcall ApplyToPaletteDib(const Endigrph::TDibGraphic* DibGraphic);
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TNegativeTransform(void) : TImageTransform() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TNegativeTransform(void) { }
	#pragma option pop
	
};


class DELPHICLASS TContrastTransform;
class PASCALIMPLEMENTATION TContrastTransform : public TImageTransform 
{
	typedef TImageTransform inherited;
	
protected:
	bool FIncrease;
	int FFactor;
	void __fastcall SetFactor(int Value);
	
public:
	__fastcall TContrastTransform(void);
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	virtual void __fastcall Apply(const Endigrph::TDibGraphic* DibGraphic);
	__property bool Increase = {read=FIncrease, write=FIncrease, nodefault};
	__property int Factor = {read=FFactor, write=SetFactor, nodefault};
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TContrastTransform(void) { }
	#pragma option pop
	
};


class DELPHICLASS TBrightnessTransform;
class PASCALIMPLEMENTATION TBrightnessTransform : public TImageTransform 
{
	typedef TImageTransform inherited;
	
protected:
	double FPercent;
	void __fastcall SetPercent(const double InPercent);
	
public:
	__fastcall TBrightnessTransform(void);
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	virtual void __fastcall Apply(const Endigrph::TDibGraphic* DibGraphic);
	__property double Percent = {read=FPercent, write=SetPercent};
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TBrightnessTransform(void) { }
	#pragma option pop
	
};


class DELPHICLASS TGammaTransform;
class PASCALIMPLEMENTATION TGammaTransform : public TImageTransform 
{
	typedef TImageTransform inherited;
	
protected:
	double FGamma;
	void __fastcall SetGamma(const double InGamma);
	
public:
	__fastcall TGammaTransform(void);
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	__property double Gamma = {read=FGamma, write=SetGamma};
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TGammaTransform(void) { }
	#pragma option pop
	
};


class DELPHICLASS TConvertToGrayTransform;
class PASCALIMPLEMENTATION TConvertToGrayTransform : public TImageTransform 
{
	typedef TImageTransform inherited;
	
protected:
	double FRedFactor;
	double FGreenFactor;
	double FBlueFactor;
	Enmisc::TImageFormat FGrayFormat;
	void __fastcall SetRedFactor(const double Factor);
	void __fastcall SetGreenFactor(const double Factor);
	void __fastcall SetBlueFactor(const double Factor);
	void __fastcall SetGrayFormat(const Enmisc::TImageFormat Format);
	
public:
	__fastcall TConvertToGrayTransform(void);
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	__property double RedFactor = {read=FRedFactor, write=SetRedFactor};
	__property double GreenFactor = {read=FGreenFactor, write=SetGreenFactor};
	__property double BlueFactor = {read=FBlueFactor, write=SetBlueFactor};
	__property Enmisc::TImageFormat GrayFormat = {read=FGrayFormat, write=SetGrayFormat, nodefault};
public:
		
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TConvertToGrayTransform(void) { }
	#pragma option pop
	
};


#pragma option push -b-
enum TInterpolationFilter { ifTriangle, ifHermite, ifBell, ifBSpline, ifLanczos3, ifMitchell };
#pragma option pop

class DELPHICLASS TResizeTransform;
class PASCALIMPLEMENTATION TResizeTransform : public TImageTransform 
{
	typedef TImageTransform inherited;
	
protected:
	int FWidth;
	int FHeight;
	bool FInterpolated;
	bool FOverrideDestFormat;
	Enmisc::TImageFormat FDestFormat;
	TInterpolationFilter FFilter;
	
public:
	__fastcall TResizeTransform(void);
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	__property int Width = {read=FWidth, write=FWidth, nodefault};
	__property int Height = {read=FHeight, write=FHeight, nodefault};
	__property bool Interpolated = {read=FInterpolated, write=FInterpolated, nodefault};
	__property TInterpolationFilter Filter = {read=FFilter, write=FFilter, nodefault};
	__property bool OverrideDestFormat = {read=FOverrideDestFormat, write=FOverrideDestFormat, nodefault
		};
	__property Enmisc::TImageFormat DestFormat = {read=FDestFormat, write=FDestFormat, nodefault};
public:
		
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TResizeTransform(void) { }
	#pragma option pop
	
};


class DELPHICLASS TImageFormatTransform;
class PASCALIMPLEMENTATION TImageFormatTransform : public TImageTransform 
{
	typedef TImageTransform inherited;
	
protected:
	Enmisc::TImageFormat FImageFormat;
	#pragma pack(push, 1)
	Windows::TMaxLogPalette FPalette;
	#pragma pack(pop)
	
	bool FQuantize;
	bool FDither;
	void __fastcall QuantizeProgress(const System::TObject* Sender, const Byte PercentProgress);
	
public:
	__fastcall TImageFormatTransform(void);
	virtual void __fastcall Apply(const Endigrph::TDibGraphic* DibGraphic);
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	__property Enmisc::TImageFormat ImageFormat = {read=FImageFormat, write=FImageFormat, nodefault};
	__property bool Quantize = {read=FQuantize, write=FQuantize, nodefault};
	__property bool Dither = {read=FDither, write=FDither, nodefault};
	__property Windows::TMaxLogPalette Palette = {read=FPalette, write=FPalette};
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TImageFormatTransform(void) { }
	#pragma option pop
	
};


#pragma option push -b-
enum TCropMode { cmRemoveBorders, cmExtractRect };
#pragma option pop

class DELPHICLASS TCropTransform;
class PASCALIMPLEMENTATION TCropTransform : public TImageTransform 
{
	typedef TImageTransform inherited;
	
protected:
	int FTop;
	int FLeft;
	int FBottom;
	int FRight;
	TCropMode FCropMode;
	
public:
	__fastcall TCropTransform(void);
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
	__property TCropMode CropMode = {read=FCropMode, write=FCropMode, nodefault};
	__property int Top = {read=FTop, write=FTop, nodefault};
	__property int Left = {read=FLeft, write=FLeft, nodefault};
	__property int Bottom = {read=FBottom, write=FBottom, nodefault};
	__property int Right = {read=FRight, write=FRight, nodefault};
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TCropTransform(void) { }
	#pragma option pop
	
};


class DELPHICLASS TLowResFaxTransform;
class PASCALIMPLEMENTATION TLowResFaxTransform : public TImageTransform 
{
	typedef TImageTransform inherited;
	
public:
	virtual void __fastcall ApplyOnDest(const Endigrph::TDibGraphic* Source, const Endigrph::TDibGraphic* 
		Dest);
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TLowResFaxTransform(void) : TImageTransform() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TLowResFaxTransform(void) { }
	#pragma option pop
	
};


//-- var, const, procedure ---------------------------------------------------
extern PACKAGE void __fastcall HSLToRGB(float Hue, const float Saturation, const float Luminosity, Endigrph::TRgb 
	&Rgb);
extern PACKAGE void __fastcall RGBToHSL(const Endigrph::TRgb Rgb, float &Hue, float &Saturation, float 
	&Luminosity);

}	/* namespace Entransf */
#if !defined(NO_IMPLICIT_NAMESPACE_USE)
using namespace Entransf;
#endif
#pragma option pop	// -w-
#pragma option pop	// -Vx

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