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

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

#ifndef imageenviewHPP
#define imageenviewHPP

#pragma delphiheader begin
#pragma option push
#if defined(__BORLANDC__) && !defined(__clang__)
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member 
#endif
#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 <System.Contnrs.hpp>
#include <hyiedefs.hpp>
#include <iexBitmaps.hpp>
#include <imageenio.hpp>
#include <imageenproc.hpp>
#include <ieview.hpp>
#include <iexTransitions.hpp>
#include <hyieutils.hpp>
#include <iexRulers.hpp>
#include <iexLayers.hpp>
#include <ietextc.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 TImageEnView;
class DELPHICLASS TIEUserInteraction;
class DELPHICLASS TIECropToolInteraction;
class DELPHICLASS TIECreateLayerInteraction;
//-- type declarations -------------------------------------------------------
enum DECLSPEC_DENUM TIEGrip : unsigned char { ieNone, ieTopLeft, ieTopRight, ieBottomRight, ieBottomLeft, ieLeftSide, ieRightSide, ieTopSide, ieBottomSide, ieRotationCenter };

enum DECLSPEC_DENUM TIEFastDrawing : unsigned char { iefFast, iefDelayed, iefNormal };

enum DECLSPEC_DENUM TIEGridKind : unsigned char { iedgNone, iedgPixelGrid, iedgGuideLines };

enum DECLSPEC_DENUM TIEAlignLayers : unsigned char { ilaAlignToLeft, ilaAlignToRight, ilaAlignToTop, ilaAlignToBottom, ilaAlignToHorizontalCenter, ilaAlignToVerticalCenter, ilaAlignLeftEdges, ilaAlignRightEdges, ilaAlignTopEdges, ilaAlignBottomEdges, ilaAlignHorizontalCenters, ilaAlignVerticalCenters, ilaMatchWidth, ilaMatchHeight };

enum DECLSPEC_DENUM Imageenview__1 : unsigned char { loAllowMultiSelect, loAutoSelectMask, loAutoUndoChangesByUser, loAutoUndoChangesByCode, loAutoPromptForImage, loAutoFixBorders, loAutoFixRotation, loDynamicCanvas };

typedef System::Set<Imageenview__1, Imageenview__1::loAllowMultiSelect, Imageenview__1::loDynamicCanvas> TIELayerOptions;

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

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

typedef void __fastcall (__closure *TIETextEditorEvent)(System::TObject* Sender, int Layer, System::TObject* Editor);

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 Winapi::Windows::TRect &ARect);

typedef void __fastcall (__closure *TIEOnDrawBackground)(System::TObject* Sender, Vcl::Graphics::TCanvas* ACanvas, const Winapi::Windows::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, miCropTool, miCreateImageLayers, miCreateShapeLayers, miCreateLineLayers, miCreatePolylineLayers, miCreateTextLayers };

typedef System::Set<TIEMouseInteractItems, TIEMouseInteractItems::miZoom, TIEMouseInteractItems::miCreateTextLayers> 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() : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TIEGestureOptions() { }
	
};


class PASCALIMPLEMENTATION TIEGesturePanOptions : public TIEGestureOptions
{
	typedef TIEGestureOptions inherited;
	
private:
	Winapi::Windows::TRect fBoundingBox;
	bool fPanWithSingleFingerVertically;
	bool fPanWithSingleFingerHorizontally;
	
public:
	__property Winapi::Windows::TRect BoundingBox = {read=fBoundingBox, write=fBoundingBox};
	__property bool PanWithSingleFingerVertically = {read=fPanWithSingleFingerVertically, write=fPanWithSingleFingerVertically, nodefault};
	__property bool PanWithSingleFingerHorizontally = {read=fPanWithSingleFingerHorizontally, write=fPanWithSingleFingerHorizontally, nodefault};
public:
	/* TObject.Create */ inline __fastcall TIEGesturePanOptions() : TIEGestureOptions() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TIEGesturePanOptions() { }
	
};


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() : TIEGestureOptions() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TIEGestureZoomOptions() { }
	
};


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


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() : TIEGestureOptions() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TIEGestureLayerRotateOptions() { }
	
};


class PASCALIMPLEMENTATION TIEViewerGestures : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	TIEGesturePanOptions* fPan;
	TIEGestureZoomOptions* fZoom;
	TIEGestureLayerRotateOptions* fLayerRotate;
	TIEGestureLayerMoveOptions* fLayerMove;
	bool __fastcall GetEnabled();
	
public:
	__fastcall TIEViewerGestures();
	__fastcall virtual ~TIEViewerGestures();
	__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};
};


enum DECLSPEC_DENUM Imageenview__8 : unsigned char { ienoMouseWheelZoom, ienoMarkOuter, ienoDontAssignNavBitmap, ienoDontPaintSrcBitmap, ienoDontRefreshSrcIfNavNotFocused };

typedef System::Set<Imageenview__8, Imageenview__8::ienoMouseWheelZoom, Imageenview__8::ienoDontRefreshSrcIfNavNotFocused> TIENavigatorOptions;

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

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

typedef System::Set<Imageenview__9, Imageenview__9::iesoAnimated, Imageenview__9::iesoAllowMoveByKeyboard> TIESelectionOptions;

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

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

enum DECLSPEC_DENUM TIELayerEvent : unsigned char { ielSelected, ielMoved, ielResized, ielMoving, ielResizing, ielRotating, ielRotated, ielBeginResizing, ielBeginMoving, ielDeselected, ielEdited, ielBeginCreating, ielCreating, ielCreated, ielAction };

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

typedef void __fastcall (__closure *TIENewLayerEvent)(System::TObject* Sender, int LayerIdx, Iexlayers::TIELayerKind LayerKind);

typedef void __fastcall (__closure *TIELayerMoveSizeEvent)(System::TObject* Sender, int layer, TIELayerEvent event, double &PosX, double &PosY, double &Width, double &Height);

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__01 : unsigned char { iegfBegin, iegfInertia, iegfEnd };

