flexcontrols.hpp

FlexGraphics是一套创建矢量图形的VCL组件

	__property Flexprops::TFontProp* FontProp = {read=FFontProp};
	__property Flexprops::TBoolProp* WordWrapProp = {read=FWordWrapProp};
	__property Flexprops::TEnumProp* AlignmentProp = {read=FAlignmentProp};
	__property Flexprops::TEnumProp* LayoutProp = {read=FLayoutProp};
	__property Flexprops::TIntProp* AngleProp = {read=FAngleProp};
	__property Flexprops::TBoolProp* PreciseProp = {read=FPreciseProp};
	__property Flexprops::TBoolProp* PreciseJustifyProp = {read=FPreciseJustifyProp};
	__property Flexprops::TBoolProp* AutoScaleFontSizeProp = {read=FAutoScaleFontSizeProp};
	__property Flexprops::TIntProp* MaxFontSizeProp = {read=FMaxFontSizeProp};
	__property bool Grayed = {read=GetGrayed, write=SetGrayed, nodefault};
	__property bool WordWrap = {read=GetWordWrap, write=SetWordWrap, nodefault};
	__property Classes::TAlignment Alignment = {read=GetAlignment, write=SetAlignment, nodefault};
	__property Stdctrls::TTextLayout Layout = {read=GetLayout, write=SetLayout, nodefault};
public:
	#pragma option push -w-inl
	/* TFlexControl.Create */ inline __fastcall virtual TFlexText(Flexbase::TFlexPanel* AOwner, Flexbase::TFlexControl* AParent, Flexbase::TFlexLayer* ALayer) : TFlexBox(AOwner, AParent, ALayer) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TFlexControl.Destroy */ inline __fastcall virtual ~TFlexText(void) { }
	#pragma option pop
	
};


