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

// (DO NOT EDIT: machine generated header) 'FMX.TMSHotSpotImage.pas' rev: 26.00 (Windows)

#ifndef Fmx_TmshotspotimageHPP
#define Fmx_TmshotspotimageHPP

#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>	// Pascal unit
#include <SysInit.hpp>	// Pascal unit
#include <System.Types.hpp>	// Pascal unit
#include <System.SysUtils.hpp>	// Pascal unit
#include <System.Classes.hpp>	// Pascal unit
#include <System.UITypes.hpp>	// Pascal unit
#include <FMX.TMSBitmap.hpp>	// Pascal unit
#include <FMX.Platform.hpp>	// Pascal unit
#include <FMX.Types.hpp>	// Pascal unit
#include <FMX.Objects.hpp>	// Pascal unit
#include <FMX.Controls.hpp>	// Pascal unit
#include <FMX.TMSBitmapContainer.hpp>	// Pascal unit
#include <System.Math.hpp>	// Pascal unit
#include <FMX.Dialogs.hpp>	// Pascal unit
#include <System.UIConsts.hpp>	// Pascal unit
#include <FMX.Styles.hpp>	// Pascal unit
#include <FMX.TMSBaseControl.hpp>	// Pascal unit
#include <FMX.Graphics.hpp>	// Pascal unit

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