typedef System::Set<Imageenview__01, Imageenview__01::iegfBegin, Imageenview__01::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, iearLayerDefaultOnCornerGrip };

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 fActualZoomFilter;
	bool fDelayZoomFilter;
	Hyiedefs::TIEBackgroundStyle fBackgroundStyle;
	bool fMagicWandMaxFilter;
	int fMagicWandTolerance;
	TIEMagicWandMode fMagicWandMode;
	double fRXScroll;
	double fRYScroll;
	TIEGridKind fDisplayGridKind;
	int fDisplayGridLyr;
	Winapi::Windows::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;
	TIELayerMoveSizeEvent fOnLayerMoveSize;
	System::Classes::TNotifyEvent fOnLayerSelectionChange;
	TIENewLayerEvent fOnNewLayer;
	double fSelectionAspectRatio;
	int fSelectionAbsWidth;
	int fSelectionAbsHeight;
	TIESpecialKeyEvent fOnSpecialKey;
	TImageEnView* fNavigator;
	TIENavigatorOptions fNavigatorOptions;
	bool fNavigatorInside;
	bool fIsNavigator;
	Iexbitmaps::TIEBitmap* fNavigatorBackBuffer;
	Winapi::Windows::TRect fNavigatorActualRect;
	bool fUpdateInsideUpdate;
	bool fInsideUpdate;
	int fDelayTimer;
	Winapi::Windows::TRect fLyrResizingClientAreaBox;
	System::StaticArray<System::Types::TPoint, 4> fLyrResizingRotatedBox;
	bool fZoomSelectionAspectRatio;
	double fMouseScrollRate;
	TIEOnDrawPolygon fOnDrawPolygon;
	Hyiedefs::TIEAntialiasMode fLayersRotationFilter;
	bool fLayersRotationAntialias;
	bool fLayersRotationUseFilterOnPreview;
	int fUpdate_MaskCache;
	bool fLayersSelectConstrains;
	TIELayersResizeAspectRatio fLayersResizeAspectRatio;
	double fLayersResizingAR;
	TIEFastDrawing fLayersFastDrawing;
	bool fLayersFastOutput;
	bool fLayersCropped;
	int fSelectionGridWidth;
	int fSelectionGridHeight;
	int fMarkOuterAlpha;
	System::Uitypes::TColor fMarkOuterColor;
	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;
	Winapi::Windows::THandle fOldHandle;
	Iexlayers::TIEDrawLayerEvent fOnDrawLayer;
	Iexlayers::TIEDrawLayerBoxEvent fOnDrawLayerBox;
	Iexlayers::TIEDrawLayerGrip fOnDrawLayerGrip;
	bool fVisibleSelection;
	bool fOffscreenPaint;
	bool fFirstTimeSetCursor;
	int fLayersRotateStep;
	Hyiedefs::TResampleFilter fLayersMergeFilter;
	Vcl::Graphics::TPicture* fWallpaper;
	TIEWallpaperStyle fWallpaperStyle;
	Vcl::Graphics::TBitmap* fDrawPixelBitmap;
	Hyiedefs::PRGB 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;
	bool fNeedUpdateLiveBackground;
	Iexbitmaps::TIEBitmap* fLiveBackground;
	System::Contnrs::TObjectList* fUserInteractions;
	Iexrulers::TRulerDirs fShowRulers;
	Iexrulers::TIEViewRulerParams* fRulerParams;
	int fEditingLayer;
	Ietextc::TIEEdit* fTextEditor;
	Vcl::Controls::TKeyEvent fOnTextEditorKeyDown;
	TIETextEditorEvent fOnActivateTextEditor;
	TIETextEditorEvent fOnDeactivateTextEditor;
	int fNextLayerPosition;
	bool fModified;
	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();
	int __fastcall GetSelY1();
	int __fastcall GetSelX2();
	int __fastcall GetSelY2();
	void __fastcall SetCenter(bool value);
	bool __fastcall GetCenter();
	void __fastcall SetImageHorizAlignment(Hyieutils::TIEHAlign value);
	void __fastcall SetImageVertAlignment(Hyieutils::TIEVAlign value);
	TIEMouseInteract __fastcall GetMouseInteract();
	TIECropToolInteraction* __fastcall GetCropToolInteraction();
	void __fastcall SetBackgroundStyle(Hyiedefs::TIEBackgroundStyle v);
	void __fastcall DoSelectionChange();
	void __fastcall DoSelectionChanging();
	void __fastcall DoBeforeSelectionChange();
	void __fastcall DoMouseInResizingGrip(TIEGrip Grip);
	void __fastcall DoMouseInSel();
	void __fastcall DoZoomIn(double &NewZoom);
	void __fastcall DoZoomOut(double &NewZoom);
	void __fastcall SetSelectionOptions(TIESelectionOptions v);
	Hyiedefs::TIERectangle __fastcall GetSelectedRect();
	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 __fastcall SetScrollBarsAlwaysVisible(bool v);
	bool __fastcall GetDisplayGrid();
	void __fastcall SetDisplayGrid(bool v);
	bool __fastcall GetAutoFixRotationBorders();
	void __fastcall SetAutoFixRotationBorders(bool v);
	void __fastcall SetDisplayGridKind(TIEGridKind v);
	void __fastcall SetDisplayGridLyr(int v);
	bool __fastcall GetTransitionRunning();
	int __fastcall GetLayersCount();
	void __fastcall SetLayersCaching(int v);
	Iexlayers::TIELayer* __fastcall GetLayer(int idx);
	void __fastcall PaintSelection(Vcl::Graphics::TBitmap* OutBitmap);
	void __fastcall PaintPixelGrid(Vcl::Graphics::TBitmap* OutBitmap);
	void __fastcall PaintGuideLines(Vcl::Graphics::TCanvas* Canvas);
	HIDESBASE void __fastcall SetCursor(System::Uitypes::TCursor Value);
	void __fastcall SetDelayTimer(int Value);
	int __fastcall GetDelayTimer();
	void __fastcall SetGradientEndColor(System::Uitypes::TColor Value);
	void __fastcall DoDrawVersion();
	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 __fastcall SetFlatScrollBars(bool Value);
	void __fastcall SwapSelectionBase();
	void __fastcall NavigatorSelectionChanging(System::TObject* Sender);
	void __fastcall NavigatorMouseWheel(System::TObject* Sender, System::Classes::TShiftState Shift, int WheelDelta, const Winapi::Windows::TPoint &MousePos, bool &Handled);
	void __fastcall SetNavigatorRect();
	System::UnicodeString __fastcall GetImageEnVersion();
	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 __fastcall SetOnTransitionStep(Iextransitions::TIETransitionStepEvent value);
	Iextransitions::TIETransitionStepEvent __fastcall GetOnTransitionStep();
	void __fastcall SetTransitionTiming(Iextransitions::TIETransitionTiming value);
	Iextransitions::TIETransitionTiming __fastcall GetTransitionTiming();
	void __fastcall SetWallpaper(Vcl::Graphics::TPicture* Value);
	void __fastcall SetWallpaperStyle(TIEWallpaperStyle Value);
	Winapi::Windows::TRect __fastcall AdjustRectToAspectRatio(const Winapi::Windows::TRect &ARect, bool TransitionActive);
	void __fastcall DoOnDrawPolygon(int polygon, int point, Vcl::Graphics::TCanvas* Canvas, int x, int y);
	Vcl::Graphics::TBitmap* __fastcall GetBackBuffer();
	void __fastcall SetOnSaveUndo(Imageenproc::TIESaveUndoEvent value);
	Imageenproc::TIESaveUndoEvent __fastcall GetOnSaveUndo();
	void __fastcall ZoomSelectionEx(bool AspectRatio, bool FireDoZoomIn);
	void __fastcall SetSoftCrop(TIESoftCropMode v);
	void __fastcall SetSoftCropValue(int v);
	void __fastcall SetHighlightedPixel(const Winapi::Windows::TPoint &v);
	void __fastcall SetOnTransitionPaint(const Iextransitions::TIEOnTransitionPaint Value);
	Iextransitions::TIEOnTransitionPaint __fastcall GetOnTransitionPaint();
	void __fastcall SetSmoothScrollValue(int v);
	void __fastcall SetSmoothZoomValue(int v);
	void __fastcall SetupAniPolyTimer();
	void __fastcall SetupTransition();
	void __fastcall SetupDrawPixelBitmap();
	void __fastcall TerminatePolySelection(bool shift, bool removeLastPoint);
	void __fastcall DrawMarkOutNavigator(const Winapi::Windows::TRect &rc);
	void __fastcall SetHighlightedPixelColor(System::Uitypes::TColor c);
	int __fastcall GetSelectionGridSize();
	void __fastcall SetSelectionGridSize(int value);
	void __fastcall SetPlaying(const bool v);
	void __fastcall StartPlayTimer();
	void __fastcall StopPlayTimer();
	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);
	void __fastcall SetLayerOptions(const TIELayerOptions Value);
	System::Classes::TStringList* __fastcall GetLayerDefaults();
	void __fastcall SetLayersCropped(const bool Value);
	int __fastcall MultiSelectedLayersCount();
	Hyiedefs::TIEArrayOfInteger __fastcall MultiSelectedLayersList();
	void __fastcall SetDisplayStable(bool value);
	void __fastcall UpdateLiveBackground(Iexbitmaps::TIEBitmap* Src);
	void __fastcall SetShowRulers(const Iexrulers::TRulerDirs v);
	Iexrulers::TRulerClickEvent __fastcall GetOnRulerClick();
	Iexrulers::TRulerGripClickEvent __fastcall GetOnRulerGripClick();
	Iexrulers::TRulerGripClickEvent __fastcall GetOnRulerGripDblClick();
	Iexrulers::TRulerGripPosChangeEvent __fastcall GetOnRulerGripPosChange();
	void __fastcall SetOnRulerClick(const Iexrulers::TRulerClickEvent Value);
	void __fastcall SetOnRulerGripClick(const Iexrulers::TRulerGripClickEvent Value);
	void __fastcall SetOnRulerGripDblClick(const Iexrulers::TRulerGripClickEvent Value);
	void __fastcall SetOnRulerGripPosChange(const Iexrulers::TRulerGripPosChangeEvent Value);
	int __fastcall fIEBitmap_Width();
	int __fastcall fIEBitmap_Height();
	bool __fastcall GetModified();
	void __fastcall SetModified(bool value);
	
