flexcontrols.hpp

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

		, bool APrecise, bool APreciseJustify, int LogSize, int AFontHeight);
	virtual void __fastcall DrawTextCpp(Graphics::TCanvas* Canvas, Windows::TRect &R, bool CalcOnly, bool 
		Scaled);
	__property TTextFormator* Formator = {read=FFormator};
	__property Flexprops::TBoolProp* AutoSizeProp = {read=FAutoSizeProp};
	__property Flexprops::TStrListProp* TextProp = {read=FTextProp};
	__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 Windows::TPoint &NewPoint, Flexbase::TFlexEditPointGuide 
		&Guide);
	virtual void __fastcall SetDocRect(const Windows::TRect &Value);
	virtual void __fastcall MirrorInResize(bool HMirror, bool VMirror);
	virtual bool __fastcall MovePathPoints(int PointIndex, Windows::TPoint &Delta, Flexpath::TSelectedArray 
		Selected, bool Smooth, bool Symmetric);
	virtual bool __fastcall MovePathSegment(int FirstIndex, int NextIndex, Windows::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:
	#pragma option push -w-inl
	/* virtual class method */ virtual bool __fastcall IsConnectorControl() { return IsConnectorControl(__classid(TFlexConnector)
		); }
	#pragma option pop
	/*         class method */ static bool __fastcall IsConnectorControl(TMetaClass* vmt);
	virtual int __fastcall InsertPoint(int Index, const Windows::TPoint &Point);
	virtual int __fastcall InsertNearestPoint(const Windows::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
{
	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<Windows::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, Windows::TRect &PaintRect);
	virtual Windows::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 Windows::TRect &PaintRect, bool Inflate);
	virtual Windows::TRect __fastcall GetRefreshRect(int RefreshX, int RefreshY);
	virtual Windows::TPoint __fastcall GetDefaultLinkPoint(int Index);
	virtual int __fastcall GetDefaultLinkPointCount(void);
	void __fastcall RebuildEtalon(void);
	void __fastcall BuildPoints(Flexpath::TPointArray &Points, const Windows::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
{
	int Size;
	int LineLength;
	Windows::TRect Bounds;
} ;

struct TLineCapData
{
	TLineCapInfo Info;
	Windows::TPoint p0;
	Windows::TPoint p1;
	DynamicArray<Windows::TPoint >  Points;
	DynamicArray<Flexpath::TPointType >  PointTypes;
} ;

typedef TLineCapData *PLineCapData;

struct TRenderCapParams;
typedef TRenderCapParams *PRenderCapParams;

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

typedef void __fastcall (*TLineCapStyleResolve)(int LineCap, const Windows::TPoint &p0, const Windows::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 Windows::TPoint &p0, const Windows::TPoint 
	&p1, TLineCapData &Data, int CapSize);
extern PACKAGE void __fastcall RenderCap(HDC DC, int LineCap, const Windows::TPoint &p0, const Windows::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);
extern PACKAGE void __fastcall RegisterStdControls(void);

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

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