namespace Fmx
{
namespace Tmshotspotimage
{
//-- type declarations -------------------------------------------------------
enum DECLSPEC_DENUM TLineSelected : unsigned char { lsNotSelected, lsPoint1, lsPoint2, lsLine };

enum DECLSPEC_DENUM TLineOrientation : unsigned char { loPoint, loHorizontal, loVertical };

enum DECLSPEC_DENUM THoverPosition : unsigned char { hpNone, hpInside, hpBorder };

enum DECLSPEC_DENUM TSpotShapeType : unsigned char { stRectangle, stEllipse, stPolygon };

enum DECLSPEC_DENUM TBorderPoly : unsigned char { bNone, bInside, bPoint, bLine };

enum DECLSPEC_DENUM TSelectionMode : unsigned char { smSingleSelect, smMultiSelectCtrl, smMultiSelect };

typedef System::Types::TPolygon TPoints;

typedef System::Types::TPolygon TIntPoints;

class DELPHICLASS TTMSFMXHotSpotShape;
class PASCALIMPLEMENTATION TTMSFMXHotSpotShape : public System::Classes::TPersistent
{
	typedef System::Classes::TPersistent inherited;
	
private:
	int FTop;
	int FLeft;
	int FHeight;
	int FWidth;
	int FAngle;
	TSpotShapeType FShapeType;
	System::Types::TPolygon FPoints;
	double FEx1;
	double FEx2;
	double FEy1;
	double FEy2;
	THoverPosition __fastcall EllipsePos(int X, int Y);
	THoverPosition __fastcall PolyPos(int X, int Y);
	void __fastcall SetPoints(const System::Types::TPolygon Value);
	void __fastcall SetAngle(const int Value);
	
public:
	void __fastcall calcMargins(void);
	void __fastcall FillEllipse(Fmx::Graphics::TCanvas* Canvas, System::Types::TPolygon Pts);
	TBorderPoly __fastcall BorderPolypos(int X, int Y, int &p1, int &p2);
	void __fastcall EllipseToBezier(void);
	__fastcall TTMSFMXHotSpotShape(TSpotShapeType Shape);
	__fastcall virtual ~TTMSFMXHotSpotShape(void);
	THoverPosition __fastcall RectPos(int X, int Y);
	THoverPosition __fastcall GetHoverPos(int X, int Y);
	void __fastcall Draw(Fmx::Graphics::TCanvas* Canvas);
	void __fastcall DrawAt(Fmx::Graphics::TCanvas* Canvas, int X, int Y);
	__property int Top = {read=FTop, write=FTop, nodefault};
	__property int Left = {read=FLeft, write=FLeft, nodefault};
	__property int Height = {read=FHeight, write=FHeight, nodefault};
	__property int Width = {read=FWidth, write=FWidth, nodefault};
	__property TSpotShapeType ShapeType = {read=FShapeType, write=FShapeType, nodefault};
	__property System::Types::TPolygon Points = {read=FPoints, write=SetPoints};
	__property int Angle = {read=FAngle, write=SetAngle, nodefault};
};


class DELPHICLASS TPersistentBrushObject;
class PASCALIMPLEMENTATION TPersistentBrushObject : public System::Classes::TComponent
{
	typedef System::Classes::TComponent inherited;
	
private:
	Fmx::Graphics::TBrush* FBrush;
	
__published:
	__property Fmx::Graphics::TBrush* Brush = {read=FBrush, write=FBrush};
public:
	/* TComponent.Create */ inline __fastcall virtual TPersistentBrushObject(System::Classes::TComponent* AOwner) : System::Classes::TComponent(AOwner) { }
	/* TComponent.Destroy */ inline __fastcall virtual ~TPersistentBrushObject(void) { }
	
};


class DELPHICLASS TTMSFMXHotSpot;
class DELPHICLASS TTMSFMXHotSpots;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TTMSFMXHotSpot : public System::Classes::TCollectionItem
{
	typedef System::Classes::TCollectionItem inherited;
	
private:
	Fmx::Graphics::TBitmap* FHoverPicture;
	Fmx::Graphics::TBitmap* FClickPicture;
	Fmx::Graphics::TBitmap* FPicture;
	Fmx::Graphics::TBitmap* FCClick;
	Fmx::Graphics::TBitmap* FCHover;
	Fmx::Graphics::TBitmap* FCSelect;
	Fmx::Graphics::TBitmap* FCBlink;
	TTMSFMXHotSpotShape* FShape;
	System::UnicodeString FHint;
	System::UnicodeString FName;
	int FID;
	bool FClipped;
	TTMSFMXHotSpots* FOwner;
	bool FDown;
	bool FShowClick;
	bool FBlink;
	bool FSelected;
	System::UnicodeString FBlinkImageName;
	System::UnicodeString FSelectedImageName;
	System::UnicodeString FClickImageName;
	System::UnicodeString FHoverImageName;
	Fmx::Graphics::TBitmap* FSelectedImage;
	Fmx::Graphics::TBitmap* FBlinkImage;
	int FOffsetY;
	int FOffsetX;
	bool FSelectable;
	Fmx::Graphics::TBrush* FHoverStroke;
	Fmx::Graphics::TBrush* FBlinkFill;
	Fmx::Graphics::TBrush* FClickFill;
	Fmx::Graphics::TBrush* FBlinkStroke;
	Fmx::Graphics::TBrush* FSelectedFill;
	Fmx::Graphics::TBrush* FClickStroke;
	Fmx::Graphics::TBrush* FSelectedStroke;
	Fmx::Graphics::TBrush* FHoverFill;
	void __fastcall CalcClip(Fmx::Graphics::TBitmap* const Pict, Fmx::Graphics::TBitmap* &Bitm, System::UnicodeString ImageName, Fmx::Graphics::TBrush* AFill, Fmx::Graphics::TBrush* AStroke);
	void __fastcall SetShapeType(const TSpotShapeType Value);
	void __fastcall SetClickPicture(Fmx::Graphics::TBitmap* const Value);
	void __fastcall SetHoverPicture(Fmx::Graphics::TBitmap* const Value);
	int __fastcall GetWidth(void);
	int __fastcall GetHeight(void);
	int __fastcall GetX(void);
	int __fastcall GetY(void);
	int __fastcall GetX2(void);
	int __fastcall GetY2(void);
	TSpotShapeType __fastcall GetShapeType(void);
	void __fastcall SetWidth(const int Value);
	void __fastcall SetHeight(const int Value);
	void __fastcall SetX(const int Value);
	void __fastcall SetY(const int Value);
	void __fastcall SetX2(const int Value);
	void __fastcall SetY2(const int Value);
	void __fastcall setPolyPoints(const System::Types::TPolygon Value);
	System::Types::TPolygon __fastcall getPolyPoints(void);
	void __fastcall setPolyPoint(int i, const System::Types::TPointF &Value);
	System::Types::TPointF __fastcall getPolyPoint(int i);
	int __fastcall GetAngle(void);
	void __fastcall SetAngle(const int Value);
	void __fastcall SetClipped(const bool Value);
	void __fastcall SetDown(const bool Value);
	void __fastcall SetShowClick(const bool Value);
	void __fastcall SetBlink(const bool Value);
	void __fastcall SetBlinkImage(Fmx::Graphics::TBitmap* const Value);
	void __fastcall SetSelected(const bool Value);
	void __fastcall SetSelectedImage(Fmx::Graphics::TBitmap* const Value);
	void __fastcall SetSelectedImageName(const System::UnicodeString Value);
	void __fastcall SetOffsetX(const int Value);
	void __fastcall SetOffsetY(const int Value);
	void __fastcall UpdateExclusive(void);
	void __fastcall SetSelectable(const bool Value);
	void __fastcall SetBlinkFill(Fmx::Graphics::TBrush* const Value);
	void __fastcall SetBlinkStroke(Fmx::Graphics::TBrush* const Value);
	void __fastcall SetClickFill(Fmx::Graphics::TBrush* const Value);
	void __fastcall SetClickStroke(Fmx::Graphics::TBrush* const Value);
	void __fastcall SetHoverFill(Fmx::Graphics::TBrush* const Value);
	void __fastcall SetHoverStroke(Fmx::Graphics::TBrush* const Value);
	void __fastcall SetSelectedFill(Fmx::Graphics::TBrush* const Value);
	void __fastcall SetSelectedStroke(Fmx::Graphics::TBrush* const Value);
	Fmx::Tmsbitmapcontainer::TTMSFMXBitmapContainer* __fastcall GetBitmapContainer(void);
	bool __fastcall GetSelectable(void);
	
protected:
	virtual System::UnicodeString __fastcall GetDisplayName(void);
	virtual void __fastcall DefineProperties(System::Classes::TFiler* Filer);
	void __fastcall StorePoints(System::Classes::TWriter* Writer);
	void __fastcall LoadPoints(System::Classes::TReader* Reader);
	void __fastcall HoverPictureChange(System::TObject* Sender);
	void __fastcall ClickPictureChange(System::TObject* Sender);
	void __fastcall SelectedImageChange(System::TObject* Sender);
	void __fastcall BlinkImageChange(System::TObject* Sender);
	void __fastcall InternalClick(void);
	void __fastcall ReCalcClips(void);
	
public:
	__fastcall virtual TTMSFMXHotSpot(System::Classes::TCollection* Collection);
	__fastcall virtual ~TTMSFMXHotSpot(void);
	void __fastcall ScaleEllipse(const System::Types::TPoint &p1, const System::Types::TPoint &p2, const System::Types::TPoint &ps);
	void __fastcall DrawShape(Fmx::Graphics::TCanvas* Canvas);
	void __fastcall DrawShapeAt(Fmx::Graphics::TCanvas* Canvas, int X, int Y);
	System::Types::TRect __fastcall AsRect(void);
	THoverPosition __fastcall GetHoverPos(int X, int Y);
	THoverPosition __fastcall GetRectHoverPos(int X, int Y);
	TBorderPoly __fastcall GetBorderPolypos(int X, int Y, int &p1, int &p2);
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	void __fastcall SetRect(int AX1, int AY1, int AX2, int AY2)/* overload */;
	void __fastcall SetRect(const System::Types::TRect &R)/* overload */;
	void __fastcall SaveToStream(System::Classes::TStream* S);
	void __fastcall LoadFromStream(System::Classes::TStream* S, bool DoVCL);
	__property int X1 = {read=GetX, write=SetX, nodefault};
	__property int Y1 = {read=GetY, write=SetY, nodefault};
	__property int X2 = {read=GetX2, write=SetX2, nodefault};
	__property int Y2 = {read=GetY2, write=SetY2, nodefault};
	__property System::Types::TPolygon PolyPoints = {read=getPolyPoints, write=setPolyPoints};
	__property System::Types::TPointF PolyPoint[int i] = {read=getPolyPoint, write=setPolyPoint};
	__property Fmx::Tmsbitmapcontainer::TTMSFMXBitmapContainer* BitmapContainer = {read=GetBitmapContainer};
	
__published:
	__property TSpotShapeType ShapeType = {read=GetShapeType, write=SetShapeType, nodefault};
	__property System::UnicodeString Hint = {read=FHint, write=FHint};
	__property System::UnicodeString Name = {read=FName, write=FName};
	__property int ID = {read=FID, write=FID, nodefault};
	__property int X = {read=GetX, write=SetX, nodefault};
	__property int Y = {read=GetY, write=SetY, nodefault};
	__property int Width = {read=GetWidth, write=SetWidth, nodefault};
	__property int Height = {read=GetHeight, write=SetHeight, nodefault};
	__property Fmx::Graphics::TBitmap* HoverImage = {read=FHoverPicture, write=SetHoverPicture};
	__property Fmx::Graphics::TBitmap* ClickImage = {read=FClickPicture, write=SetClickPicture};
	__property Fmx::Graphics::TBitmap* HoverClippedBitmap = {read=FCHover};
	__property Fmx::Graphics::TBitmap* ClickClippedBitmap = {read=FCClick};
	__property Fmx::Graphics::TBitmap* SelectClippedBitmap = {read=FCSelect};
	__property Fmx::Graphics::TBitmap* BlinkClippedBitmap = {read=FCBlink};
	__property int Angle = {read=GetAngle, write=SetAngle, stored=false, nodefault};
	__property bool Clipped = {read=FClipped, write=SetClipped, nodefault};
	__property bool Down = {read=FDown, write=SetDown, nodefault};
	__property bool ShowClick = {read=FShowClick, write=SetShowClick, default=0};
	__property Fmx::Graphics::TBrush* HoverFill = {read=FHoverFill, write=SetHoverFill};
	__property Fmx::Graphics::TBrush* HoverStroke = {read=FHoverStroke, write=SetHoverStroke};
	__property Fmx::Graphics::TBrush* ClickFill = {read=FClickFill, write=SetClickFill};
	__property Fmx::Graphics::TBrush* ClickStroke = {read=FClickStroke, write=SetClickStroke};
	__property Fmx::Graphics::TBrush* BlinkFill = {read=FBlinkFill, write=SetBlinkFill};
	__property Fmx::Graphics::TBrush* BlinkStroke = {read=FBlinkStroke, write=SetBlinkStroke};
	__property Fmx::Graphics::TBrush* SelectedFill = {read=FSelectedFill, write=SetSelectedFill};
	__property Fmx::Graphics::TBrush* SelectedStroke = {read=FSelectedStroke, write=SetSelectedStroke};
	__property System::UnicodeString HoverImageName = {read=FHoverImageName, write=FHoverImageName};
	__property System::UnicodeString ClickImageName = {read=FClickImageName, write=FClickImageName};
	__property System::UnicodeString SelectedImageName = {read=FSelectedImageName, write=SetSelectedImageName};
	__property System::UnicodeString BlinkImageName = {read=FBlinkImageName, write=FBlinkImageName};
	__property bool Selectable = {read=GetSelectable, write=SetSelectable, default=1};
	__property Fmx::Graphics::TBitmap* SelectedImage = {read=FSelectedImage, write=SetSelectedImage};
	__property Fmx::Graphics::TBitmap* BlinkImage = {read=FBlinkImage, write=SetBlinkImage};
	__property bool Blink = {read=FBlink, write=SetBlink, default=0};
	__property bool Selected = {read=FSelected, write=SetSelected, default=0};
	__property int OffsetX = {read=FOffsetX, write=SetOffsetX, default=4};
	__property int OffsetY = {read=FOffsetY, write=SetOffsetY, default=4};
};

#pragma pack(pop)

class DELPHICLASS TTMSFMXHotSpotImage;
#pragma pack(push,4)
class PASCALIMPLEMENTATION TTMSFMXHotSpots : public Fmx::Tmsbasecontrol::TTMSFMXBaseCollection
{
	typedef Fmx::Tmsbasecontrol::TTMSFMXBaseCollection inherited;
	
public:
	TTMSFMXHotSpot* operator[](int Index) { return Items[Index]; }
	
private:
	TTMSFMXHotSpotImage* FOwner;
	float oldHeight;
	float oldWidth;
	HIDESBASE TTMSFMXHotSpot* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, TTMSFMXHotSpot* const Value);
	
protected:
	TTMSFMXHotSpotImage* __fastcall GeTTMSFMXHotSpotImage(void);
	
public:
	virtual void __fastcall EndUpdate(void);
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	__fastcall TTMSFMXHotSpots(TTMSFMXHotSpotImage* AOwner);
	void __fastcall SetDimensions(int W, int H);
	void __fastcall ReCalclips(void);
	HIDESBASE TTMSFMXHotSpot* __fastcall Add(void);
	void __fastcall SaveToStream(System::Classes::TStream* S);
	void __fastcall LoadFromStream(System::Classes::TStream* S);
	void __fastcall SaveToFile(System::Sysutils::TFileName FName);
	void __fastcall LoadFromFile(System::Sysutils::TFileName FName);
	void __fastcall ReScale(float newWidth, float newHeight)/* overload */;
	void __fastcall ReScale(int delta)/* overload */;
	DYNAMIC System::Classes::TPersistent* __fastcall GetOwner(void);
	__property TTMSFMXHotSpot* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
public:
	/* TCollection.Destroy */ inline __fastcall virtual ~TTMSFMXHotSpots(void) { }
	
};

#pragma pack(pop)

typedef void __fastcall (__closure *THotSpotEvent)(System::TObject* Sender, TTMSFMXHotSpot* HotSpot);

class PASCALIMPLEMENTATION TTMSFMXHotSpotImage : public Fmx::Tmsbitmap::TTMSFMXCustomBitmap
{
	typedef Fmx::Tmsbitmap::TTMSFMXCustomBitmap inherited;
	
private:
	Fmx::Controls::TControl* FOwner;
	TTMSFMXHotSpots* FHotSpots;
	int FHoveredItem;
	int FClickedItem;
	System::Uitypes::TAlphaColor FColor;
	bool isMouseUp;
	bool isDblClick;
	THotSpotEvent FOnHotSpotExit;
	THotSpotEvent FOnHotSpotEnter;
	THotSpotEvent FOnHotSpotClick;
	THotSpotEvent FOnHotSpotRightClick;
	THotSpotEvent FOnHotSpotDblClick;
	bool FTransparent;
	bool FAutoSize;
	bool FStretch;
	System::Uitypes::TCursor FHotSpotCursor;
	System::Uitypes::TCursor FOrigCursor;
	Fmx::Controls::TOnPaintEvent FOnPaint;
	TSelectionMode FSelectionMode;
	Fmx::Types::TTimer* FTimer;
	int FBlinkInterval;
	int FBlinkCount;
	bool FPainting;
	int FAngle;
	bool FRotating;
	void __fastcall OnTimerTime(System::TObject* Sender);
	void __fastcall SetHotSpots(TTMSFMXHotSpots* const Value);
	void __fastcall SetPicture(Fmx::Graphics::TBitmap* const Value);
	void __fastcall SetHoveredItem(const int Value);
	void __fastcall SetColor(const System::Uitypes::TAlphaColor Value);
	void __fastcall SetTransparent(const bool Value);
	void __fastcall SetAutoSizeEx(const bool Value);
	TTMSFMXHotSpot* __fastcall GetHotSpotXY(int x, int y);
	HIDESBASE void __fastcall SetStretch(const bool Value);
	void __fastcall SetBlinkInterval(const int Value);
	void __fastcall UpdateHotSpotsBlinking(void);
	int __fastcall GetSelectedIndex(void);
	HIDESBASE System::UnicodeString __fastcall GetVersion(void);
	
protected:
	void __fastcall DrawImage(int HotSpotIndex, Fmx::Graphics::TBitmap* AImage, Fmx::Graphics::TBitmap* ACachedImage, Fmx::Graphics::TBrush* AStroke);
	void __fastcall RestoreHotSpot(int HotSpotIndex);
	virtual void __fastcall MouseMove(System::Classes::TShiftState Shift, float X, float Y);
	virtual void __fastcall MouseDown(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, float X, float Y);
	virtual void __fastcall MouseUp(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, float X, float Y);
	virtual void __fastcall DblClick(void);
	void __fastcall PictureChanged(System::TObject* Sender);
	virtual void __fastcall Resize(void);
	void __fastcall UpdateControlCanvas(void);
	__property bool Transparent = {read=FTransparent, write=SetTransparent, nodefault};
	
public:
	virtual void __fastcall Paint(void);
	__fastcall virtual TTMSFMXHotSpotImage(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TTMSFMXHotSpotImage(void);
	virtual void __fastcall Loaded(void);
	__property Canvas;
	__property int HoveredItem = {read=FHoveredItem, write=SetHoveredItem, nodefault};
	__property TTMSFMXHotSpot* HotSpotXY[int x][int y] = {read=GetHotSpotXY};
	__property int SelectedIndex = {read=GetSelectedIndex, nodefault};
	void __fastcall LoadFromFile(System::Sysutils::TFileName FName);
	void __fastcall SaveToFile(System::Sysutils::TFileName FName);
	void __fastcall UpdateHotSpots(void);
	
__published:
	__property Bitmap;
	__property BitmapContainer;
	__property System::UnicodeString Version = {read=GetVersion};
	__property bool AutoSize = {read=FAutoSize, write=SetAutoSizeEx, nodefault};
	__property int BlinkInterval = {read=FBlinkInterval, write=SetBlinkInterval, default=100};
	__property System::Uitypes::TAlphaColor Color = {read=FColor, write=SetColor, nodefault};
	__property System::Uitypes::TCursor HotSpotCursor = {read=FHotSpotCursor, write=FHotSpotCursor, nodefault};
	__property TTMSFMXHotSpots* HotSpots = {read=FHotSpots, write=SetHotSpots};
	__property TSelectionMode SelectionMode = {read=FSelectionMode, write=FSelectionMode, default=0};
	__property bool Stretch = {read=FStretch, write=SetStretch, nodefault};
	__property THotSpotEvent OnHotSpotEnter = {read=FOnHotSpotEnter, write=FOnHotSpotEnter};
	__property THotSpotEvent OnHotSpotExit = {read=FOnHotSpotExit, write=FOnHotSpotExit};
	__property THotSpotEvent OnHotSpotClick = {read=FOnHotSpotClick, write=FOnHotSpotClick};
	__property THotSpotEvent OnHotSpotRightClick = {read=FOnHotSpotRightClick, write=FOnHotSpotRightClick};
	__property THotSpotEvent OnHotSpotDblClick = {read=FOnHotSpotDblClick, write=FOnHotSpotDblClick};
	__property Fmx::Controls::TOnPaintEvent OnPaint = {read=FOnPaint, write=FOnPaint};
};


//-- var, const, procedure ---------------------------------------------------
static const System::Int8 CornerSize = System::Int8(0x2);
#define EllipseTolerance  (1.500000E-01)
static const System::Int8 MAJ_VER = System::Int8(0x1);
static const System::Int8 MIN_VER = System::Int8(0x5);
static const System::Int8 REL_VER = System::Int8(0x0);
static const System::Int8 BLD_VER = System::Int8(0x1);
extern DELPHI_PACKAGE System::Types::TPointF __fastcall AddPoints(const System::Types::TPointF &PointA, const System::Types::TPointF &PointB);
extern DELPHI_PACKAGE System::Types::TPointF __fastcall SubtractPoints(const System::Types::TPointF &PointA, const System::Types::TPointF &PointB);
extern DELPHI_PACKAGE bool __fastcall EmptyImage(Fmx::Graphics::TBitmap* Image);
extern DELPHI_PACKAGE System::Types::TPointF __fastcall RPoint(double x, double y);
extern DELPHI_PACKAGE bool __fastcall Between(int Value, int Min, int Max)/* overload */;
extern DELPHI_PACKAGE bool __fastcall Between(double Value, double Min, double Max)/* overload */;
extern DELPHI_PACKAGE void __fastcall WriteCardinal(System::Classes::TStream* S, unsigned Buffer);
extern DELPHI_PACKAGE void __fastcall WriteInteger(System::Classes::TStream* S, int Buffer);
extern DELPHI_PACKAGE void __fastcall WriteString(System::Classes::TStream* S, System::UnicodeString Buffer);
extern DELPHI_PACKAGE System::UnicodeString __fastcall ReadString(System::Classes::TStream* S);
extern DELPHI_PACKAGE int __fastcall ReadInteger(System::Classes::TStream* S);
extern DELPHI_PACKAGE unsigned __fastcall ReadCardinal(System::Classes::TStream* S);
extern DELPHI_PACKAGE bool __fastcall Intersect(const System::Types::TPointF &p1, const System::Types::TPointF &p2, const System::Types::TPointF &p3, const System::Types::TPointF &p4);
extern DELPHI_PACKAGE int __fastcall CCW(const System::Types::TPointF &p0, const System::Types::TPointF &p1, const System::Types::TPointF &p2);
}	/* namespace Tmshotspotimage */
}	/* namespace Fmx */
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_FMX_TMSHOTSPOTIMAGE)
using namespace Fmx::Tmshotspotimage;
#endif
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_FMX)
using namespace Fmx;
#endif
#pragma pack(pop)
#pragma option pop

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