protected:
	int fDelayZoomTicks;
	int fDelayAniSelTicks;
	int fStable;
	int fStable2;
	TIEUpdateReason fUpdateReason;
	bool fUpdateBackBuffer;
	Iexbitmaps::TIEBitmap* fBackBuffer;
	double fZoomX;
	double fZoomY;
	double fZoomD100X;
	double f100DZoomX;
	double fZoomD100Y;
	double f100DZoomY;
	Hyiedefs::hDrawDib fHDrawDib;
	Hyiedefs::TIEScrollStyle fScrollBars;
	int fLockPaint;
	int fOffX;
	int fOffY;
	int fExtX;
	int fExtY;
	int fZZWW;
	int fZZHH;
	int fViewX;
	int fViewY;
	int fUpdateLocked;
	Hyiedefs::TBitmapInfoHeader256 fBitmapInfoHeader256;
	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;
	Iexbitmaps::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 fChessboardColor2Customized;
	bool fForceALTkey;
	bool fMouseMoveScrolling;
	System::Classes::TList* fSavedSelection;
	bool fEnableShiftKey;
	System::Uitypes::TColor fGradientEndColor;
	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;
	Imageenio::TImageEnIO* fImageEnIO;
	Imageenproc::TImageEnProc* fImageEnProc;
	System::Classes::TList* fLayers;
	int fLayersCurrent;
	Hyiedefs::TIERectangle fLayersRect;
	TIELayerOptions fLayerOptions;
	System::Classes::TStringList* fLayerDefaults;
	bool fLayersDrawBox;
	int fLayersCaching;
	int fMovingLayer;
	bool fLayerMoved;
	int fRotatingLayer;
	double fRotatingLayerValue;
	int fMovingRotationCenter;
	TIEGrip fLayerResizing;
	bool fMovResRotLayerStarted;
	Hyiedefs::pIntegerArray fGXScr2Bmp;
	Hyiedefs::pIntegerArray fGYScr2Bmp;
	int fGXScr2BmpSize;
	int fGYScr2BmpSize;
	Hyiedefs::pIntegerArray fXScr2Bmp;
	Hyiedefs::pIntegerArray fYScr2Bmp;
	int fXScr2BmpSize;
	int fYScr2BmpSize;
	Hyiedefs::pIntegerArray fXBmp2Scr;
	Hyiedefs::pIntegerArray fYBmp2Scr;
	Hyiedefs::pIntegerArray fGXBmp2Scr;
	Hyiedefs::pIntegerArray 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 &LeftEdge, int &TopEdge, int &RightEdge, int &BottomEdge, bool NoVertSB, bool NoHorizSB);
	virtual void __fastcall SetBackground(System::Uitypes::TColor cl);
	void __fastcall PolyDraw1();
	virtual void __fastcall SetScrollBars(Hyiedefs::TIEScrollStyle v);
	virtual void __fastcall CreateHandle();
	double __fastcall GetOptimalZoom(bool CanStretch, bool CanShrink);
	void __fastcall DoSize();
	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();
	DYNAMIC bool __fastcall PaletteChanged(bool Foreground);
	HIDESBASE MESSAGE void __fastcall WMLButtonDblClk(Winapi::Messages::TWMLButtonDblClk &Message);
	HIDESBASE MESSAGE void __fastcall WMKillFocus(Winapi::Messages::TWMKillFocus &Msg);
	HIDESBASE MESSAGE void __fastcall WMSetFocus(Winapi::Messages::TWMSetFocus &Msg);
	MESSAGE void __fastcall CMWantSpecialKey(Vcl::Controls::TCMWantSpecialKey &Msg);
	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 __fastcall ShowSelectionEx(bool d);
	void __fastcall HideSelectionEx(bool dd);
	int __fastcall GetIdealComponentWidth();
	int __fastcall GetIdealComponentHeight();
	int __fastcall GetIdealImageWidth();
	int __fastcall GetIdealImageHeight();
	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);
	Winapi::Windows::TPoint __fastcall GetPolySel(int idx);
	int __fastcall GetPolySelCount();
	virtual void __fastcall SetMouseInteract(TIEMouseInteract v);
	void __fastcall SetMouseWheelParams(Hyieutils::TIEMouseWheelParams* 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);
	void __fastcall MouseMoveScroll();
	virtual Vcl::Graphics::TBitmap* __fastcall GetFBitmap();
	virtual Iexbitmaps::TIEBitmap* __fastcall GetIEBitmap();
	void __fastcall SetVisibleSelection(bool vv);
	bool __fastcall GetVisibleSelection();
	Hyiedefs::PPointArray __fastcall GetPolySelArray();
	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 __fastcall SelectEx(int x1, int y1, int x2, int y2, TIESelOp Op, bool aspectratio, bool adjRect);
	HIDESBASE virtual int __fastcall GetClientWidth();
	int __fastcall GetClientWidthExRulers();
	HIDESBASE virtual int __fastcall GetClientHeight();
	int __fastcall GetClientHeightExRulers();
	virtual bool __fastcall HasParentWindow();
	void __fastcall SetSelColor1(System::Uitypes::TColor v);
	void __fastcall SetSelColor2(System::Uitypes::TColor v);
	Imageenio::TImageEnIO* __fastcall GetImageEnIO();
	Imageenproc::TImageEnProc* __fastcall GetImageEnProc();
	void __fastcall SetEnableAlphaChannel(bool v);
	virtual void __fastcall SetOnProgress(Hyiedefs::TIEProgressEvent v);
	virtual System::Classes::TNotifyEvent __fastcall GetOnFinishWork();
	virtual void __fastcall SetOnFinishWork(System::Classes::TNotifyEvent v);
	virtual void __fastcall SetOnAcquireBitmap(Imageenio::TIEAcquireBitmapEvent v);
	virtual Imageenio::TIEAcquireBitmapEvent __fastcall GetOnAcquireBitmap();
	virtual Hyiedefs::TIEProgressEvent __fastcall GetOnProgress();
	virtual bool __fastcall GetHasAlphaChannel();
	virtual Iexbitmaps::TIEBitmap* __fastcall GetAlphaChannel();
	virtual bool __fastcall GetIsEmpty();
	virtual bool __fastcall GetIsEmpty2();
	bool __fastcall RequiresScrollBars();
	virtual void __fastcall SetLayersCurrent(int Value);
	bool __fastcall SetLayersCurrentEx(int Value, bool bUserAction, bool bDeselectAll, bool DoUpdate = true);
	void __fastcall SelectMaskOfLayer(int iLayerIndex, bool bSelect, bool bUserAction);
	void __fastcall SyncBitmapToCurrentLayer();
	bool __fastcall SyncLayers();
	bool __fastcall MouseChangingLayers();
	virtual void __fastcall SetLegacyBitmap(bool Value);
	virtual void __fastcall CreateCoordConvLUT();
	virtual void __fastcall CalcPaintCoords();
	void __fastcall CalcPaintCoordsEx(int &XSrc, int &YSrc, int &SrcWidth, int &SrcHeight, int &DstWidth, int &DstHeight, int tViewX, int tViewY);
	virtual void __fastcall UpdateLimits();
	int __fastcall QuantizeViewX(int vx);
	int __fastcall QuantizeViewY(int vy);
	void __fastcall HideHorizScrollBar();
	void __fastcall HideVertScrollBar();
	void __fastcall SetSelectionIntensity(int value);
	void __fastcall SetLayersDrawBox(bool value);
	virtual void __fastcall DoLayerNotify(int layer, TIELayerEvent event);
	void __fastcall SetTempCursor(System::Uitypes::TCursor Value, bool bOnMouseDown = false);
	Iexlayers::TIELayer* __fastcall GetCurrentLayer();
	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 __fastcall OnSmoothZoom(System::TObject* Sender);
	void __fastcall StopSmoothZoom();
	virtual void __fastcall DrawSelectionGrid(int x1, int y1, int x2, int y2);
	virtual void __fastcall AfterDrawLayer(int layerIndex, Iexbitmaps::TIEBitmap* DestBitmap, const Winapi::Windows::TRect &DestRect);
	void __fastcall SetVisibleBitmapRect(const Winapi::Windows::TRect &ARect);
	Winapi::Windows::TRect __fastcall GetVisibleBitmapRect();
	bool __fastcall LayersAllowMultiSelect();
	void __fastcall MoveSelByKey(System::Word VKey, System::Classes::TShiftState ss);
	bool __fastcall UserInteractions_MouseDownExclusive(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y);
	void __fastcall UserInteractions_MouseDown(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y);
	bool __fastcall UserInteractions_MouseMoveExclusive(System::Classes::TShiftState Shift, int X, int Y, bool Captured);
	void __fastcall UserInteractions_MouseMove(System::Classes::TShiftState Shift, int X, int Y, bool Captured);
	bool __fastcall UserInteractions_MouseUpExclusive(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y);
	void __fastcall UserInteractions_MouseUp(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y);
	void __fastcall UserInteractions_VirtualKey(unsigned VKey, unsigned KeyData, bool KeyDown);
	void __fastcall UserInteractions_Paint(const Winapi::Windows::TRect &UpdateRect);
	int __fastcall GetDPIX();
	int __fastcall GetDPIY();
	virtual void __fastcall SetDPIX(int dpiX);
	virtual void __fastcall SetDPIY(int dpiY);
	bool __fastcall GetLayersRotationDelayFilterOnPreview();
	void __fastcall SetLayersRotationDelayFilterOnPreview(bool value);
	void __fastcall UpdateTextEditor();
	void __fastcall TextEditorKeyDown(System::TObject* Sender, System::Word &Key, System::Classes::TShiftState Shift);
	void __fastcall TextEditorOnChange(System::TObject* Sender);
	