class DELPHICLASS TFlexConnector;
class PASCALIMPLEMENTATION TFlexConnector : public TFlexCurve 
{
	typedef TFlexCurve inherited;
	
private:
	Flexbase::TLinkPointProp* FLinkAProp;
	Flexbase::TLinkPointProp* FLinkBProp;
	Flexprops::TEnumProp* FRerouteModeProp;
	Flexprops::TBoolProp* FOrtogonalProp;
	Flexprops::TIntProp* FMinimalGapProp;
	bool FBlocked;
	int FLinkUpdateCount;
	bool FLinkPointsIniting;
	void __fastcall SetBlocked(bool Value);
	bool __fastcall GetLinked(void);
	bool __fastcall GetOrtogonal(void);
	void __fastcall SetOrtogonal(const bool Value);
	Flexpath::TRerouteMode __fastcall GetRerouteMode(void);
	void __fastcall SetRerouteMode(const Flexpath::TRerouteMode Value);
	
protected:
	bool FDesignMoving;
	int FDesignMovedFirst;
	int FDesignMovedNext;
	bool FInTransformation;
	virtual void __fastcall CreateProperties(void);
	virtual void __fastcall ControlCreate(void);
	virtual void __fastcall ControlDestroy(void);
	virtual void __fastcall CreateInDesign(Flexbase::TFlexCreateInDesignInfo &Info);
	virtual void __fastcall BeginSelectionTransformation(void);
	virtual void __fastcall EndSelectionTransformation(void);
	virtual void __fastcall ControlTranslate(const Flexutils::TTranslateInfo &TranslateInfo);
	virtual void __fastcall CreateCurveGuide(const Types::TPoint &NewPoint, Flexbase::TFlexEditPointGuide &Guide);
	virtual void __fastcall SetDocRect(const Types::TRect &Value);
	virtual void __fastcall MirrorInResize(bool HMirror, bool VMirror);
	virtual bool __fastcall MovePathPoints(int PointIndex, Types::TPoint &Delta, Flexpath::TSelectedArray Selected, bool Smooth = false, bool Symmetric = false);
	virtual bool __fastcall MovePathSegment(int FirstIndex, int NextIndex, Types::TPoint &Delta, const double SegmentCurvePos);
	virtual void __fastcall PointsChanged(void);
	virtual void __fastcall DoNotify(Flexutils::TFlexNotify Notify);
	void __fastcall LinkedNotify(System::TObject* Sender, Flexutils::TNotifyLink* Source, const Flexutils::TNotifyLinkInfo &Info);
	virtual void __fastcall GetLinkProps(Flexbase::TLinkPointProp* &LinkFirst, Flexbase::TLinkPointProp* &LinkLast);
	virtual void __fastcall PropChanged(System::TObject* Sender, Flexprops::TCustomProp* Prop);
	virtual void __fastcall PropStored(System::TObject* Sender, Flexprops::TCustomProp* Prop, bool &IsStored, const AnsiString PropName = "");
	virtual void __fastcall ConnectorMinGapChanged(void);
	void __fastcall Reroute(void);
	__property bool Blocked = {read=FBlocked, write=SetBlocked, nodefault};
	__property int LinkUpdateCount = {read=FLinkUpdateCount, nodefault};
	__property bool Linked = {read=GetLinked, nodefault};
	
public:
	/* virtual class method */ virtual bool __fastcall IsConnectorControl(TMetaClass* vmt);
	virtual int __fastcall InsertPoint(int Index, const Types::TPoint &Point);
	virtual int __fastcall InsertNearestPoint(const Types::TPoint &Point);
	virtual void __fastcall DeletePoint(int Index);
	virtual void __fastcall EndPointsDesigning(void);
	void __fastcall BeginLinkUpdate(void);
	void __fastcall EndLinkUpdate(void);
	__property Flexbase::TLinkPointProp* LinkAProp = {read=FLinkAProp};
	__property Flexbase::TLinkPointProp* LinkBProp = {read=FLinkBProp};
	__property Flexprops::TEnumProp* RerouteModeProp = {read=FRerouteModeProp};
	__property Flexprops::TBoolProp* OrtogonalProp = {read=FOrtogonalProp};
	__property Flexprops::TIntProp* MinimalGapProp = {read=FMinimalGapProp};
	__property Flexpath::TRerouteMode RerouteMode = {read=GetRerouteMode, write=SetRerouteMode, nodefault};
	__property bool Ortogonal = {read=GetOrtogonal, write=SetOrtogonal, nodefault};
public:
	#pragma option push -w-inl
	/* TFlexControl.Create */ inline __fastcall virtual TFlexConnector(Flexbase::TFlexPanel* AOwner, Flexbase::TFlexControl* AParent, Flexbase::TFlexLayer* ALayer) : TFlexCurve(AOwner, AParent, ALayer) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TFlexControl.Destroy */ inline __fastcall virtual ~TFlexConnector(void) { }
	#pragma option pop
	
};


struct FlexControls__01
{
	
public:
	double X;
	double Y;
} ;

typedef DynamicArray<FlexControls__01 >  FlexControls__11;

