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

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

#ifndef ImageenviewHPP
#define ImageenviewHPP

#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.Graphics.hpp>
#include <Vcl.Controls.hpp>
#include <Vcl.Forms.hpp>
#include <System.Classes.hpp>
#include <System.SysUtils.hpp>
#include <Vcl.StdCtrls.hpp>
#include <Vcl.ExtCtrls.hpp>
#include <hyiedefs.hpp>
#include <hyieutils.hpp>
#include <imageenio.hpp>
#include <imageenproc.hpp>
#include <ieview.hpp>
#include <iexTransitions.hpp>
#include <System.UITypes.hpp>
#include <System.Types.hpp>
#include <Vcl.Menus.hpp>

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

namespace Imageenview
{
//-- forward type declarations -----------------------------------------------
class DELPHICLASS TIEGestureOptions;
class DELPHICLASS TIEGesturePanOptions;
class DELPHICLASS TIEGestureZoomOptions;
class DELPHICLASS TIEGestureLayerMoveOptions;
class DELPHICLASS TIEGestureLayerRotateOptions;
class DELPHICLASS TIEViewerGestures;
class DELPHICLASS TIEVSoftShadow;
struct TIEDrawingInfo;
class DELPHICLASS TIELayer;
class DELPHICLASS TImageEnView;
//-- type declarations -------------------------------------------------------
enum DECLSPEC_DENUM TIEGrip : unsigned char { ieNone, ieTopLeft, ieTopRight, ieBottomRight, ieBottomLeft, ieLeftSide, ieRightSide, ieTopSide, ieBottomSide, ieRotationCenter };

enum DECLSPEC_DENUM TIEAlignment : unsigned char { iejLeft, iejRight, iejCenter, iejJustify };

typedef void __fastcall (__closure *TViewChangeEvent)(System::TObject* Sender, int Change);

typedef void __fastcall (__closure *TIEMediaFoundationNotifyEvent)(System::TObject* Sender, System::TObject* MediaFoundationObject, Hyiedefs::TIEMediaFountationNotifyType NotifyType);

enum DECLSPEC_DENUM TIESmoothTask : unsigned char { iestScroll, iestZoom };

typedef void __fastcall (__closure *TIEFinishSmoothTaskEvent)(System::TObject* Sender, TIESmoothTask Task);

typedef void __fastcall (__closure *TViewChangingEvent)(System::TObject* Sender, int Change, double newValue);

typedef void __fastcall (__closure *TIEMouseInResizingGripEvent)(System::TObject* Sender, TIEGrip Grip);

typedef void __fastcall (__closure *TIEZoomEvent)(System::TObject* Sender, double &NewZoom);

typedef void __fastcall (__closure *TIESpecialKeyEvent)(System::TObject* Sender, System::Word CharCode, System::Classes::TShiftState Shift, bool &Handled);

enum DECLSPEC_DENUM TIEScrollCommand : unsigned char { iescPosition, iescBottom, iescTop, iescLineDown, iescLineUp, iescPageDown, iescPageUp };

typedef void __fastcall (__closure *TIEOnDrawCanvas)(System::TObject* Sender, Vcl::Graphics::TCanvas* ACanvas, const System::Types::TRect &ARect);

typedef void __fastcall (__closure *TIEOnDrawBackground)(System::TObject* Sender, Vcl::Graphics::TCanvas* ACanvas, const System::Types::TRect &ARect, bool &Handled);

typedef void __fastcall (__closure *TIEOnDrawPolygon)(System::TObject* Sender, int polygon, int point, Vcl::Graphics::TCanvas* Canvas, int x, int y);

enum DECLSPEC_DENUM TIEWallPaperStyle : unsigned char { iewoNormal, iewoStretch, iewoTile };

enum DECLSPEC_DENUM TIEMouseInteractItems : unsigned char { miZoom, miScroll, miSelect, miSelectPolygon, miSelectCircle, miSelectZoom, miSelectMagicWand, miSelectLasso, miMoveLayers, miResizeLayers, miRotateLayers, miMovingScroll };

typedef System::Set<TIEMouseInteractItems, TIEMouseInteractItems::miZoom, TIEMouseInteractItems::miMovingScroll> TIEMouseInteract;

class PASCALIMPLEMENTATION TIEGestureOptions : public System::TObject
{
	typedef System::TObject inherited;
	
	
private:
	typedef System::DynamicArray<TIEGestureOptions*> _TIEGestureOptions__1;
	
	
private:
	_TIEGestureOptions__1 fDisables;
	bool fEnabled;
	bool fInertia;
	double fMultiplier;
	bool fSnapValues;
	double fSnapDelta;
	void __fastcall SetEnabled(bool Value);
	void __fastcall AddDisables(TIEGestureOptions* Value);
	
public:
	__property bool Enabled = {read=fEnabled, write=SetEnabled, nodefault};
	__property bool Inertia = {read=fInertia, write=fInertia, nodefault};
	__property double Multiplier = {read=fMultiplier, write=fMultiplier};
	__property bool SnapValues = {read=fSnapValues, write=fSnapValues, nodefault};
	__property double SnapDelta = {read=fSnapDelta, write=fSnapDelta};
public:
	/* TObject.Create */ inline __fastcall TIEGestureOptions(void) : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TIEGestureOptions(void) { }
	
};


class PASCALIMPLEMENTATION TIEGesturePanOptions : public TIEGestureOptions
{
	typedef TIEGestureOptions inherited;
	
private:
	System::Types::TRect fBoundingBox;
	
public:
	__property System::Types::TRect BoundingBox = {read=fBoundingBox, write=fBoundingBox};
public:
	/* TObject.Create */ inline __fastcall TIEGesturePanOptions(void) : TIEGestureOptions() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TIEGesturePanOptions(void) { }
	
};


class PASCALIMPLEMENTATION TIEGestureZoomOptions : public TIEGestureOptions
{
	typedef TIEGestureOptions inherited;
	
private:
	double fMax;
	double fMin;
	
public:
	__property double Max = {read=fMax, write=fMax};
	__property double Min = {read=fMin, write=fMin};
public:
	/* TObject.Create */ inline __fastcall TIEGestureZoomOptions(void) : TIEGestureOptions() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TIEGestureZoomOptions(void) { }
	
};


class PASCALIMPLEMENTATION TIEGestureLayerMoveOptions : public TIEGestureOptions
{
	typedef TIEGestureOptions inherited;
	
private:
	System::Types::TRect fBoundingBox;
	
public:
	__property System::Types::TRect BoundingBox = {read=fBoundingBox, write=fBoundingBox};
public:
	/* TObject.Create */ inline __fastcall TIEGestureLayerMoveOptions(void) : TIEGestureOptions() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TIEGestureLayerMoveOptions(void) { }
	
};


class PASCALIMPLEMENTATION TIEGestureLayerRotateOptions : public TIEGestureOptions
{
	typedef TIEGestureOptions inherited;
	
private:
	double fMax;
	double fMin;
	
public:
	__property double Max = {read=fMax, write=fMax};
	__property double Min = {read=fMin, write=fMin};
public:
	/* TObject.Create */ inline __fastcall TIEGestureLayerRotateOptions(void) : TIEGestureOptions() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TIEGestureLayerRotateOptions(void) { }
	
};


#pragma pack(push,4)
class PASCALIMPLEMENTATION TIEViewerGestures : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	TIEGesturePanOptions* fPan;
	TIEGestureZoomOptions* fZoom;
	TIEGestureLayerRotateOptions* fLayerRotate;
	TIEGestureLayerMoveOptions* fLayerMove;
	bool __fastcall GetEnabled(void);
	
public:
	__fastcall TIEViewerGestures(void);
	__fastcall virtual ~TIEViewerGestures(void);
	__property bool Enabled = {read=GetEnabled, nodefault};
	__property TIEGesturePanOptions* Pan = {read=fPan};
	__property TIEGestureZoomOptions* Zoom = {read=fZoom};
	__property TIEGestureLayerRotateOptions* LayerRotate = {read=fLayerRotate};
	__property TIEGestureLayerMoveOptions* LayerMove = {read=fLayerMove};
};

#pragma pack(pop)

enum DECLSPEC_DENUM Imageenview__7 : unsigned char { ienoMouseWheelZoom, ienoMarkOuter };

typedef System::Set<Imageenview__7, Imageenview__7::ienoMouseWheelZoom, Imageenview__7::ienoMarkOuter> TIENavigatorOptions;

enum DECLSPEC_DENUM TIESelectionBase : unsigned char { iesbClientArea, iesbBitmap };

enum DECLSPEC_DENUM Imageenview__8 : unsigned char { iesoAnimated, iesoSizeable, iesoMoveable, iesoFilled, iesoCutBorders, iesoMarkOuter, iesoCanScroll, iesoSelectTranspLayers, iesoRightButtonSelectLayers, iesoRightButtonTerminatePolySelect, iesoDisableOneClickDeselect, iesoDisableNewSelection };

typedef System::Set<Imageenview__8, Imageenview__8::iesoAnimated, Imageenview__8::iesoDisableNewSelection> TIESelectionOptions;

enum DECLSPEC_DENUM TIESelOp : unsigned char { iespReplace, iespAdd };

enum DECLSPEC_DENUM TIEMagicWandMode : unsigned char { iewInclusive, iewExclusive, iewGlobal };

class PASCALIMPLEMENTATION TIEVSoftShadow : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	bool Enabled;
	double Radius;
	int OffsetX;
	int OffsetY;
	int Intensity;
	Hyiedefs::TRGB ShadowColor;
public:
	/* TObject.Create */ inline __fastcall TIEVSoftShadow(void) : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TIEVSoftShadow(void) { }
	
};