public:
	bool fIEBitmapValid;
	Iexbitmaps::TIEBitmap* fIEBitmap;
	Vcl::Graphics::TBitmap* fBitmap;
	__fastcall virtual TImageEnView(System::Classes::TComponent* Owner);
	__fastcall virtual ~TImageEnView();
	virtual void __fastcall Paint();
	virtual void __fastcall PaintToEx(Iexbitmaps::TIEBitmap* ABitmap, Winapi::Windows::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 GetMinViewXY(int &mx, int &my);
	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 __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();
	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 SelectNonAlpha(TIESelOp Op = (TIESelOp)(0x0));
	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 __fastcall MoveSelection(int MoveX, int MoveY, bool Sizing = false);
	__property double SelectionAspectRatio = {read=fSelectionAspectRatio, write=SetSelectionAspectRatio};
	void __fastcall SetSelectionMarkOuterStyle(int Alpha, System::Uitypes::TColor Color);
	void __fastcall SelectByGroupIndex(int iGroupIndex, bool bSelect, bool bUserAction);
	__property int SelectionAbsWidth = {read=fSelectionAbsWidth, write=fSelectionAbsWidth, nodefault};
	__property int SelectionAbsHeight = {read=fSelectionAbsHeight, write=fSelectionAbsHeight, nodefault};
	__property bool AutoFixRotationBorders = {read=GetAutoFixRotationBorders, write=SetAutoFixRotationBorders, nodefault};
	void __fastcall Deselect();
	__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 __fastcall DelLastSelPoint();
	__property Winapi::Windows::TPoint PolySel[int idx] = {read=GetPolySel};
	__property int PolySelCount = {read=GetPolySelCount, nodefault};
	__property Hyiedefs::PPointArray PolySelPoints = {read=GetPolySelArray};
	__property Winapi::Windows::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 Iexbitmaps::TIEMask* SelectionMask = {read=fSelectionMask};
	void __fastcall InvertSelection();
	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 ApplyBitmapToSelection(Vcl::Graphics::TBitmap* SrcBitmap, bool MaintainAspectRatio = true, bool CanStretch = false)/* overload */;
	void __fastcall ApplyBitmapToSelection(Iexbitmaps::TIEBitmap* SrcBitmap, bool MergeAlpha = true, bool MaintainAspectRatio = true, bool CanStretch = false)/* overload */;
	void __fastcall CopySelectionToBitmap(Vcl::Graphics::TBitmap* DestBitmap, bool FillBackground = true)/* overload */;
	void __fastcall CopySelectionToBitmap(Iexbitmaps::TIEBitmap* DestBitmap, bool FillBackground = true)/* overload */;
	void __fastcall CopySelectionToIEBitmap(Iexbitmaps::TIEBitmap* DestBitmap, bool FillBackground = true);
	virtual void __fastcall EndSelect();
	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();
	bool __fastcall DiscardSavedSelection();
	__property int SavedSelectionsCount = {read=GetSavedSelectionsCount, nodefault};
	__property bool EnableShiftKey = {read=fEnableShiftKey, write=fEnableShiftKey, nodefault};
	void __fastcall LayersSizeAll(double HorzSizing, double VertSizing, bool bSelectedOnly = false, bool bFixSizes = false, bool ScalePosition = false);
	void __fastcall LayersRotateAll(double Value, bool bSelectedOnly = false, bool bFixRotations = false);
	void __fastcall LayersRepositionAll(int MoveX, int MoveY, bool SelectedOnly = false, bool Sizing = false);
	__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=GetLayersRotationDelayFilterOnPreview, write=SetLayersRotationDelayFilterOnPreview, 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, const System::Types::TPoint *Polygon, const System::NativeInt Polygon_High, int PolygonLen, const Winapi::Windows::TPoint &Position);
	void __fastcall CopyToPolygon(Vcl::Graphics::TBitmap* Dest, const System::Types::TPoint *Polygon, const System::NativeInt Polygon_High, int PolygonLen, const Winapi::Windows::TPoint &Position);
	virtual void __fastcall Update();
	__property TIEUpdateReason UpdateReason = {read=fUpdateReason, write=fUpdateReason, nodefault};
	void __fastcall UpdateNoPaint();
	__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(bool StretchSmall = true);
	void __fastcall FitToWidth();
	void __fastcall FitToHeight();
	void __fastcall Stretch();
	double __fastcall GetIdealZoom();
	__property int ViewX = {read=fViewX, write=SetViewX, nodefault};
	__property int ViewY = {read=fViewY, write=SetViewY, nodefault};
	void __fastcall CenterImage();
	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 __fastcall ZoomOut();
	__property ClientWidth = {read=GetClientWidth};
	__property ClientHeight = {read=GetClientHeight};
	__property int IdealComponentWidth = {read=GetIdealComponentWidth, nodefault};
	__property int IdealComponentHeight = {read=GetIdealComponentHeight, nodefault};
	__property int IdealImageWidth = {read=GetIdealImageWidth, nodefault};
	__property int IdealImageHeight = {read=GetIdealImageHeight, nodefault};
	virtual void __fastcall LockPaint();
	virtual int __fastcall UnLockPaint();
	virtual int __fastcall NPUnLockPaint();
	__property int LockPaintCount = {read=fLockPaint, nodefault};
	__property int LockUpdateCount = {read=fUpdateLocked, 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 Winapi::Windows::TRect &rclip);
	void __fastcall PaintRect(const Winapi::Windows::TRect &rc);
	void __fastcall LockUpdate();
	void __fastcall UnLockUpdate();
	void __fastcall UnLockUpdateEx();
	__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 LayersAddEx(Iexlayers::TIELayerKind Kind, int PosX = 0xffffffff, int PosY = 0xffffffff, int Width = 0x0, int Height = 0x0, Iexbitmaps::TIEBitmap* SrcBitmap = (Iexbitmaps::TIEBitmap*)(0x0), bool DoCopyBitmap = true, bool DoSaveUndo = false, bool AssignDefaults = false, bool SelLayer = true);
	int __fastcall LayersAdd(Iexlayers::TIELayerKind Kind = (Iexlayers::TIELayerKind)(0x0))/* overload */;
	int __fastcall LayersAdd(int Width, int Height, Hyieutils::TIEPixelFormat PixelFormat = (Hyieutils::TIEPixelFormat)(0x5), int PosX = 0xffffffff, int PosY = 0xffffffff)/* overload */;
	int __fastcall LayersAdd(Iexbitmaps::TIEBitmap* Bitmap, bool DoCopy = true)/* overload */;
	int __fastcall LayersAdd(System::WideString FileName, int PosX = 0xffffffff, int PosY = 0xffffffff)/* overload */;
	int __fastcall LayersAdd(Hyiedefs::TIEShape Shape, int PosX = 0xffffffff, int PosY = 0xffffffff, int Width = 0x0, int Height = 0x0)/* overload */;
	int __fastcall LayersAdd(const System::UnicodeString Text, int FontSize, System::Uitypes::TColor FontColor, const System::UnicodeString FontName, System::Uitypes::TFontStyles FontStyle = System::Uitypes::TFontStyles() , int PosX = 0xffffffff, int PosY = 0xffffffff)/* overload */;
	int __fastcall LayersInsertEx(int Position, Iexlayers::TIELayerKind Kind, int PosX = 0xffffffff, int PosY = 0xffffffff, int Width = 0x0, int Height = 0x0, Iexbitmaps::TIEBitmap* SrcBitmap = (Iexbitmaps::TIEBitmap*)(0x0), bool DoCopyBitmap = true, bool DoSaveUndo = false, bool AssignDefaults = false, bool SelLayer = true);
	void __fastcall LayersInsert(int Position, Iexlayers::TIELayerKind Kind = (Iexlayers::TIELayerKind)(0x0))/* overload */;
	void __fastcall LayersInsert(int Position, int Width, int Height, Hyieutils::TIEPixelFormat PixelFormat = (Hyieutils::TIEPixelFormat)(0x5), int PosX = 0xffffffff, int PosY = 0xffffffff)/* overload */;
	void __fastcall LayersInsert(int Position, Iexbitmaps::TIEBitmap* Bitmap, bool DoCopy = true)/* overload */;
	void __fastcall LayersInsert(int Position, System::WideString FileName, int PosX = 0xffffffff, int PosY = 0xffffffff)/* overload */;
	void __fastcall LayersInsert(int Position, Hyiedefs::TIEShape Shape, int PosX = 0xffffffff, int PosY = 0xffffffff, int Width = 0x0, int Height = 0x0)/* overload */;
	void __fastcall LayersInsert(int Position, const System::UnicodeString Text, int FontSize, System::Uitypes::TColor FontColor, const System::UnicodeString FontName, System::Uitypes::TFontStyles FontStyle = System::Uitypes::TFontStyles() , int PosX = 0xffffffff, int PosY = 0xffffffff)/* overload */;
	void __fastcall LayersRemoveEx(int LyrIndex = 0xfffffffe, bool SaveUndo = false);
	virtual void __fastcall LayersRemove(int LyrIndex = 0xfffffffe);
	void __fastcall LayersClear();
	void __fastcall LayersMove(int CurIndex, int NewIndex);
	void __fastcall LayersMerge(int Layer1, int Layer2, bool RemoveUpperLayer = true)/* overload */;
	void __fastcall LayersMerge(int *LayerList, const System::NativeInt LayerList_High)/* overload */;
	void __fastcall LayersMerge(Hyiedefs::TIEArrayOfInteger LayerList)/* overload */;
	void __fastcall LayersMerge()/* overload */;
	void __fastcall LayersMergeTo(int Layer1, int Layer2, Iexbitmaps::TIEBitmap* Destination);
	void __fastcall LayersDrawTo(Iexbitmaps::TIEBitmap* Destination, bool AdjustBitmap = true);
	void __fastcall LayersSaveMergedTo(Iexbitmaps::TIEBitmap* Destination, bool FastOutput = false)/* overload */;
	void __fastcall LayersSaveMergedTo(const System::UnicodeString Filename, bool FastOutput = false)/* overload */;
	void __fastcall LayersSaveMergedTo(System::Classes::TStream* const Stream, Hyieutils::TIOFileType FileType, bool FastOutput = false)/* overload */;
	void __fastcall LayersMergeAll(bool AlphaCompositing = false);
	void __fastcall LayersCopyToAlpha(int DestLayer);
	void __fastcall LayersCropBackground(bool SelectedOnly = false, int FillAlpha = 0xff, bool AllowReduce = true, bool AllowEnlarge = true);
	void __fastcall LayersActivateTextEditor(int LayerIdx);
	void __fastcall LayersCancelEditor(bool SaveChanges = true);
	int __fastcall LayersCreateFromAlpha();
	int __fastcall LayersCreateFromEdge(int ScreenX, int ScreenY, int Tolerance, bool MaxFilter = false);
	void __fastcall LayersSetPropertiesEx(int LayerIndex, System::Classes::TStrings* Props, const System::UnicodeString PropName, const System::UnicodeString Value, bool SaveUndo, System::UnicodeString UndoMsg);
	void __fastcall LayersSetProperties(int LayerIndex, System::Classes::TStrings* Props)/* overload */;
	void __fastcall LayersSetProperties(int LayerIndex, const System::Variant &PropName, const System::Variant &Value)/* overload */;
	__property int LayersCaching = {read=fLayersCaching, write=SetLayersCaching, nodefault};
	__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 Hyiedefs::TResampleFilter LayersMergeFilter = {read=fLayersMergeFilter, write=fLayersMergeFilter, nodefault};
	__property bool LayersSelectConstrains = {read=fLayersSelectConstrains, write=fLayersSelectConstrains, nodefault};
	__property Iexlayers::TIELayer* Layers[int idx] = {read=GetLayer};
	__property TIELayerOptions LayerOptions = {read=fLayerOptions, write=SetLayerOptions, nodefault};
	__property System::Classes::TStringList* LayerDefaults = {read=GetLayerDefaults};
	__property System::Classes::TList* LayersList = {read=fLayers};
	__property TIELayersResizeAspectRatio LayersResizeAspectRatio = {read=fLayersResizeAspectRatio, write=fLayersResizeAspectRatio, nodefault};
	__property bool LayersCropped = {read=fLayersCropped, write=SetLayersCropped, nodefault};
	__property TIEFastDrawing LayersFastDrawing = {read=fLayersFastDrawing, write=fLayersFastDrawing, nodefault};
	bool __fastcall LayersFastDrawingActive();
	__property bool LayersFastOutput = {read=fLayersFastOutput, write=fLayersFastOutput, nodefault};
	int __fastcall MaxLayerWidth();
	int __fastcall MaxLayerHeight();
	Hyiedefs::TIERectangle __fastcall LayersRect(bool SelOnly = false, bool ExcludeLayer0 = false);
	__property bool LayersDrawBox = {read=fLayersDrawBox, write=SetLayersDrawBox, nodefault};
	int __fastcall FindLayerAt(int x, int y, bool SelectablesOnly = true);
	__property Iexlayers::TIELayer* CurrentLayer = {read=GetCurrentLayer};
	void __fastcall LayersSaveToStream(System::Classes::TStream* Stream, Hyieutils::TIOFileType CompressionFormat = 0xffffffff, bool SelectedOnly = false, bool ExcludeImageLayers = false, bool SaveThumbnail = false, Hyiedefs::TIEProgressEvent ProgressEvent = 0x0);
	void __fastcall LayersSaveToFile(const System::UnicodeString FileName, Hyieutils::TIOFileType CompressionFormat = 0xffffffff);
	void __fastcall LayersSelectAll(bool bIncludeLocked = true);
	void __fastcall LayersAlign(TIEAlignLayers Alignment, int Index = 0xfffffffe);
	int __fastcall LayersSelCount(bool bCountBackgroundLayer = true);
	void __fastcall LayersDeselectAll();
	void __fastcall LayersGroup(bool bSelectedOnly = true);
	void __fastcall LayersConvertToImageLayersEx(int LayerIdx = 0xfffffffe, double QualityFactor = 2.000000E+00, bool CropAlpha = true, bool ConvertImages = false, bool DoSaveUndo = false);
	void __fastcall LayersConvertToImageLayers(int LayerIdx = 0xfffffffe, double QualityFactor = 2.000000E+00, bool CropAlpha = true, bool ConvertImages = false);
	void __fastcall LayersUngroup(bool bSelectedOnly = true);
	bool __fastcall LayersLoadFromStream(System::Classes::TStream* Stream, bool Append = false, Hyiedefs::TIEProgressEvent ProgressEvent = 0x0);
	bool __fastcall LayersLoadFromFile(const System::UnicodeString FileName, bool Append = false);
	int __fastcall LayersCreateFromSelection();
	int __fastcall LayersCreateFromClipboard();
	int __fastcall LayersCreateFromFile(System::UnicodeString Filename = System::UnicodeString());
	int __fastcall LayersImport(const System::UnicodeString FileName, System::Classes::TStream* Stream = (System::Classes::TStream*)(0x0), Hyieutils::TIOFileType FileFormat = 0x0, bool Append = false);
	int __fastcall LayersCreateFromText(const System::UnicodeString Text, 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(Iexbitmaps::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();
	int __fastcall YScr2Bmp(int y, bool CurrentLayer = false);
	int __fastcall XScr2Bmp(int x, bool CurrentLayer = false);
	int __fastcall YBmp2Scr(int y, bool CurrentLayer = false);
	int __fastcall XBmp2Scr(int x, bool CurrentLayer = false);
	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 __fastcall ClearAll();
	void __fastcall Blank();
	__property bool DisplayGrid = {read=GetDisplayGrid, write=SetDisplayGrid, nodefault};
	__property int DisplayGridLyr = {read=fDisplayGridLyr, write=SetDisplayGridLyr, nodefault};
	__property Winapi::Windows::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};
	void __fastcall SetChessboardStyle(int Size = 0x10, Vcl::Graphics::TBrushStyle BrushStyle = (Vcl::Graphics::TBrushStyle)(0x0), System::Uitypes::TColor Color1 = (System::Uitypes::TColor)(0x1fffffff), System::Uitypes::TColor Color2 = (System::Uitypes::TColor)(0x1fffffff));
	__property bool ForceALTkey = {read=fForceALTkey, write=fForceALTkey, nodefault};
	__property bool DelayDisplaySelection = {read=fDelayDisplaySelection, write=fDelayDisplaySelection, nodefault};
	__property int DelayZoomTime = {read=fDelayZoomTicks, write=fDelayZoomTicks, 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 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 __fastcall RunTransition(Iextransitions::TIETransitionType Effect, int Duration)/* overload */;
	void __fastcall RunTransition(Iextransitions::TIETransitionType Effect, int Duration, Iextransitions::TIEPanZoomType PanZoomEffect, int iZoomLevel, int Smoothing = 0x60)/* overload */;
	void __fastcall RunTransition(Iextransitions::TIETransitionType Effect, int Duration, const Winapi::Windows::TRect &StartRect, const Winapi::Windows::TRect &EndRect, bool bMaintainAspectRatio = true, int Smoothing = 0x60)/* overload */;
	void __fastcall AbortTransition();
	void __fastcall PrepareTransitionBitmaps(Vcl::Graphics::TBitmap* OriginalBitmap, Vcl::Graphics::TBitmap* TargetBitmap, Iextransitions::TIETransitionType Effect, int iWidth = 0xffffffff, int iHeight = 0xffffffff)/* overload */;
	void __fastcall PrepareTransitionBitmaps(Vcl::Graphics::TBitmap* OriginalBitmap, Vcl::Graphics::TBitmap* TargetBitmap, Iextransitions::TIETransitionType Effect, const Winapi::Windows::TRect &StartRect, const Winapi::Windows::TRect &EndRect, bool bMaintainAspectRatio = true, int iWidth = 0xffffffff, int iHeight = 0xffffffff)/* overload */;
	void __fastcall CreateTransitionBitmap(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 System::NativeInt coords_High);
	TIEGrip __fastcall FindLayerGripAnySel(int x, int y, bool bSetCurrent = false);
	TIEGrip __fastcall FindLayerGrip(int x, int y);
	TIEGrip __fastcall FindLayerGripDist(int x, int y, double &Distance);
	__property TIEViewerGestures* Gestures = {read=fGestures};
	__property Iexrulers::TIEViewRulerParams* RulerParams = {read=fRulerParams};
	__property int DpiX = {read=GetDPIX, write=SetDPIX, nodefault};
	__property int DpiY = {read=GetDPIY, write=SetDPIY, nodefault};
	virtual void __fastcall SetDPI(int dpiX, int dpiY);
	__property bool Modified = {read=GetModified, write=SetModified, nodefault};
	__property TIECropToolInteraction* CropToolInteraction = {read=GetCropToolInteraction};
	__property System::Contnrs::TObjectList* UserInteractions = {read=fUserInteractions};
	
__published:
	__property bool LegacyBitmap = {read=fLegacyBitmap, write=SetLegacyBitmap, nodefault};
	__property Hyiedefs::TResampleFilter ZoomFilter = {read=fZoomFilter, write=SetZoomFilter, default=0};
	__property Hyiedefs::TIEScrollStyle 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=16455};
	__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 TIELayerMoveSizeEvent OnLayerMoveSize = {read=fOnLayerMoveSize, write=fOnLayerMoveSize};
	__property TIENewLayerEvent OnNewLayer = {read=fOnNewLayer, write=fOnNewLayer};
	__property System::Classes::TNotifyEvent OnLayerSelectionChange = {read=fOnLayerSelectionChange, write=fOnLayerSelectionChange};
	__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 Iexlayers::TIEDrawLayerBoxEvent OnDrawLayerBox = {read=fOnDrawLayerBox, write=fOnDrawLayerBox};
	__property Iexlayers::TIEDrawLayerEvent OnDrawLayer = {read=fOnDrawLayer, write=fOnDrawLayer};
	__property Iexlayers::TIEDrawLayerGrip OnDrawLayerGrip = {read=fOnDrawLayerGrip, write=fOnDrawLayerGrip};
	__property TIEOnDrawPolygon OnDrawPolygon = {read=fOnDrawPolygon, write=fOnDrawPolygon};
	__property Imageenproc::TIESaveUndoEvent OnSaveUndo = {read=GetOnSaveUndo, write=SetOnSaveUndo};
	__property OnMouseWheel;
	__property OnMouseWheelDown;
	__property OnMouseWheelUp;
	__property Anchors = {default=3};
	__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 Vcl::Controls::TKeyEvent OnTextEditorKeyDown = {read=fOnTextEditorKeyDown, write=fOnTextEditorKeyDown};
	__property TIETextEditorEvent OnActivateTextEditor = {read=fOnActivateTextEditor, write=fOnActivateTextEditor};
	__property TIETextEditorEvent OnDeactivateTextEditor = {read=fOnDeactivateTextEditor, write=fOnDeactivateTextEditor};
	__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 TIEGridKind DisplayGridKind = {read=fDisplayGridKind, write=SetDisplayGridKind, default=0};
	__property Hyieutils::TIEMouseWheelParams* MouseWheelParams = {read=fMouseWheelParams, write=SetMouseWheelParams};
	__property Iexrulers::TRulerDirs ShowRulers = {read=fShowRulers, write=SetShowRulers, default=0};
	__property bool AutoCursors = {read=fAutoCursors, write=fAutoCursors, default=1};
	__property Iexrulers::TRulerGripPosChangeEvent OnRulerGripPosChange = {read=GetOnRulerGripPosChange, write=SetOnRulerGripPosChange};
	__property Iexrulers::TRulerGripClickEvent OnRulerGripClick = {read=GetOnRulerGripClick, write=SetOnRulerGripClick};
	__property Iexrulers::TRulerGripClickEvent OnRulerGripDblClick = {read=GetOnRulerGripDblClick, write=SetOnRulerGripDblClick};
	__property Iexrulers::TRulerClickEvent OnRulerClick = {read=GetOnRulerClick, write=SetOnRulerClick};
	__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) { }
	
};