class DELPHICLASS TFlexRegularPolygon;
class PASCALIMPLEMENTATION TFlexRegularPolygon : public Flexbase::TFlexControl 
{
	typedef Flexbase::TFlexControl inherited;
	
private:
	Flexprops::TBrushProp* FBrushProp;
	Flexprops::TPenProp* FPenProp;
	Flexprops::TIntProp* FAngleProp;
	Flexprops::TIntProp* FSidesProp;
	
protected:
	DynamicArray<FlexControls__01 >  FEtalon;
	double FEtalonDX;
	double FEtalonDY;
	double FEtalonDXDY;
	DynamicArray<Types::TPoint >  FPoints;
	DynamicArray<Flexpath::TPointType >  FPointTypes;
	virtual void __fastcall CreateProperties(void);
	virtual void __fastcall ControlCreate(void);
	virtual void __fastcall ControlTranslate(const Flexutils::TTranslateInfo &TranslateInfo);
	virtual Flexbase::TFlexControl* __fastcall CreateCurveControl(void);
	virtual void __fastcall Paint(Graphics::TCanvas* Canvas, Types::TRect &PaintRect);
	virtual Types::TPoint __fastcall GetAnchorPoint();
	virtual void __fastcall PropChanged(System::TObject* Sender, Flexprops::TCustomProp* Prop);
	virtual void __fastcall PropStored(System::TObject* Sender, Flexprops::TCustomProp* Prop, bool &IsStored, const AnsiString PropName = "");
	HRGN __fastcall CreatePolygonRegion(const Types::TRect &PaintRect, bool Inflate = false);
	virtual Types::TRect __fastcall GetRefreshRect(int RefreshX, int RefreshY);
	virtual Types::TPoint __fastcall GetDefaultLinkPoint(int Index);
	virtual int __fastcall GetDefaultLinkPointCount(void);
	void __fastcall RebuildEtalon(void);
	void __fastcall BuildPoints(Flexpath::TPointArray &Points, const Types::TRect &R);
	
public:
	virtual bool __fastcall IsPointInside(int PaintX, int PaintY);
	__property Flexprops::TBrushProp* BrushProp = {read=FBrushProp};
	__property Flexprops::TPenProp* PenProp = {read=FPenProp};
	__property Flexprops::TIntProp* AngleProp = {read=FAngleProp};
	__property Flexprops::TIntProp* SidesProp = {read=FSidesProp};
public:
	#pragma option push -w-inl
	/* TFlexControl.Create */ inline __fastcall virtual TFlexRegularPolygon(Flexbase::TFlexPanel* AOwner, Flexbase::TFlexControl* AParent, Flexbase::TFlexLayer* ALayer) : Flexbase::TFlexControl(AOwner, AParent, ALayer) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TFlexControl.Destroy */ inline __fastcall virtual ~TFlexRegularPolygon(void) { }
	#pragma option pop
	
};


struct TLineCapInfo;
typedef TLineCapInfo *PLineCapInfo;

struct TLineCapInfo
{
	
public:
	int Size;
	int LineLength;
	#pragma pack(push,1)
	Types::TRect Bounds;
	#pragma pack(pop)
} ;

struct TLineCapData;
typedef TLineCapData *PLineCapData;

struct TLineCapData
{
	
public:
	TLineCapInfo Info;
	#pragma pack(push,1)
	Types::TPoint p0;
	#pragma pack(pop)
	#pragma pack(push,1)
	Types::TPoint p1;
	#pragma pack(pop)
	DynamicArray<Types::TPoint >  Points;
	DynamicArray<Flexpath::TPointType >  PointTypes;
} ;

struct TRenderCapParams;
typedef TRenderCapParams *PRenderCapParams;

struct TRenderCapParams
{
	
public:
	int Style;
	Graphics::TColor OutlineColor;
	Graphics::TColor FillColor;
	int CapSize;
} ;

typedef void __fastcall (*TLineCapStyleResolve)(int LineCap, const Types::TPoint &p0, const Types::TPoint &p1, TLineCapData &Data, int CapSize, bool &Resolved);

//-- var, const, procedure ---------------------------------------------------
extern PACKAGE TLineCapStyleResolve ResolveLineCapStyle;
extern PACKAGE bool __fastcall GetLineCapInfo(int LineCap, TLineCapInfo &Info, int CapSize);
extern PACKAGE bool __fastcall GetLineCapData(int LineCap, const Types::TPoint &p0, const Types::TPoint &p1, TLineCapData &Data, int CapSize);
extern PACKAGE void __fastcall RenderCap(HDC DC, int LineCap, const Types::TPoint &p0, const Types::TPoint &p1, int CapSize);
extern PACKAGE void __fastcall RenderCaps(HDC DC, int PenWidth, const TRenderCapParams &BeginCap, const TRenderCapParams &EndCap, const Flexpath::TPointArray Points, const Flexpath::TPointTypeArray PointTypes, Flexpath::PPathInfo Info = (void *)(0x0));
extern PACKAGE void __fastcall RegisterStdControls(void);

}	/* namespace Flexcontrols */
using namespace Flexcontrols;
#pragma pack(pop)
#pragma option pop

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