struct DECLSPEC_DRECORD TIEDrawingInfo
{
public:
	int XDst;
	int YDst;
	int WidthDst;
	int HeightDst;
	int XSrc;
	int YSrc;
	int WidthSrc;
	int HeightSrc;
	System::StaticArray<System::Types::TPoint, 4> RotatedDest;
};


typedef void __fastcall (__closure *TIEDrawLayerEvent)(System::TObject* Sender, Hyieutils::TIEBitmap* dest, int layerIndex);

typedef void __fastcall (__closure *TIEDrawLayerBoxEvent)(System::TObject* Sender, Vcl::Graphics::TBitmap* ABitmap, int layer);

typedef void __fastcall (__closure *TIEDrawLayerGrip)(System::TObject* Sender, Vcl::Graphics::TBitmap* ABitmap, int layer, int grip, const System::Types::TRect &rect);

class PASCALIMPLEMENTATION TIELayer : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	int ResizedWidth;
	int ResizedHeight;
	double fRotate;
	Hyieutils::TIEBitmap* fCachedLayerMask;
	int __fastcall GetWidth(void);
	int __fastcall GetHeight(void);
	void __fastcall SetRotate(double v);
	
public:
	System::TObject* fOwner;
	Hyieutils::TIEBitmap* Bitmap;
	bool Visible;
	bool VisibleBox;
	int Transparency;
	double Opacity;
	int PosX;
	int PosY;
	System::Types::TRect ClientAreaBox;
	bool Cropped;
	bool Locked;
	bool Selectable;
	Hyiedefs::TIELayerMagnification Magnify;
	Hyieutils::TIERenderOperation Operation;
	void *UserData;
	int UserDataLen;
	bool FreeBitmapOnDestroy;
	Hyiedefs::TResampleFilter ResampleFilter;
	bool UseResampleFilter;
	System::AnsiString Name;
	bool IsMask;
	TIEDrawingInfo DrawingInfo;
	bool DrawOuter;
	GUID GUID;
	double RotateCenterX;
	double RotateCenterY;
	__property double Rotate = {read=fRotate, write=SetRotate};
	__property int Width = {read=GetWidth, write=ResizedWidth, nodefault};
	__property int Height = {read=GetHeight, write=ResizedHeight, nodefault};
	__fastcall TIELayer(System::TObject* Owner, Hyieutils::TIEBitmap* TemplateBitmap, bool JustAssign);
	__fastcall virtual ~TIELayer(void);
	int __fastcall ConvXScr2Bmp(int x);
	int __fastcall ConvYScr2Bmp(int y);
	int __fastcall ConvXBmp2Scr(int x);
	int __fastcall ConvYBmp2Scr(int y);
	void __fastcall Assign(TIELayer* Source);
	void __fastcall Swap(TIELayer* OtherLayer);
	void __fastcall SetDefaults(void);
	void __fastcall SaveInfo(System::Classes::TStream* Stream, bool saveBitmap);
	void __fastcall LoadInfo(System::Classes::TStream* Stream);
	TIELayer* __fastcall GetLayerMask(void);
	int __fastcall GetIndex(void);
};


enum DECLSPEC_DENUM TIELayerEvent : unsigned char { ielSelected, ielMoved, ielResized, ielMoving, ielResizing, ielRotating, ielRotated, ielBeginResizing, ielBeginMoving };

typedef void __fastcall (__closure *TIELayerNotify)(System::TObject* Sender, int layer, TIELayerEvent event);

typedef void __fastcall (__closure *TIEVirtualKeyEvent)(System::TObject* Sender, unsigned VirtualKey, unsigned KeyData, bool KeyDown);

typedef void __fastcall (__closure *TIESetCursorEvent)(System::TObject* Sender, System::Uitypes::TCursor &Cursor);

enum DECLSPEC_DENUM Imageenview__11 : unsigned char { iegfBegin, iegfInertia, iegfEnd };

typedef System::Set<Imageenview__11, Imageenview__11::iegfBegin, Imageenview__11::iegfEnd> TIEGestureFlags;

enum DECLSPEC_DENUM TIEGestureID : unsigned char { iegiBegin, iegiEnd, iegiZoom, iegiPan, iegiRotate, iegiTwoFingerTap, iegiPressAndTap };

typedef void __fastcall (__closure *TIEImageEnGestureEvent)(System::TObject* Sender, TIEGestureFlags Flags, TIEGestureID ID, System::Types::TSmallPoint Location, int Value, int InertiaX, int InertiaY, int PressAndTapDistance, bool &Handled);

enum DECLSPEC_DENUM TIERSOptions : unsigned char { iersNone, iersMoveToAdapt, iersSyncLayers };

enum DECLSPEC_DENUM TIESoftCropMode : unsigned char { iesfNone, iesfAlphaBlend, iesfGrid, iesfAdd };

enum DECLSPEC_DENUM TIEGripShape : unsigned char { iegsBox, iegsCircle };

enum DECLSPEC_DENUM TIEUpdateReason : unsigned char { ieurDefault, ieurScrolled, ieurZoomed, ieurSelectionChanged, ieurComponentStuffChanged };

enum DECLSPEC_DENUM TIELayersResizeAspectRatio : unsigned char { iearDisabled, iearALTKey, iearAlways, iearAlwaysOnCornerGrip };