class PASCALIMPLEMENTATION TIEUserInteraction : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	TImageEnView* fParent;
	bool fEnabled;
	
public:
	__fastcall TIEUserInteraction(TImageEnView* Parent);
	__fastcall virtual ~TIEUserInteraction();
	TImageEnView* __fastcall GetParent();
	__property bool Enabled = {read=fEnabled, write=fEnabled, nodefault};
	void __fastcall SetTempCursor(System::Uitypes::TCursor Value);
	void __fastcall RestoreCursor();
	virtual bool __fastcall MouseDownExclusive(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y) = 0 ;
	virtual void __fastcall MouseDown(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y) = 0 ;
	virtual bool __fastcall MouseMoveExclusive(System::Classes::TShiftState Shift, int X, int Y, bool Captured) = 0 ;
	virtual void __fastcall MouseMove(System::Classes::TShiftState Shift, int X, int Y, bool Captured) = 0 ;
	virtual bool __fastcall MouseUpExclusive(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y) = 0 ;
	virtual void __fastcall MouseUp(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y) = 0 ;
	virtual void __fastcall VirtualKey(unsigned VKey, unsigned KeyData, bool KeyDown) = 0 ;
	virtual void __fastcall Paint(const Winapi::Windows::TRect &UpdateRect) = 0 ;
};


enum DECLSPEC_DENUM TIECropToolInteractionState : unsigned char { iectisUNSELECTED, iectisCREATING, iectisSELECTED, iectisTOP_LEFT_SIZE, iectisTOP_SIZE, iectisTOP_RIGHT_SIZE, iectisRIGHT_SIZE, iectisBOTTOM_RIGHT_SIZE, iectisBOTTOM_SIZE, iectisBOTTOM_LEFT_SIZE, iectisLEFT_SIZE, iectisMOVING, iectisROTATE };

enum DECLSPEC_DENUM TIECropToolInteractionMode : unsigned char { iectmRECTANGLE, iectmPERSPECTIVE };

enum DECLSPEC_DENUM Imageenview__31 : unsigned char { iecoAllowResizing, iecoAllowRotating, iecoAllowMoving, iecoSideGripsRespectLocks, iecoSizeLocksAreMinimums };

typedef System::Set<Imageenview__31, Imageenview__31::iecoAllowResizing, Imageenview__31::iecoSizeLocksAreMinimums> TIECropToolOptions;

class PASCALIMPLEMENTATION TIECropToolInteraction : public TIEUserInteraction
{
	typedef TIEUserInteraction inherited;
	
private:
	Hyiedefs::TIE2DPointArray fScreenPolygon;
	Hyiedefs::TIE2DPointArray fBitmapPolygon;
	Hyiedefs::TIE2DPointArray fRotatedPolygon;
	double fRotation;
	TIECropToolInteractionState fState;
	Winapi::Windows::TPoint fMouseDownCoords;
	Hyiedefs::TIE2DPointArray fMouseDownScreenPolygon;
	double fMouseDownRotation;
	Hyiedefs::TIE2DPointArray fMouseDownRotatedPolygon;
	System::StaticArray<System::StaticArray<System::Types::TPoint, 2>, 8> fGripRects;
	double fAspectRatio;
	TIECropToolOptions fOptions;
	int fGripSize;
	bool fDrawGuides;
	Hyiedefs::TIEAntialiasMode fAntialiasMode;
	TIECropToolInteractionMode fMode;
	double fLockAspectRatio;
	int fLockWidth;
	int fLockHeight;
	TIECropToolInteractionState __fastcall GetGrip(int x, int y);
	void __fastcall Draw(Vcl::Graphics::TCanvas* Canvas);
	Hyiedefs::TIE2DPoint __fastcall ScreenToBitmap(const Hyiedefs::TIE2DPoint &P);
	Hyiedefs::TIE2DPoint __fastcall BitmapToScreen(const Hyiedefs::TIE2DPoint &P);
	void __fastcall UpdateBitmapPolygon();
	void __fastcall UpdateScreenPolygon();
	Hyiedefs::TIE2DPointArray __fastcall GetRotatedBitmapPolygon();
	void __fastcall SetMode(const TIECropToolInteractionMode Value);
	void __fastcall AdjustAspectRatio(Hyiedefs::TIE2DPointArray quad, TIECropToolInteractionState grip);
	bool __fastcall GetSelected();
	void __fastcall SetSelected(const bool Value);
	
public:
	__fastcall TIECropToolInteraction(TImageEnView* Parent);
	__property int GripSize = {read=fGripSize, write=fGripSize, nodefault};
	__property bool DrawGuides = {read=fDrawGuides, write=fDrawGuides, nodefault};
	__property double LockAspectRatio = {read=fLockAspectRatio, write=fLockAspectRatio};
	__property int LockWidth = {read=fLockWidth, write=fLockWidth, nodefault};
	__property int LockHeight = {read=fLockHeight, write=fLockHeight, nodefault};
	__property Hyiedefs::TIE2DPointArray BitmapPolygon = {read=fBitmapPolygon};
	__property Hyiedefs::TIE2DPointArray RotatedBitmapPolygon = {read=GetRotatedBitmapPolygon};
	void __fastcall SetBitmapPolygon(const Winapi::Windows::TRect &Rect);
	__property Hyiedefs::TIE2DPointArray ScreenPolygon = {read=fScreenPolygon};
	__property Hyiedefs::TIE2DPointArray RotatedPolygon = {read=fRotatedPolygon};
	__property double Rotation = {read=fRotation, write=fRotation};
	__property Hyiedefs::TIEAntialiasMode AntialiasMode = {read=fAntialiasMode, write=fAntialiasMode, nodefault};
	__property TIECropToolInteractionMode Mode = {read=fMode, write=SetMode, nodefault};
	__property TIECropToolOptions Options = {read=fOptions, write=fOptions, nodefault};
	__property bool Selected = {read=GetSelected, write=SetSelected, nodefault};
	void __fastcall Refresh();
	void __fastcall Cancel();
	void __fastcall Crop();
	virtual bool __fastcall MouseDownExclusive(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y);
	virtual void __fastcall MouseDown(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y);
	virtual bool __fastcall MouseMoveExclusive(System::Classes::TShiftState Shift, int X, int Y, bool Captured);
	virtual void __fastcall MouseMove(System::Classes::TShiftState Shift, int X, int Y, bool Captured);
	virtual bool __fastcall MouseUpExclusive(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y);
	virtual void __fastcall MouseUp(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y);
	virtual void __fastcall VirtualKey(unsigned VKey, unsigned KeyData, bool KeyDown);
	virtual void __fastcall Paint(const Winapi::Windows::TRect &UpdateRect);
public:
	/* TIEUserInteraction.Destroy */ inline __fastcall virtual ~TIECropToolInteraction() { }
	
};