class PASCALIMPLEMENTATION TImageEnView : public Ieview::TIEView
{
	typedef Ieview::TIEView inherited;
	
private:
	bool fLegacyBitmap;
	bool fUseDrawDibDraw;
	System::Uitypes::TCursor fLCursor;
	System::Uitypes::TCursor fCursor;
	System::Uitypes::TCursor fWasScreenCursor;
	System::Classes::TNotifyEvent fOnImageChange;
	TViewChangeEvent fOnViewChange;
	TIEImageEnGestureEvent fOnImageEnGesture;
	TIEFinishSmoothTaskEvent fOnFinishSmoothTask;
	TViewChangingEvent fOnViewChanging;
	Hyieutils::TIEHAlign fImageHorizAlignment;
	Hyieutils::TIEVAlign fImageVertAlignment;
	Hyiedefs::TResampleFilter fZoomFilter;
	Hyiedefs::TResampleFilter fSaveZoomFilter;
	bool fDelayZoomFilter;
	Hyiedefs::TIEBackgroundStyle fBackgroundStyle;
	bool fMagicWandMaxFilter;
	int fMagicWandTolerance;
	TIEMagicWandMode fMagicWandMode;
	double fRXScroll;
	double fRYScroll;
	bool fDisplayGrid;
	int fDisplayGridLyr;
	System::Types::TPoint fHighlightedPixel;
	bool fVScrollBarVisible;
	bool fHScrollBarVisible;
	int fAniCounter;
	System::Classes::TNotifyEvent fOnPaint;
	TIEMouseInResizingGripEvent fOnMouseInResizingGrip;
	TIEZoomEvent fOnZoomIn;
	TIEZoomEvent fOnZoomOut;
	bool fDelayDisplaySelection;
	Hyiedefs::TIEProgressEvent fOnProgress;
	System::Classes::TNotifyEvent fOnFinishWork;
	Imageenio::TIEAcquireBitmapEvent fOnAcquireBitmap;
	bool fFullUpdateRequest;
	bool fBlockPaint;
	bool fRectMoving;
	bool fDrawVersion;
	System::Classes::TNotifyEvent fOnDrawBackBuffer;
	TIELayerNotify fOnLayerNotify;
	double fSelectionAspectRatio;
	int fSelectionAbsWidth;
	int fSelectionAbsHeight;
	TIESpecialKeyEvent fOnSpecialKey;
	TImageEnView* fNavigator;
	TIENavigatorOptions fNavigatorOptions;
	bool fNavigatorInside;
	bool fIsNavigator;
	Hyieutils::TIEBitmap* fNavigatorBackBuffer;
	System::Types::TRect fNavigatorActualRect;
	bool fUpdateInsideUpdate;
	bool fInsideUpdate;
	int fDelayTimer;
	System::Types::TRect fLyrResizingClientAreaBox;
	System::StaticArray<System::Types::TPoint, 4> fLyrResizingRotatedBox;
	bool fZoomSelectionAspectRatio;
	double fMouseScrollRate;
	TIEOnDrawPolygon fOnDrawPolygon;
	Hyiedefs::TIEAntialiasMode fLayersRotationFilter;
	bool fLayersRotationAntialias;
	bool fLayersRotationUseFilterOnPreview;
	bool fLayersRotationDelayFilterOnPreview;
	int fUpdate_MaskCache;
	bool fLayersSelectConstrains;
	int fSelectionGridWidth;
	int fSelectionGridHeight;
	int fMarkOuterAlpha;
	System::Uitypes::TColor fMarkOuterColor;
	TIELayersResizeAspectRatio fLayersResizeAspectRatio;
	double fLayersResizingAR;
	TIESetCursorEvent fOnSetCursor;
	double fLutLastZoomX;
	double fLutLastZoomY;
	int fLutLastFRX;
	int fLutLastFRY;
	int fLutLastMaxLayerWidth;
	int fLutLastMaxLayerHeight;
	int fHSVX1;
	int fHSVY1;
	int fo1x;
	int fo1y;
	int fo2x;
	int fo2y;
	int frx;
	int fry;
	int fBitmapWidth;
	int fBitmapHeight;
	Iextransitions::TIETransitionEffects* fTransition;
	Iextransitions::TIETransitionType fTransitionEffect;
	int fTransitionDuration;
	int fMinBitmapSize;
	System::Classes::TNotifyEvent fOnDShowNewFrame;
	System::Classes::TNotifyEvent fOnDShowEvent;
	TIEMediaFoundationNotifyEvent fOnMediaFoundationNotify;
	bool fFlatScrollBars;
	TIEOnDrawBackground fOnDrawBackground;
	TIEOnDrawCanvas fOnDrawCanvas;
	NativeUInt fOldHandle;
	TIEDrawLayerEvent fOnDrawLayer;
	TIEDrawLayerBoxEvent fOnDrawLayerBox;
	TIEDrawLayerGrip fOnDrawLayerGrip;
	bool fVisibleSelection;
	bool fOffscreenPaint;
	bool fFirstTimeSetCursor;
	int fLayersRotateStep;
	bool fAutoFixRotationBorders;
	Vcl::Graphics::TPicture* fWallPaper;
	TIEWallPaperStyle fWallPaperStyle;
	Vcl::Graphics::TBitmap* fDrawPixelBitmap;
	Hyiedefs::TRGB *fDrawPixelPtr;
	TIESoftCropMode fSoftCrop;
	int fSoftCropValue;
	bool fEnableInteractionHints;
	System::UnicodeString fInteractionHint;
	int fInteractionHintX;
	int fInteractionHintY;
	System::UnicodeString fInteractionHintMinText;
	System::Classes::TList* fPostFrames;
	bool fPlaying;
	int fPlayTimer;
	bool fPlayLoop;
	void __fastcall RemovePostFrames(int index);
	void __fastcall AniPolyFunc(System::TObject* Sender, bool UseLockPaint);
	void __fastcall TimerEvent(System::TObject* Sender);
	void __fastcall SetViewX(int v);
	void __fastcall SetViewY(int v);
	void __fastcall SetZoom(double v);
	void __fastcall SetZoomX(double v);
	void __fastcall SetZoomY(double v);
	int __fastcall GetSelX1(void);
	int __fastcall GetSelY1(void);
	int __fastcall GetSelX2(void);
	int __fastcall GetSelY2(void);
	void __fastcall SetCenter(bool value);
	bool __fastcall GetCenter(void);
	void __fastcall SetImageHorizAlignment(Hyieutils::TIEHAlign value);
	void __fastcall SetImageVertAlignment(Hyieutils::TIEVAlign value);
	TIEMouseInteract __fastcall GetMouseInteract(void);
	void __fastcall SetBackgroundStyle(Hyiedefs::TIEBackgroundStyle v);
	void __fastcall DoSelectionChange(void);
	void __fastcall DoSelectionChanging(void);
	void __fastcall DoBeforeSelectionChange(void);
	void __fastcall DoMouseInResizingGrip(TIEGrip Grip);
	void __fastcall DoMouseInSel(void);
	void __fastcall DoZoomIn(double &NewZoom);
	void __fastcall DoZoomOut(double &NewZoom);
	void __fastcall SetSelectionOptions(TIESelectionOptions v);
	Hyiedefs::TIERectangle __fastcall GetSelectedRect(void);
	TIEGrip __fastcall GetResizingGrip(int x, int y, System::Classes::TShiftState Shift);
	int __fastcall GetMovingGrip(int x, int y, System::Classes::TShiftState Shift);
	TIEGrip __fastcall SelectResizeEx(TIEGrip grip, int newx, int newy, bool aspectratio);
	int __fastcall SelectMoveEx(int fMoving, int ox, int oy, bool cutBorders);
	bool __fastcall GetScrollBarsAlwaysVisible(void);
	void __fastcall SetScrollBarsAlwaysVisible(bool v);
	void __fastcall SetDisplayGrid(bool v);
	void __fastcall SetDisplayGridLyr(int v);
	bool __fastcall GetTransitionRunning(void);
	int __fastcall GetLayersCount(void);
	TIELayer* __fastcall GetLayer(int idx);
	void __fastcall PaintSelection(Vcl::Graphics::TBitmap* OutBitmap);
	void __fastcall PaintGrid(Vcl::Graphics::TBitmap* OutBitmap);
	HIDESBASE void __fastcall SetCursor(System::Uitypes::TCursor Value);
	void __fastcall SetDelayTimer(int Value);
	int __fastcall GetDelayTimer(void);
	void __fastcall SetGradientEndColor(System::Uitypes::TColor Value);
	void __fastcall DoDrawVersion(void);
	void __fastcall SetDrawVersion(bool v);
	void __fastcall SetSelectionMaskDepth(int value);
	void __fastcall MouseResizeLayer(int clientlx, int cliently, bool AltPressed);
	MESSAGE void __fastcall DShowNewFrame(Winapi::Messages::TMessage &Message);
	MESSAGE void __fastcall DShowEvent(Winapi::Messages::TMessage &Message);
	MESSAGE void __fastcall MediaFoundationNotify(Winapi::Messages::TMessage &Message);
	void __fastcall MouseSelectCircle(int x, int y, System::Classes::TShiftState Shift);
	void __fastcall MouseSelectRectangle(int x, int y, System::Classes::TShiftState Shift);
	void __fastcall SetSelectionAspectRatio(double value);
	int __fastcall GetSavedSelectionsCount(void);
	void __fastcall SetFlatScrollBars(bool Value);
	void __fastcall SwapSelectionBase(void);
	void __fastcall NavigatorSelectionChanging(System::TObject* Sender);
	void __fastcall NavigatorMouseWheel(System::TObject* Sender, System::Classes::TShiftState Shift, int WheelDelta, const System::Types::TPoint &MousePos, bool &Handled);
	void __fastcall SetNavigatorRect(void);
	System::UnicodeString __fastcall GetImageEnVersion(void);
	void __fastcall SetImageEnVersion(System::UnicodeString Value);
	HIDESBASE MESSAGE void __fastcall WMGestureNotify(Hyiedefs::TIEWMGestureNotify &Msg);
	HIDESBASE MESSAGE void __fastcall WMGesture(Winapi::Messages::TMessage &Msg);
	void __fastcall SetOnTransitionStop(System::Classes::TNotifyEvent value);
	System::Classes::TNotifyEvent __fastcall GetOnTransitionStop(void);
	void __fastcall SetOnTransitionStep(Iextransitions::TIETransitionStepEvent value);
	Iextransitions::TIETransitionStepEvent __fastcall GetOnTransitionStep(void);
	void __fastcall SetTransitionTiming(Iextransitions::TIETransitionTiming value);
	Iextransitions::TIETransitionTiming __fastcall GetTransitionTiming(void);
	void __fastcall SetWallPaper(Vcl::Graphics::TPicture* Value);
	void __fastcall SetWallPaperStyle(TIEWallPaperStyle Value);
	System::Types::TRect __fastcall AdjustRectToAspectRatio(const System::Types::TRect &ARect);
	void __fastcall DoOnDrawPolygon(int polygon, int point, Vcl::Graphics::TCanvas* Canvas, int x, int y);
	Vcl::Graphics::TBitmap* __fastcall GetBackBuffer(void);
	void __fastcall SetOnSaveUndo(Imageenproc::TIESaveUndoEvent value);
	Imageenproc::TIESaveUndoEvent __fastcall GetOnSaveUndo(void);
	void __fastcall ZoomSelectionEx(bool AspectRatio, bool FireDoZoomIn);
	void __fastcall SetSoftCrop(TIESoftCropMode v);
	void __fastcall SetSoftCropValue(int v);
	void __fastcall SetHighlightedPixel(const System::Types::TPoint &v);
	void __fastcall SetOnTransitionPaint(const Iextransitions::TIEOnTransitionPaint Value);
	Iextransitions::TIEOnTransitionPaint __fastcall GetOnTransitionPaint(void);
	void __fastcall SetSmoothScrollValue(int v);
	void __fastcall SetSmoothZoomValue(int v);
	void __fastcall SetupAniPolyTimer(void);
	void __fastcall SetupTransition(void);
	void __fastcall SetupDrawPixelBitmap(void);
	void __fastcall TerminatePolySelection(bool shift, bool removeLastPoint);
	void __fastcall DrawMarkOutNavigator(const System::Types::TRect &rc);
	void __fastcall SetHighlightedPixelColor(System::Uitypes::TColor c);
	int __fastcall GetSelectionGridSize(void);
	void __fastcall SetSelectionGridSize(int value);
	void __fastcall SetPlaying(const bool v);
	void __fastcall StartPlayTimer(void);
	void __fastcall StopPlayTimer(void);
	virtual void __fastcall DoImageEnGestureEvent(const Hyiedefs::TIEGESTUREINFO &GInfo, bool &Handled);
	double __fastcall PerformRotateSnap(double Value);
	double __fastcall PerformLayerMoveSnap(double Value);
	double __fastcall PerformZoomSnap(double Value);
	
protected:
	int fStableReset;
	int fStable2Reset;
	int fStable;
	int fStable2;
	TIEUpdateReason fUpdateReason;
	bool fDBToDraw;
	Hyieutils::TIEBitmap* fTBitmap;
	int fViewX;
	int fViewY;
	double fZoomX;
	double fZoomY;
	double fZoomD100X;
	double f100DZoomX;
	double fZoomD100Y;
	double f100DZoomY;
	NativeUInt fHDrawDib;
	System::Uitypes::TScrollStyle fScrollBars;
	int fLockPaint;
	int fOffX;
	int fOffY;
	int fExtX;
	int fExtY;
	int fZZWW;
	int fZZHH;
	Vcl::Graphics::TBitmap* fBitmap;
	Hyiedefs::TBitmapInfoHeader256 fBitmapInfoHeader256;
	bool fDoubleBuffer;
	bool fAutoFit;
	bool fUpdateInvalidate;
	bool fAutoStretch;
	bool fAutoShrink;
	bool fSel;
	bool fPolySelecting;
	bool fLassoSelecting;
	bool fRectSelecting;
	bool fCircSelecting;
	TIEGrip fRectResizing;
	int fSelectMoving;
	int fMMoveX;
	int fMMoveY;
	int fHSX0;
	int fHSY0;
	int fHSX1;
	int fHSY1;
	int fPredX;
	int fPredY;
	int fPredLX;
	int fPredLY;
	int fMouseDownX;
	int fMouseDownY;
	void *fHPolySel;
	TIESelectionBase fSelectionBase;
	TIESelectionBase fSavedSelectionBase;
	System::Classes::TNotifyEvent fOnSelectionChanging;
	System::Classes::TNotifyEvent fOnSelectionChange;
	System::Classes::TNotifyEvent fOnBeforeSelectionChange;
	System::Classes::TNotifyEvent fOnMouseInSel;
	TIESelectionOptions fSelectionOptions;
	int fStartingPolyCount;
	Hyieutils::TIEMask* fSelectionMask;
	int fSelectionMaskDepth;
	int fSelectionIntensity;
	System::Uitypes::TColor fSelColor1;
	System::Uitypes::TColor fSelColor2;
	System::Uitypes::TColor fGripColor1;
	System::Uitypes::TColor fGripColor2;
	Vcl::Graphics::TBrushStyle fGripBrushStyle;
	int fGripSize;
	TIEGripShape fGripShape;
	bool fExtendedGrips;
	System::Uitypes::TColor fLyrGripColor1;
	System::Uitypes::TColor fLyrGripColor2;
	Vcl::Graphics::TBrushStyle fLyrGripBrushStyle;
	int fLyrGripSize;
	TIEGripShape fLyrGripShape;
	int fChessboardSize;
	Vcl::Graphics::TBrushStyle fChessboardBrushStyle;
	bool fForceALTkey;
	bool fMouseMoveScrolling;
	System::Classes::TList* fSavedSelection;
	bool fEnableShiftKey;
	System::Uitypes::TColor fGradientEndColor;
	int fUpdateLocked;
	System::Classes::TList* fAnimPoly;
	Vcl::Extctrls::TTimer* fAnimPolyTimer;
	Vcl::Extctrls::TTimer* fSmoothScrollTimer;
	int fSmoothScrollDestX;
	int fSmoothScrollDestY;
	int fSmoothScrollValue;
	Vcl::Extctrls::TTimer* fSmoothZoomTimer;
	double fSmoothZoomDest;
	int fSmoothZoomValue;
	TIEMouseInteract fMouseInteract;
	bool fScrollBarsAlwaysVisible;
	Hyieutils::TIEScrollBarParams* fVScrollBarParams;
	Hyieutils::TIEScrollBarParams* fHScrollBarParams;
	Hyieutils::TIEMouseWheelParams* fMouseWheelParams;
	int flx1;
	int fly1;
	int flx2;
	int fly2;
	bool fEnableAlphaChannel;
	Hyieutils::TIEBitmap* fIEBitmap;
	Imageenio::TImageEnIO* fImageEnIO;
	Imageenproc::TImageEnProc* fImageEnProc;
	System::Classes::TList* fLayers;
	int fLayersCurrent;
	int fMaxLayerWidth;
	int fMaxLayerHeight;
	bool fLayersAutoUndo;
	bool fLayersSync;
	bool fLayersDrawBox;
	int fMovingLayer;
	bool fLayerMoved;
	int fRotatingLayer;
	double fRotatingLayerValue;
	int fMovingRotationCenter;
	TIEGrip fLayerResizing;
	bool fMovResRotLayerStarted;
	Hyiedefs::IntegerArray *fGXScr2Bmp;
	Hyiedefs::IntegerArray *fGYScr2Bmp;
	int fGXScr2BmpSize;
	int fGYScr2BmpSize;
	Hyiedefs::IntegerArray *fXScr2Bmp;
	Hyiedefs::IntegerArray *fYScr2Bmp;
	int fXScr2BmpSize;
	int fYScr2BmpSize;
	Hyiedefs::IntegerArray *fXBmp2Scr;
	Hyiedefs::IntegerArray *fYBmp2Scr;
	Hyiedefs::IntegerArray *fGXBmp2Scr;
	Hyiedefs::IntegerArray *fGYBmp2Scr;
	int fXBmp2ScrSize;
	int fYBmp2ScrSize;
	bool fAutoCursors;
	Imageenproc::TIESaveUndoEvent fOnSaveUndo;
	TIEVirtualKeyEvent fOnVirtualKey;
	Vcl::Graphics::TPen* fLayerBoxPen;
	System::Uitypes::TColor fHighlightedPixelColor;
	bool fImageSet;
	TIEViewerGestures* fGestures;
	int fGestureStartValue;
	int fGestureStartX;
	int fGestureStartY;
	double fGestureBaseZoom;
	int fGestureBaseViewX;
	int fGestureBaseViewY;
	double fGestureBaseRotate;
	int fGestureBasePosX;
	int fGestureBasePosY;
	void __fastcall CalcEdges(int &EdgeX, int &EdgeY, bool NoVertSB, bool NoHorizSB);
	virtual void __fastcall SetBackGround(System::Uitypes::TColor cl);
	void __fastcall PolyDraw1(void);
	virtual void __fastcall SetScrollBars(System::Uitypes::TScrollStyle v);
	virtual void __fastcall CreateHandle(void);
	double __fastcall GetOptimalZoom(int ibitmapwidth, int ibitmapheight, int iwidth, int iheight, bool bolStretch, bool bolShrink);
	void __fastcall DoSize(void);
	void __fastcall DoVertScroll(TIEScrollCommand command, int Position);
	void __fastcall DoHorizScroll(TIEScrollCommand command, int Position);
	void __fastcall DoMouseWheelScroll(int Delta, int mouseX, int mouseY, bool CtrlPressed);
	void __fastcall DoDoubleClickEx(bool Shift);
	HIDESBASE MESSAGE void __fastcall WMSize(Winapi::Messages::TWMSize &Message);
	HIDESBASE MESSAGE void __fastcall WMEraseBkgnd(Winapi::Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall WMVScroll(Winapi::Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall WMHScroll(Winapi::Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall WMMouseWheel(Winapi::Messages::TMessage &Message);
	MESSAGE void __fastcall WMMouseHWheel(Winapi::Messages::TMessage &Message);
	HPALETTE __fastcall _CreatePalette(void);
	DYNAMIC bool __fastcall PaletteChanged(bool Foreground);
	HIDESBASE MESSAGE void __fastcall WMLButtonDblClk(Winapi::Messages::TWMMouse &Message);
	HIDESBASE MESSAGE void __fastcall WMKillFocus(Winapi::Messages::TWMKillFocus &Msg);
	HIDESBASE MESSAGE void __fastcall WMSetFocus(Winapi::Messages::TWMSetFocus &Msg);
	MESSAGE void __fastcall CMWantSpecialKey(Winapi::Messages::TWMKey &Msg);
	HIDESBASE MESSAGE void __fastcall WMNCPaint(Winapi::Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall WMPaint(Winapi::Messages::TWMPaint &Message);
	MESSAGE void __fastcall IEMUpdate(Winapi::Messages::TMessage &Message);
	MESSAGE void __fastcall IEMProgress(Winapi::Messages::TMessage &Message);
	MESSAGE void __fastcall IEMFinishWork(Winapi::Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall CNKEYDOWN(Winapi::Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall CNKEYUP(Winapi::Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall WMSYSKEYDOWN(Winapi::Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall WMSYSKEYUP(Winapi::Messages::TMessage &Message);
	MESSAGE void __fastcall WMTimer(Winapi::Messages::TWMTimer &Message);
	void __fastcall RestoreCursor(void);
	void __fastcall ShowSelectionEx(bool d);
	void __fastcall HideSelectionEx(bool dd);
	int __fastcall GetIdealComponentWidth(void);
	int __fastcall GetIdealComponentHeight(void);
	DYNAMIC void __fastcall MouseDown(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y);
	DYNAMIC void __fastcall MouseMove(System::Classes::TShiftState Shift, int X, int Y);
	DYNAMIC void __fastcall MouseUp(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y);
	System::Types::TPoint __fastcall GetPolySel(int idx);
	int __fastcall GetPolySelCount(void);
	virtual void __fastcall SetMouseInteract(TIEMouseInteract v);
	void __fastcall AnimPolygonAddPtEx(void * ap, int x, int y);
	void __fastcall AnimPolygonAddBreak(void * ap);
	void __fastcall AnimPolygonRemoveLast(void * ap);
	void __fastcall AnimPolygonRemoveLastPoint(void * ap);
	void __fastcall AnimPolygonMove(void * ap, int ox, int oy, int max_x, int max_y, bool CutSel);
	virtual void __fastcall ViewChange(int c);
	virtual void __fastcall ViewChanging(int c, double newValue);
	void __fastcall SetZoomFilter(Hyiedefs::TResampleFilter v);
	virtual void __fastcall SubMouseMoveScroll(int scx, int scy);
	bool __fastcall MouseMoveScroll(void);
	virtual Vcl::Graphics::TBitmap* __fastcall GetFBitmap(void);
	virtual Hyieutils::TIEBitmap* __fastcall GetIEBitmap(void);
	void __fastcall SetVisibleSelection(bool vv);
	bool __fastcall GetVisibleSelection(void);
	Hyiedefs::PPointArray __fastcall GetPolySelArray(void);
	DYNAMIC void __fastcall KeyDown(System::Word &Key, System::Classes::TShiftState Shift);
	DYNAMIC void __fastcall KeyUp(System::Word &Key, System::Classes::TShiftState Shift);
	DYNAMIC void __fastcall KeyPress(System::WideChar &Key);
	void __fastcall AddSelPointEx(int x, int y);
	void __fastcall AddSelBreakEx(void);
	void __fastcall SelectEx(int x1, int y1, int x2, int y2, TIESelOp Op, bool aspectratio, bool adjRect);
	HIDESBASE virtual int __fastcall GetClientWidth(void);
	HIDESBASE virtual int __fastcall GetClientHeight(void);
	virtual bool __fastcall HasParentWindow(void);
	void __fastcall SetSelColor1(System::Uitypes::TColor v);
	void __fastcall SetSelColor2(System::Uitypes::TColor v);
	Imageenio::TImageEnIO* __fastcall GetImageEnIO(void);
	Imageenproc::TImageEnProc* __fastcall GetImageEnProc(void);
	void __fastcall SetEnableAlphaChannel(bool v);
	virtual void __fastcall SetOnProgress(Hyiedefs::TIEProgressEvent v);
	virtual System::Classes::TNotifyEvent __fastcall GetOnFinishWork(void);
	virtual void __fastcall SetOnFinishWork(System::Classes::TNotifyEvent v);
	virtual void __fastcall SetOnAcquireBitmap(Imageenio::TIEAcquireBitmapEvent v);
	virtual Imageenio::TIEAcquireBitmapEvent __fastcall GetOnAcquireBitmap(void);
	virtual Hyiedefs::TIEProgressEvent __fastcall GetOnProgress(void);
	virtual bool __fastcall GetHasAlphaChannel(void);
	virtual Hyieutils::TIEBitmap* __fastcall GetAlphaChannel(void);
	virtual bool __fastcall GetIsEmpty(void);
	virtual bool __fastcall GetIsEmpty2(void);
	bool __fastcall RequiresScrollBars(void);
	virtual void __fastcall SetLayersCurrent(int Value);
	void __fastcall DoLayersSync(void);
	virtual void __fastcall SetLegacyBitmap(bool Value);
	virtual void __fastcall CreateCoordConvLUT(void);
	virtual void __fastcall CalcPaintCoords(void);
	void __fastcall CalcPaintCoordsEx(int &XSrc, int &YSrc, int &SrcWidth, int &SrcHeight, int &DstWidth, int &DstHeight, int tViewX, int tViewY);
	virtual void __fastcall UpdateLimits(void);
	int __fastcall QuantizeViewX(int vx);
	int __fastcall QuantizeViewY(int vy);
	void __fastcall HideHorizScrollBar(void);
	void __fastcall HideVertScrollBar(void);
	void __fastcall SetSelectionIntensity(int value);
	void __fastcall SetLayersSync(bool value);
	void __fastcall SetLayersDrawBox(bool value);
	virtual void __fastcall DoLayerNotify(int layer, TIELayerEvent event);
	void __fastcall SetTempCursor(System::Uitypes::TCursor Value, bool bOnMouseDown = false);
	TIELayer* __fastcall GetCurrentLayer(void);
	virtual void __fastcall Notification(System::Classes::TComponent* AComponent, System::Classes::TOperation Operation);
	void __fastcall GetFitValueXY(double &x, double &y);
	bool __fastcall IsPointInsideLayer(int x, int y, int layer);
	void __fastcall OnSmoothSetView(System::TObject* Sender);
	void __fastcall StopSmoothScroll(void);
	void __fastcall OnSmoothZoom(System::TObject* Sender);
	void __fastcall StopSmoothZoom(void);
	virtual void __fastcall DrawSelectionGrid(int x1, int y1, int x2, int y2);
	virtual void __fastcall AfterDrawLayer(int layerIndex, Hyieutils::TIEBitmap* DestBitmap, const System::Types::TRect &DestRect);
	void __fastcall SetVisibleBitmapRect(const System::Types::TRect &ARect);
	System::Types::TRect __fastcall GetVisibleBitmapRect(void);
	
public:
	__fastcall virtual TImageEnView(System::Classes::TComponent* Owner);
	__fastcall virtual ~TImageEnView(void);
	virtual void __fastcall Paint(void);
	virtual void __fastcall PaintToEx(Hyieutils::TIEBitmap* ABitmap, Hyiedefs::PPointerArray ABitmapScanline, System::Types::PRect UpdRect, bool drawBackground, bool drawGadgets);
	void __fastcall GetRenderRectangles(int &xDst, int &yDst, int &dxDst, int &dyDst, int &xSrc, int &ySrc, int &dxSrc, int &dySrc);
	void __fastcall GetMaxViewXY(int &mx, int &my);
	virtual void __fastcall SetZoomNoUpdate(double v);
	virtual void __fastcall SetZoomXNoUpdate(double v);
	virtual void __fastcall SetZoomYNoUpdate(double v);
	double __fastcall GetFitValue(void);
	void __fastcall DrawBackgroundToCanvas(Vcl::Graphics::TCanvas* ACanvas, int iWidth = 0xffffffff, int iHeight = 0xffffffff);
	void __fastcall MoveContentTo(TImageEnView* Destination);
	void __fastcall SaveState(const System::UnicodeString FileName)/* overload */;
	void __fastcall SaveState(System::Classes::TStream* Stream)/* overload */;
	void __fastcall LoadState(const System::UnicodeString FileName)/* overload */;
	void __fastcall LoadState(System::Classes::TStream* Stream)/* overload */;
	void __fastcall ResetState(void);
	virtual void __fastcall Select(int x1, int y1, int x2, int y2, TIESelOp Op = (TIESelOp)(0x0));
	void __fastcall SelectMagicWand(int x, int y, TIESelOp Op = (TIESelOp)(0x0));
	void __fastcall SelectColors(Hyiedefs::TRGB StartColor, Hyiedefs::TRGB FinalColor, TIESelOp Op = (TIESelOp)(0x0))/* overload */;
	void __fastcall SelectColors(Hyiedefs::TRGB Color, TIESelOp Op = (TIESelOp)(0x0))/* overload */;
	void __fastcall SelectColors(int ColorIndex, TIESelOp Op = (TIESelOp)(0x0))/* overload */;
	void __fastcall SelectEllipse(int CenterX, int CenterY, int Width, int Height, TIESelOp Op = (TIESelOp)(0x0));
	void __fastcall SelectRoundRect(int Left, int Top, int Right, int Bottom, int RoundWidth, int RoundHeight, TIESelOp Op = (TIESelOp)(0x0));
	void __fastcall SelectCustom(void);
	void __fastcall MoveSelection(int OffsetX, int OffsetY);
	__property double SelectionAspectRatio = {read=fSelectionAspectRatio, write=SetSelectionAspectRatio};
	void __fastcall SetSelectionMarkOuterStyle(int Alpha, System::Uitypes::TColor Color);
	__property int SelectionAbsWidth = {read=fSelectionAbsWidth, write=fSelectionAbsWidth, nodefault};
	__property int SelectionAbsHeight = {read=fSelectionAbsHeight, write=fSelectionAbsHeight, nodefault};
	__property bool AutoFixRotationBorders = {read=fAutoFixRotationBorders, write=fAutoFixRotationBorders, nodefault};
	void __fastcall DeSelect(void);
	__property int SelX1 = {read=GetSelX1, nodefault};
	__property int SelY1 = {read=GetSelY1, nodefault};
	__property int SelX2 = {read=GetSelX2, nodefault};
	__property int SelY2 = {read=GetSelY2, nodefault};
	virtual void __fastcall AddSelPoint(int x, int y);
	void __fastcall AddSelBreak(void);
	void __fastcall DelLastSelPoint(void);
	__property System::Types::TPoint PolySel[int idx] = {read=GetPolySel};
	__property int PolySelCount = {read=GetPolySelCount, nodefault};
	__property Hyiedefs::PPointArray PolySelPoints = {read=GetPolySelArray};
	__property System::Types::TRect VisibleBitmapRect = {read=GetVisibleBitmapRect, write=SetVisibleBitmapRect};
	__property int SmoothScrollValue = {read=fSmoothScrollValue, write=SetSmoothScrollValue, nodefault};
	__property int SmoothZoomValue = {read=fSmoothZoomValue, write=SetSmoothZoomValue, nodefault};
	__property bool Selected = {read=fSel, nodefault};
	__property Hyiedefs::TIERectangle SelectedRect = {read=GetSelectedRect};
	__property bool VisibleSelection = {read=GetVisibleSelection, write=SetVisibleSelection, nodefault};
	__property bool MagicWandMaxFilter = {read=fMagicWandMaxFilter, write=fMagicWandMaxFilter, nodefault};
	__property int MagicWandTolerance = {read=fMagicWandTolerance, write=fMagicWandTolerance, nodefault};
	__property TIEMagicWandMode MagicWandMode = {read=fMagicWandMode, write=fMagicWandMode, nodefault};
	bool __fastcall IsPointInsideSelection(int x, int y);
	__property Hyieutils::TIEMask* SelectionMask = {read=fSelectionMask};
	void __fastcall InvertSelection(void);
	void __fastcall SetSelectedAreaAlpha(int Alpha);
	void __fastcall SetSelectionGripStyle(System::Uitypes::TColor GripColor1 = (System::Uitypes::TColor)(0x0), System::Uitypes::TColor GripColor2 = (System::Uitypes::TColor)(0xffffff), Vcl::Graphics::TBrushStyle GripBrushStyle = (Vcl::Graphics::TBrushStyle)(0x0), int GripSize = 0x5, bool ExtendedGrips = true, TIEGripShape Shape = (TIEGripShape)(0x1));
	void __fastcall GetSelectionGripStyle(System::Uitypes::TColor &GripColor1, System::Uitypes::TColor &GripColor2, Vcl::Graphics::TBrushStyle &GripBrushStyle, int &GripSize, bool &ExtendedGrips, TIEGripShape &Shape);
	void __fastcall SetLayersGripStyle(System::Uitypes::TColor GripColor1 = (System::Uitypes::TColor)(0x0), System::Uitypes::TColor GripColor2 = (System::Uitypes::TColor)(0xffffff), Vcl::Graphics::TBrushStyle GripBrushStyle = (Vcl::Graphics::TBrushStyle)(0x0), int GripSize = 0x5, TIEGripShape Shape = (TIEGripShape)(0x1));
	void __fastcall SetLayersBoxStyle(Vcl::Graphics::TPenStyle PenStyle = (Vcl::Graphics::TPenStyle)(0x2), Vcl::Graphics::TPenMode PenMode = (Vcl::Graphics::TPenMode)(0x3), int PenWidth = 0x1, System::Uitypes::TColor PenColor = (System::Uitypes::TColor)(0x0));
	void __fastcall CopySelectionToBitmap(Vcl::Graphics::TBitmap* DestBitmap);
	void __fastcall CopySelectionToIEBitmap(Hyieutils::TIEBitmap* DestBitmap, bool FillBackground = true);
	virtual void __fastcall EndSelect(void);
	void __fastcall SetSelectedPixelsColor(Hyiedefs::TRGB color);
	void __fastcall SetAlphaRangePixelsColor(int alphaMin, int alphaMax, Hyiedefs::TRGB color);
	void __fastcall SaveSelectionToStream(System::Classes::TStream* Stream);
	bool __fastcall LoadSelectionFromStream(System::Classes::TStream* Stream, TIERSOptions Options = (TIERSOptions)(0x1));
	bool __fastcall MergeSelectionFromStream(System::Classes::TStream* Stream);
	void __fastcall SaveSelectionToFile(const System::UnicodeString FileName);
	bool __fastcall LoadSelectionFromFile(const System::UnicodeString FileName, TIERSOptions Options = (TIERSOptions)(0x1));
	bool __fastcall MergeSelectionFromFile(const System::UnicodeString FileName);
	bool __fastcall RestoreSelection(bool Remove = true, TIERSOptions Options = (TIERSOptions)(0x1));
	void __fastcall SaveSelection(void);
	bool __fastcall DiscardSavedSelection(void);
	__property int SavedSelectionsCount = {read=GetSavedSelectionsCount, nodefault};
	__property bool EnableShiftKey = {read=fEnableShiftKey, write=fEnableShiftKey, nodefault};
	__property Hyiedefs::TIEAntialiasMode LayersRotationFilter = {read=fLayersRotationFilter, write=fLayersRotationFilter, nodefault};
	__property bool LayersRotationAntialias = {read=fLayersRotationAntialias, write=fLayersRotationAntialias, nodefault};
	__property bool LayersRotationUseFilterOnPreview = {read=fLayersRotationUseFilterOnPreview, write=fLayersRotationUseFilterOnPreview, nodefault};
	__property bool LayersRotationDelayFilterOnPreview = {read=fLayersRotationDelayFilterOnPreview, write=fLayersRotationDelayFilterOnPreview, nodefault};
	__property int SelectionMaskDepth = {read=fSelectionMaskDepth, write=SetSelectionMaskDepth, nodefault};
	__property int SelectionIntensity = {read=fSelectionIntensity, write=SetSelectionIntensity, nodefault};
	void __fastcall MakeSelectionFeather(double radius);
	void * __fastcall AnimPolygonNew(System::Uitypes::TColor VColor1, System::Uitypes::TColor VColor2, bool VAnimated, bool VSizeable);
	void __fastcall AnimPolygonDel(void * ap);
	void __fastcall AnimPolygonAddPt(void * ap, int x, int y);
	void __fastcall AnimPolygonClear(void * ap);
	void __fastcall AnimPolygonEnabled(void * ap, bool Value);
	void __fastcall CopyFromPolygon(Vcl::Graphics::TBitmap* Source, System::Types::TPoint const *Polygon, const int Polygon_High, int PolygonLen, const System::Types::TPoint &Position);
	void __fastcall CopyToPolygon(Vcl::Graphics::TBitmap* Dest, System::Types::TPoint const *Polygon, const int Polygon_High, int PolygonLen, const System::Types::TPoint &Position);
	virtual void __fastcall Update(void);
	__property TIEUpdateReason UpdateReason = {read=fUpdateReason, write=fUpdateReason, nodefault};
	void __fastcall UpdateNoPaint(void);
	__property bool OffScreenPaint = {read=fOffscreenPaint, write=fOffscreenPaint, nodefault};
	__property int SelectionGridSize = {read=GetSelectionGridSize, write=SetSelectionGridSize, nodefault};
	__property int SelectionGridWidth = {read=fSelectionGridWidth, write=fSelectionGridWidth, nodefault};
	__property int SelectionGridHeight = {read=fSelectionGridHeight, write=fSelectionGridHeight, nodefault};
	void __fastcall Fit(void);
	void __fastcall FitToWidth(void);
	void __fastcall FitToHeight(void);
	void __fastcall Stretch(void);
	double __fastcall GetIdealZoom(void);
	__property int ViewX = {read=fViewX, write=SetViewX, nodefault};
	__property int ViewY = {read=fViewY, write=SetViewY, nodefault};
	void __fastcall CenterImage(void);
	void __fastcall SetViewXY(int x, int y);
	void __fastcall SetViewXYSmooth(int x, int y);
	void __fastcall SetZoomSmooth(double Zoom);
	__property double Zoom = {read=fZoomX, write=SetZoom};
	__property double ZoomX = {read=fZoomX, write=SetZoomX};
	__property double ZoomY = {read=fZoomY, write=SetZoomY};
	void __fastcall ZoomSelection(bool AspectRatio = true);
	void __fastcall ZoomAt(int x, int y, double ZoomVal, bool Center = true);
	void __fastcall ZoomIn(void);
	void __fastcall ZoomOut(void);
	__property ClientWidth = {read=GetClientWidth};
	__property ClientHeight = {read=GetClientHeight};
	__property int IdealComponentWidth = {read=GetIdealComponentWidth, nodefault};
	__property int IdealComponentHeight = {read=GetIdealComponentHeight, nodefault};
	virtual void __fastcall LockPaint(void);
	virtual int __fastcall UnLockPaint(void);
	virtual int __fastcall NPUnLockPaint(void);
	__property int LockPaintCount = {read=fLockPaint, nodefault};
	void __fastcall DrawTo(Vcl::Graphics::TCanvas* Canvas);
	__property int OffsetX = {read=fOffX, nodefault};
	__property int OffsetY = {read=fOffY, nodefault};
	__property int ExtentX = {read=fExtX, nodefault};
	__property int ExtentY = {read=fExtY, nodefault};
	__property bool ScrollBarsAlwaysVisible = {read=GetScrollBarsAlwaysVisible, write=SetScrollBarsAlwaysVisible, default=0};
	__property Hyieutils::TIEScrollBarParams* VScrollBarParams = {read=fVScrollBarParams};
	__property Hyieutils::TIEScrollBarParams* HScrollBarParams = {read=fHScrollBarParams};
	void __fastcall UpdateRect(const System::Types::TRect &rclip);
	void __fastcall PaintRect(const System::Types::TRect &rc);
	void __fastcall LockUpdate(void);
	void __fastcall UnLockUpdate(void);
	void __fastcall UnLockUpdateEx(void);
	__property Vcl::Graphics::TBitmap* BackBuffer = {read=GetBackBuffer};
	void __fastcall SetNavigator(TImageEnView* nav, TIENavigatorOptions options = TIENavigatorOptions() );
	__property bool IsNavigator = {read=fIsNavigator, nodefault};
	__property int MinBitmapSize = {read=fMinBitmapSize, write=fMinBitmapSize, nodefault};
	void __fastcall ChangeResolution(int NewDPI, Hyiedefs::TResampleFilter ResampleFilter = (Hyiedefs::TResampleFilter)(0x0));
	__property int LayersCount = {read=GetLayersCount, nodefault};
	__property int LayersCurrent = {read=fLayersCurrent, write=SetLayersCurrent, nodefault};
	int __fastcall LayersAdd(void)/* overload */;
	int __fastcall LayersAdd(int Width, int Height, Hyieutils::TIEPixelFormat PixelFormat = (Hyieutils::TIEPixelFormat)(0x5), int PosX = 0x0, int PosY = 0x0)/* overload */;
	int __fastcall LayersAdd(Hyieutils::TIEBitmap* Bitmap, bool DoCopy = true)/* overload */;
	int __fastcall LayersAdd(System::WideString FileName, int PosX = 0x0, int PosY = 0x0)/* overload */;
	void __fastcall LayersInsert(int Position);
	virtual void __fastcall LayersRemove(int idx);
	void __fastcall LayersClear(void);
	void __fastcall LayersMove(int CurIndex, int NewIndex);
	void __fastcall LayersMerge(int Layer1, int Layer2, bool RemoveUpperLayer = true)/* overload */;
	void __fastcall LayersMerge(int *LayerList, const int LayerList_High)/* overload */;
	void __fastcall LayersMerge(Hyiedefs::TIEArrayOfInteger LayerList)/* overload */;
	void __fastcall LayersMergeTo(int Layer1, int Layer2, Hyieutils::TIEBitmap* Destination);
	void __fastcall LayersDrawTo(Hyieutils::TIEBitmap* Destination);
	void __fastcall LayersMergeAll(void);
	void __fastcall LayersCopyToAlpha(int DestLayer);
	int __fastcall LayersCreateFromAlpha(void);
	__property TIESoftCropMode SoftCrop = {read=fSoftCrop, write=SetSoftCrop, nodefault};
	__property int SoftCropValue = {read=fSoftCropValue, write=SetSoftCropValue, nodefault};
	__property int LayersRotateStep = {read=fLayersRotateStep, write=fLayersRotateStep, nodefault};
	__property bool LayersSelectConstrains = {read=fLayersSelectConstrains, write=fLayersSelectConstrains, nodefault};
	__property TIELayer* Layers[int idx] = {read=GetLayer};
	__property bool LayersAutoUndo = {read=fLayersAutoUndo, write=fLayersAutoUndo, nodefault};
	__property System::Classes::TList* LayersList = {read=fLayers};
	__property TIELayersResizeAspectRatio LayersResizeAspectRatio = {read=fLayersResizeAspectRatio, write=fLayersResizeAspectRatio, nodefault};
	__property int MaxLayerWidth = {read=fMaxLayerWidth, nodefault};
	__property int MaxLayerHeight = {read=fMaxLayerHeight, nodefault};
	__property bool LayersSync = {read=fLayersSync, write=SetLayersSync, nodefault};
	__property bool LayersDrawBox = {read=fLayersDrawBox, write=SetLayersDrawBox, nodefault};
	int __fastcall FindLayerAt(int x, int y, bool SelectablesOnly = true);
	__property TIELayer* CurrentLayer = {read=GetCurrentLayer};
	void __fastcall LayersSaveToStream(System::Classes::TStream* Stream, int CompressionFormat = 0xffffffff);
	void __fastcall LayersSaveToFile(const System::UnicodeString FileName, int CompressionFormat = 0xffffffff);
	bool __fastcall LayersLoadFromStream(System::Classes::TStream* Stream);
	bool __fastcall LayersLoadFromFile(const System::UnicodeString FileName);
	int __fastcall LayersCreateFromSelection(void);
	int __fastcall LayersCreateFromClipboard(void);
	int __fastcall LayersCreateFromFile(const System::UnicodeString FileName);
	int __fastcall LayersCreateFromText(const System::UnicodeString sText, const System::UnicodeString sFontName, int iFontSize, System::Uitypes::TColor cFontColor, System::Uitypes::TFontStyles Style, bool bAddShadow = false, int iBlurRadius = 0x3, int iShadowOffset = 0x2, int Angle = 0x0, bool bAntiAlias = true);
	void __fastcall LayersFixSizes(int layer = 0xffffffff);
	void __fastcall LayersFixRotations(int layer = 0xffffffff);
	void __fastcall LayersFixBorders(int layer = 0xffffffff);
	void __fastcall SetExternalBitmap(Hyieutils::TIEBitmap* bmp);
	__property System::Uitypes::TColor GradientEndColor = {read=fGradientEndColor, write=SetGradientEndColor, nodefault};
	__property MouseCapture;
	HIDESBASE virtual void __fastcall Assign(System::TObject* Source);
	void __fastcall AssignSelTo(System::Classes::TPersistent* Dest);
	virtual void __fastcall ImageChange(void);
	int __fastcall YScr2Bmp(int y);
	int __fastcall XScr2Bmp(int x);
	int __fastcall YBmp2Scr(int y);
	int __fastcall XBmp2Scr(int x);
	virtual void __fastcall SetBounds(int ALeft, int ATop, int AWidth, int AHeight);
	__property System::Uitypes::TColor SelColor1 = {read=fSelColor1, write=SetSelColor1, default=0};
	__property System::Uitypes::TColor SelColor2 = {read=fSelColor2, write=SetSelColor2, default=16777215};
	void __fastcall Clear(void);
	void __fastcall Blank(void);
	__property bool DisplayGrid = {read=fDisplayGrid, write=SetDisplayGrid, nodefault};
	__property int DisplayGridLyr = {read=fDisplayGridLyr, write=SetDisplayGridLyr, nodefault};
	__property System::Types::TPoint HighlightedPixel = {read=fHighlightedPixel, write=SetHighlightedPixel};
	__property System::Uitypes::TColor HighlightedPixelColor = {read=fHighlightedPixelColor, write=SetHighlightedPixelColor, nodefault};
	void __fastcall SetInteractionHint(const System::UnicodeString Text, int x, int y, const System::UnicodeString minText);
	__property Hyieutils::TIEHAlign ImageHorizAlignment = {read=fImageHorizAlignment, write=SetImageHorizAlignment, nodefault};
	__property Hyieutils::TIEVAlign ImageVertAlignment = {read=fImageVertAlignment, write=SetImageVertAlignment, nodefault};
	__property Hyieutils::TIEMouseWheelParams* MouseWheelParams = {read=fMouseWheelParams};
	void __fastcall SetChessboardStyle(int Size = 0x10, Vcl::Graphics::TBrushStyle BrushStyle = (Vcl::Graphics::TBrushStyle)(0x0));
	__property bool ForceALTkey = {read=fForceALTkey, write=fForceALTkey, nodefault};
	__property bool DelayDisplaySelection = {read=fDelayDisplaySelection, write=fDelayDisplaySelection, nodefault};
	__property int DelayZoomTime = {read=fStableReset, write=fStableReset, nodefault};
	__property int DelayTimer = {read=GetDelayTimer, write=SetDelayTimer, nodefault};
	void __fastcall CopyToBitmapWithAlpha(Vcl::Graphics::TBitmap* Dest, int DestX, int DestY);
	__property bool UseDrawDibDraw = {read=fUseDrawDibDraw, write=fUseDrawDibDraw, nodefault};
	TIEGrip __fastcall GetGripAt(int x, int y);
	virtual void __fastcall RemoveAlphaChannel(bool Merge = false);
	__property bool IsEmpty = {read=GetIsEmpty, nodefault};
	__property bool IsEmpty2 = {read=GetIsEmpty2, nodefault};
	__property bool AutoCursors = {read=fAutoCursors, write=fAutoCursors, nodefault};
	__property bool ZoomSelectionAspectRatio = {read=fZoomSelectionAspectRatio, write=fZoomSelectionAspectRatio, nodefault};
	__property double MouseScrollRate = {read=fMouseScrollRate, write=fMouseScrollRate};
	__property Imageenio::TImageEnIO* IO = {read=GetImageEnIO};
	__property Imageenproc::TImageEnProc* Proc = {read=GetImageEnProc};
	__property bool TransitionRunning = {read=GetTransitionRunning, nodefault};
	void __fastcall PrepareTransition(void);
	void __fastcall RunTransition(Iextransitions::TIETransitionType Effect, int Duration)/* overload */;
	void __fastcall RunTransition(Iextransitions::TIETransitionType Effect, int Duration, Iextransitions::TIEPanZoomType PanZoomEffect, int iZoomLevel)/* overload */;
	void __fastcall RunTransition(Iextransitions::TIETransitionType Effect, int Duration, const System::Types::TRect &StartRect, const System::Types::TRect &EndRect, bool bMaintainAspectRatio = true)/* overload */;
	void __fastcall AbortTransition(void);
	void __fastcall PrepareTransitionBitmaps _DEPRECATED_ATTRIBUTE0 (Vcl::Graphics::TBitmap* OriginalBitmap, Vcl::Graphics::TBitmap* TargetBitmap, Iextransitions::TIETransitionType Effect, int iWidth = 0xffffffff, int iHeight = 0xffffffff)/* overload */;
	void __fastcall PrepareTransitionBitmaps _DEPRECATED_ATTRIBUTE0 (Vcl::Graphics::TBitmap* OriginalBitmap, Vcl::Graphics::TBitmap* TargetBitmap, Iextransitions::TIETransitionType Effect, const System::Types::TRect &StartRect, const System::Types::TRect &EndRect, bool bMaintainAspectRatio = true, int iWidth = 0xffffffff, int iHeight = 0xffffffff)/* overload */;
	void __fastcall CreateTransitionBitmap _DEPRECATED_ATTRIBUTE0 (float TransitionProgress, Vcl::Graphics::TBitmap* DestBitmap);
	__property Iextransitions::TIETransitionTiming TransitionTiming = {read=GetTransitionTiming, write=SetTransitionTiming, nodefault};
	void __fastcall BeginPostFrames(TImageEnView* target, int delay, int interval);
	void __fastcall EndPostFrames(TImageEnView* target);
	void __fastcall DrawLayerBox(Vcl::Graphics::TBitmap* ABitmap, int idx);
	void __fastcall DrawLayerOuter(Vcl::Graphics::TBitmap* ABitmap, int idx);
	void __fastcall DrawLayerGrips(Vcl::Graphics::TBitmap* ABitmap, int idx);
	void __fastcall DrawLayerRotationCenter(Vcl::Graphics::TBitmap* ABitmap, int idx);
	void __fastcall CalcLayerGripCoords(int layeridx, System::Types::TRect *coords, const int coords_High);
	TIEGrip __fastcall FindLayerGrip(int x, int y);
	TIEGrip __fastcall FindLayerGripDist(int x, int y, double &Distance);
	__property TIEViewerGestures* Gestures = {read=fGestures};
	
__published:
	__property bool LegacyBitmap = {read=fLegacyBitmap, write=SetLegacyBitmap, default=1};
	__property bool DoubleBuffer = {read=fDoubleBuffer, write=fDoubleBuffer, default=1};
	__property Hyiedefs::TResampleFilter ZoomFilter = {read=fZoomFilter, write=SetZoomFilter, default=0};
	__property System::Uitypes::TScrollStyle ScrollBars = {read=fScrollBars, write=SetScrollBars, default=3};
	__property TViewChangeEvent OnViewChange = {read=fOnViewChange, write=fOnViewChange};
	__property TIEImageEnGestureEvent OnImageEnGesture = {read=fOnImageEnGesture, write=fOnImageEnGesture};
	__property TIEFinishSmoothTaskEvent OnFinishSmoothTask = {read=fOnFinishSmoothTask, write=fOnFinishSmoothTask};
	__property TViewChangingEvent OnViewChanging = {read=fOnViewChanging, write=fOnViewChanging};
	__property System::Classes::TNotifyEvent OnImageChange = {read=fOnImageChange, write=fOnImageChange};
	__property TIESelectionOptions SelectionOptions = {read=fSelectionOptions, write=SetSelectionOptions, default=71};
	__property bool Center = {read=GetCenter, write=SetCenter, default=1};
	__property TIEMouseInteract MouseInteract = {read=GetMouseInteract, write=SetMouseInteract, default=0};
	__property bool AutoFit = {read=fAutoFit, write=fAutoFit, default=0};
	__property TIESelectionBase SelectionBase = {read=fSelectionBase, write=fSelectionBase, default=0};
	__property Hyiedefs::TIEBackgroundStyle BackgroundStyle = {read=fBackgroundStyle, write=SetBackgroundStyle, default=0};
	__property System::Classes::TNotifyEvent OnSelectionChange = {read=fOnSelectionChange, write=fOnSelectionChange};
	__property System::Classes::TNotifyEvent OnSelectionChanging = {read=fOnSelectionChanging, write=fOnSelectionChanging};
	__property System::Classes::TNotifyEvent OnMouseInSel = {read=fOnMouseInSel, write=fOnMouseInSel};
	__property bool DelayZoomFilter = {read=fDelayZoomFilter, write=fDelayZoomFilter, default=0};
	__property System::Classes::TNotifyEvent OnPaint = {read=fOnPaint, write=fOnPaint};
	__property bool EnableAlphaChannel = {read=fEnableAlphaChannel, write=SetEnableAlphaChannel, default=1};
	__property TIEMouseInResizingGripEvent OnMouseInResizingGrip = {read=fOnMouseInResizingGrip, write=fOnMouseInResizingGrip};
	__property TIEZoomEvent OnZoomIn = {read=fOnZoomIn, write=fOnZoomIn};
	__property TIEZoomEvent OnZoomOut = {read=fOnZoomOut, write=fOnZoomOut};
	__property Hyiedefs::TIEProgressEvent OnProgress = {read=GetOnProgress, write=SetOnProgress};
	__property System::Classes::TNotifyEvent OnFinishWork = {read=GetOnFinishWork, write=SetOnFinishWork};
	__property Imageenio::TIEAcquireBitmapEvent OnAcquireBitmap = {read=GetOnAcquireBitmap, write=SetOnAcquireBitmap};
	__property bool AutoStretch = {read=fAutoStretch, write=fAutoStretch, default=0};
	__property bool AutoShrink = {read=fAutoShrink, write=fAutoShrink, default=0};
	__property System::Classes::TNotifyEvent OnBeforeSelectionChange = {read=fOnBeforeSelectionChange, write=fOnBeforeSelectionChange};
	__property bool DrawVersion = {read=fDrawVersion, write=SetDrawVersion, default=0};
	__property System::Classes::TNotifyEvent OnDrawBackBuffer = {read=fOnDrawBackBuffer, write=fOnDrawBackBuffer};
	__property TIELayerNotify OnLayerNotify = {read=fOnLayerNotify, write=fOnLayerNotify};
	__property TIESpecialKeyEvent OnSpecialKey = {read=fOnSpecialKey, write=fOnSpecialKey};
	__property System::UnicodeString ImageEnVersion = {read=GetImageEnVersion, write=SetImageEnVersion, stored=false};
	__property TIEOnDrawBackground OnDrawBackground = {read=fOnDrawBackground, write=fOnDrawBackground};
	__property TIEOnDrawCanvas OnDrawCanvas = {read=fOnDrawCanvas, write=fOnDrawCanvas};
	__property Vcl::Graphics::TPicture* WallPaper = {read=fWallPaper, write=SetWallPaper};
	__property TIEWallPaperStyle WallPaperStyle = {read=fWallPaperStyle, write=SetWallPaperStyle, default=0};
	__property System::Classes::TNotifyEvent OnTransitionStop = {read=GetOnTransitionStop, write=SetOnTransitionStop};
	__property Iextransitions::TIETransitionStepEvent OnTransitionStep = {read=GetOnTransitionStep, write=SetOnTransitionStep};
	__property Iextransitions::TIEOnTransitionPaint OnTransitionPaint = {read=GetOnTransitionPaint, write=SetOnTransitionPaint};
	__property TIEDrawLayerBoxEvent OnDrawLayerBox = {read=fOnDrawLayerBox, write=fOnDrawLayerBox};
	__property TIEDrawLayerEvent OnDrawLayer = {read=fOnDrawLayer, write=fOnDrawLayer};
	__property TIEDrawLayerGrip OnDrawLayerGrip = {read=fOnDrawLayerGrip, write=fOnDrawLayerGrip};
	__property TIEOnDrawPolygon OnDrawPolygon = {read=fOnDrawPolygon, write=fOnDrawPolygon};
	__property Imageenproc::TIESaveUndoEvent OnSaveUndo = {read=GetOnSaveUndo, write=SetOnSaveUndo};
	__property Anchors = {default=3};
	__property OnMouseWheel;
	__property OnMouseWheelDown;
	__property OnMouseWheelUp;
	__property DragCursor = {default=-12};
	__property System::Classes::TNotifyEvent OnDShowNewFrame = {read=fOnDShowNewFrame, write=fOnDShowNewFrame};
	__property System::Classes::TNotifyEvent OnDShowEvent = {read=fOnDShowEvent, write=fOnDShowEvent};
	__property TIESetCursorEvent OnSetCursor = {read=fOnSetCursor, write=fOnSetCursor};
	__property TIEMediaFoundationNotifyEvent OnMediaFoundationNotify = {read=fOnMediaFoundationNotify, write=fOnMediaFoundationNotify};
	__property TIEVirtualKeyEvent OnVirtualKey = {read=fOnVirtualKey, write=fOnVirtualKey};
	__property bool EnableInteractionHints = {read=fEnableInteractionHints, write=fEnableInteractionHints, nodefault};
	__property bool Playing = {read=fPlaying, write=SetPlaying, default=0};
	__property bool PlayLoop = {read=fPlayLoop, write=fPlayLoop, default=1};
	__property System::Uitypes::TCursor Cursor = {read=fCursor, write=SetCursor, default=1785};
	__property bool FlatScrollBars = {read=fFlatScrollBars, write=SetFlatScrollBars, default=0};
	__property Align = {default=0};
	__property DragMode = {default=0};
	__property Enabled = {default=1};
	__property ParentShowHint = {default=1};
	__property PopupMenu;
	__property ShowHint;
	__property Visible = {default=1};
	__property TabOrder = {default=-1};
	__property TabStop = {default=0};
	__property OnClick;
	__property OnDblClick;
	__property OnDragDrop;
	__property OnDragOver;
	__property OnEndDrag;
	__property OnMouseDown;
	__property OnMouseMove;
	__property OnMouseUp;
	__property OnStartDrag;
	__property OnKeyDown;
	__property OnKeyPress;
	__property OnKeyUp;
	__property OnContextPopup;
	__property OnGesture;
public:
	/* TWinControl.CreateParented */ inline __fastcall TImageEnView(HWND ParentWindow) : Ieview::TIEView(ParentWindow) { }
	
};


//-- var, const, procedure ---------------------------------------------------
static const System::Int8 IEN_Send_To_Back = System::Int8(-9);
static const System::Int8 IEN_Send_Backward = System::Int8(-8);
static const System::Int8 IEN_Bring_Forward = System::Int8(-7);
static const System::Int8 IEN_Bring_To_Front = System::Int8(-6);
extern DELPHI_PACKAGE void __fastcall IEDrawBackground(System::Classes::TComponentState ComponentState, Vcl::Graphics::TCanvas* Canvas, Vcl::Graphics::TBitmap* Bitmap, Hyiedefs::TIEBackgroundStyle fBackgroundStyle, System::Uitypes::TColor fBackGround, int DestX, int DestY, int Width, int Height, int x1, int y1, int x2, int y2, int fChessboardSize, Vcl::Graphics::TBrushStyle fChessboardBrushStyle, System::Uitypes::TColor fGradientEndColor, Vcl::Graphics::TPicture* WallPaper, TIEWallPaperStyle WallPaperStyle);
extern DELPHI_PACKAGE bool __fastcall _IsRectangle(Hyiedefs::PPointArray p, int n);
extern DELPHI_PACKAGE void __fastcall IELayersMerge(TIELayer* Layer1, TIELayer* Layer2, TIELayer* LayerMask, Hyieutils::TIEBitmap* Destination, Hyiedefs::TResampleFilter ZoomFilter, System::Uitypes::TColor Background, bool RelativePositions);
extern DELPHI_PACKAGE bool __fastcall IETryLYR(System::Classes::TStream* Stream);
extern DELPHI_PACKAGE void __fastcall IEInitialize_imageenview(void);
extern DELPHI_PACKAGE void __fastcall IEFinalize_imageenview(void);
}	/* namespace Imageenview */
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_IMAGEENVIEW)
using namespace Imageenview;
#endif
#pragma pack(pop)
#pragma option pop

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