class PASCALIMPLEMENTATION TIECreateLayerInteraction : public TIEUserInteraction
{
	typedef TIEUserInteraction inherited;
	
private:
	Hyiedefs::TIE2DPoint fScreenPt1;
	Hyiedefs::TIE2DPoint fScreenPt2;
	Winapi::Windows::TPoint fMouseDownCoords;
	Iexlayers::TIELayerKind fLayerKind;
	bool fCreatingRect;
	double fLockAspectRatio;
	int fLockWidth;
	int fLockHeight;
	void __fastcall Draw(Vcl::Graphics::TCanvas* Canvas);
	int __fastcall GetSelX();
	int __fastcall GetSelY();
	int __fastcall GetSelWidth();
	int __fastcall GetSelHeight();
	
public:
	__fastcall TIECreateLayerInteraction(TImageEnView* Parent);
	__property double LockAspectRatio = {read=fLockAspectRatio, write=fLockAspectRatio};
	__property int LockWidth = {read=fLockWidth, write=fLockWidth, nodefault};
	__property int LockHeight = {read=fLockHeight, write=fLockHeight, nodefault};
	__property Iexlayers::TIELayerKind LayerKind = {read=fLayerKind, write=fLayerKind, nodefault};
	__property int SelX = {read=GetSelX, nodefault};
	__property int SelY = {read=GetSelY, nodefault};
	__property int SelWidth = {read=GetSelWidth, nodefault};
	__property int SelHeight = {read=GetSelHeight, nodefault};
	void __fastcall SetSel(int X, int Y, int Width, int Height);
	void __fastcall Enact();
	void __fastcall Cancel();
	void __fastcall Refresh();
	virtual bool __fastcall MouseDownExclusive(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y);
	virtual void __fastcall MouseDown(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y);
	virtual bool __fastcall MouseMoveExclusive(System::Classes::TShiftState Shift, int X, int Y, bool Captured);
	virtual void __fastcall MouseMove(System::Classes::TShiftState Shift, int X, int Y, bool Captured);
	virtual bool __fastcall MouseUpExclusive(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y);
	virtual void __fastcall MouseUp(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y);
	virtual void __fastcall VirtualKey(unsigned VKey, unsigned KeyData, bool KeyDown);
	virtual void __fastcall Paint(const Winapi::Windows::TRect &UpdateRect);
public:
	/* TIEUserInteraction.Destroy */ inline __fastcall virtual ~TIECreateLayerInteraction() { }
	
};


//-- var, const, procedure ---------------------------------------------------
static _DELPHI_CONST System::Int8 IEN_Send_To_Back = System::Int8(-9);
static _DELPHI_CONST System::Int8 IEN_Send_Backward = System::Int8(-8);
static _DELPHI_CONST System::Int8 IEN_Bring_Forward = System::Int8(-7);
static _DELPHI_CONST System::Int8 IEN_Bring_To_Front = System::Int8(-6);
static _DELPHI_CONST System::Int8 LYR_ALL_LAYERS = System::Int8(-1);
static _DELPHI_CONST System::Int8 LYR_SELECTED_LAYERS = System::Int8(-2);
static _DELPHI_CONST System::Uitypes::TCursor crIEZoomOut = System::Uitypes::TCursor(1778);
static _DELPHI_CONST System::Uitypes::TCursor crIEZoomIn = System::Uitypes::TCursor(1779);
static _DELPHI_CONST System::Uitypes::TCursor crIEThickCross2 = System::Uitypes::TCursor(1780);
static _DELPHI_CONST System::Uitypes::TCursor crIEEraser = System::Uitypes::TCursor(1781);
static _DELPHI_CONST System::Uitypes::TCursor crIEHandDrag = System::Uitypes::TCursor(1782);
static _DELPHI_CONST System::Uitypes::TCursor crIEPencil = System::Uitypes::TCursor(1783);
static _DELPHI_CONST System::Uitypes::TCursor crIECross = System::Uitypes::TCursor(1784);
static _DELPHI_CONST System::Uitypes::TCursor crIECrossSight = System::Uitypes::TCursor(1785);
static _DELPHI_CONST System::Uitypes::TCursor crIESizeNWSE = System::Uitypes::TCursor(1786);
static _DELPHI_CONST System::Uitypes::TCursor crIESizeNS = System::Uitypes::TCursor(1787);
static _DELPHI_CONST System::Uitypes::TCursor crIESizeNESW = System::Uitypes::TCursor(1788);
static _DELPHI_CONST System::Uitypes::TCursor crIESizeWE = System::Uitypes::TCursor(1789);
static _DELPHI_CONST System::Uitypes::TCursor crIESizeAll = System::Uitypes::TCursor(1790);
static _DELPHI_CONST System::Uitypes::TCursor crIECrossSightPlus = System::Uitypes::TCursor(1791);
static _DELPHI_CONST System::Uitypes::TCursor crIECrossSightMinus = System::Uitypes::TCursor(1792);
static _DELPHI_CONST System::Uitypes::TCursor crIEThickCross = System::Uitypes::TCursor(1793);
static _DELPHI_CONST System::Uitypes::TCursor crIEThickCrossPlus = System::Uitypes::TCursor(1794);
static _DELPHI_CONST System::Uitypes::TCursor crIECrossSightMinus2 = System::Uitypes::TCursor(1795);
static _DELPHI_CONST System::Uitypes::TCursor crIECrossSightMinus3 = System::Uitypes::TCursor(1796);
static _DELPHI_CONST System::Uitypes::TCursor crIEBrush = System::Uitypes::TCursor(1797);
static _DELPHI_CONST System::Uitypes::TCursor crIEEyeDropper3 = System::Uitypes::TCursor(1798);
static _DELPHI_CONST System::Uitypes::TCursor crIEPaintFill = System::Uitypes::TCursor(1799);
static _DELPHI_CONST System::Uitypes::TCursor crIEStamp = System::Uitypes::TCursor(1800);
static _DELPHI_CONST System::Uitypes::TCursor crIECrop = System::Uitypes::TCursor(1801);
static _DELPHI_CONST System::Uitypes::TCursor crIECrossSmallPlus = System::Uitypes::TCursor(1802);
static _DELPHI_CONST System::Uitypes::TCursor crIESmallArrow = System::Uitypes::TCursor(1803);
static _DELPHI_CONST System::Uitypes::TCursor crIEMultipleArrow = System::Uitypes::TCursor(1804);
static _DELPHI_CONST System::Uitypes::TCursor crIEEyeDropper2 = System::Uitypes::TCursor(1805);
static _DELPHI_CONST System::Uitypes::TCursor crIEEyeDropper = System::Uitypes::TCursor(1806);
static _DELPHI_CONST System::Uitypes::TCursor crIECut = System::Uitypes::TCursor(1807);
static _DELPHI_CONST System::Uitypes::TCursor crIESelectArrow = System::Uitypes::TCursor(1808);
static _DELPHI_CONST System::Uitypes::TCursor crIEPen = System::Uitypes::TCursor(1809);
static _DELPHI_CONST System::Uitypes::TCursor crIEBigZoomPlusMinus = System::Uitypes::TCursor(1810);
static _DELPHI_CONST System::Uitypes::TCursor crIERotateNE = System::Uitypes::TCursor(1811);
static _DELPHI_CONST System::Uitypes::TCursor crIERotateSW = System::Uitypes::TCursor(1812);
static _DELPHI_CONST System::Uitypes::TCursor crIERotateNW = System::Uitypes::TCursor(1813);
static _DELPHI_CONST System::Uitypes::TCursor crIERotateSE = System::Uitypes::TCursor(1814);
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, bool fChessboardColor2Customized, System::Uitypes::TColor fGradientEndColor, Vcl::Graphics::TPicture* Wallpaper, TIEWallpaperStyle WallpaperStyle, Iexbitmaps::TIEBitmap* LiveBackground);
extern DELPHI_PACKAGE bool __fastcall _IsRectangle(Hyiedefs::PPointArray p, int n);
extern DELPHI_PACKAGE bool __fastcall IELayersLoadHeaderFromStream(System::Classes::TStream* Stream, /* out */ Iexlayers::TLayerHeader &Header, /* out */ int &Width, /* out */ int &Height, /* out */ System::WideString &Description, Iexbitmaps::TIEBitmap* &Thumbnail, bool LoadThumb = true);
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