flexbase.int

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

   FStyle: TFlexGridStyle;
   FColor: TColor;
   FPixColor: TColor;
   FHSize: integer;
   FVSize: integer;
   FHOffset: integer;
   FVOffset: integer;
   procedure GetOwnerWidth(Sender: TObject; out Value: integer);
   procedure GetOwnerHeight(Sender: TObject; out Value: integer);
   procedure SetColor(const Value: TColor);
   procedure SetShowPixGrid(const Value: boolean);
   procedure SetStyle(const Value: TFlexGridStyle);
   procedure SetPixColor(const Value: TColor);
   procedure SetHSize(const Value: integer);
   procedure SetVSize(const Value: integer);
   procedure SetHOffset(const Value: integer);
   procedure SetVOffset(const Value: integer);
  protected
   procedure CreateProperties; override;
   procedure ControlCreate; override;
   procedure Paint(Canvas: TCanvas; var PaintRect: TRect); override;
  public
   procedure DoSnap(const SnapRect: TRect; var Delta: TPoint;
     ResizeCursor: TResizeCursor = rcrNone);
   procedure DoCustomSnap(const SnapRect: TRect; var Delta: TPoint;
     HStep, VStep, HOffset, VOffset: integer;
     ResizeCursor: TResizeCursor = rcrNone;
     SnapTo: TFlexSnaps = [snAll]); virtual;
   property  Snap: boolean read FSnap write FSnap;
   property  SnapTo: TFlexSnaps read FSnapTo write FSnapTo;
   property  ShowPixGrid: boolean read FShowPixGrid write SetShowPixGrid;
   property  Style: TFlexGridStyle read FStyle write SetStyle;
   property  Color: TColor read FColor write SetColor;
   property  PixColor: TColor read FPixColor write SetPixColor;
   property  HSize: integer read FHSize write SetHSize;
   property  VSize: integer read FVSize write SetVSize;
   property  HOffset: integer read FHOffset write SetHOffset;
   property  VOffset: integer read FVOffset write SetVOffset;
  end;

  TFlexLayer = class(TFlexServiceControl)
  private
   //FSelectableProp: TBoolProp;
   FMoveableProp: TBoolProp;
   FResizableProp: TBoolProp;
   FReadOnlyProp: TBoolProp;
   //function  GetSelectable: boolean;
   //procedure SetSelectable(Value: boolean);
   function  GetReadOnly: boolean;
   procedure SetReadOnly(Value: boolean);
   function  GetMoveable: boolean;
   procedure SetMoveable(const Value: boolean);
   function  GetResizable: boolean;
   procedure SetResizable(const Value: boolean);
  protected
   FCheckName: string;
   procedure CreateProperties; override;
   procedure ControlCreate; override;
   procedure ControlDestroy; override;
   procedure PropBeforeChanged(Sender: TObject; Prop: TCustomProp); override;
   procedure PropChanged(Sender: TObject; Prop: TCustomProp); override;
   procedure PropStored(Sender: TObject; Prop: TCustomProp;
     var IsStored: boolean; const PropName: string = ''); override;
   property  ReadOnlyProp: TBoolProp read FReadOnlyProp;
   //property  SelectableProp: TBoolProp read FSelectableProp;
   property  MoveableProp: TBoolProp read FMoveableProp;
   property  ResizableProp: TBoolProp read FResizableProp;
  public
   procedure Invalidate; override;
   property  Moveable: boolean read GetMoveable write SetMoveable;
   property  Resizable: boolean read GetResizable write SetResizable;
   //property  Selectable: boolean read GetSelectable write SetSelectable;
   property  ReadOnly: boolean read GetReadOnly write SetReadOnly;
  end;

  TFlexLayers = class(TFlexServiceControl)
  private
   function  GetLayer(Index: integer): TFlexLayer;
   function  GetByName(const Name: string): TFlexLayer;
  protected
   procedure ControlCreate; override;
  public
   function  New: TFlexLayer;
   function  Add(AControl: TFlexControl): integer; override;
   procedure Delete(Index: integer); override;
   procedure ChangeOrder(CurIndex, NewIndex: integer); override;
   property  Controls[Index: integer]: TFlexLayer read GetLayer; default;
   property  ByName[const Name: string]: TFlexLayer read GetByName;
  end;

  TPaintOrder = record
   LayerRefs:   array of record
                 First: integer;
                 Last: integer;
                end;
   ControlRefs: array of record
                 Next: integer;
                 Prev: integer;
                 Control: TFlexControl;
                end;
  end;

  TFlexCustomScheme = class(TFlexServiceControl)
  private
   function  GetDefault: boolean;
   procedure SetDefault(const Value: boolean);
   procedure GetOwnerWidth(Sender: TObject; out Value: integer);
   procedure GetOwnerHeight(Sender: TObject; out Value: integer);
  protected
   FDefaultProp: TBoolProp;
   procedure CreateProperties; override;
   procedure ControlCreate; override;
   procedure ControlDestroy; override;
   procedure PropChanged(Sender: TObject; Prop: TCustomProp); override;
   procedure PropStored(Sender: TObject; Prop: TCustomProp;
     var IsStored: boolean; const PropName: string = ''); override;
   procedure PaintAll(Canvas: TCanvas; PaintX, PaintY: integer); override;
   property  Default: boolean read GetDefault write SetDefault;
  public
   function  FindControlAtPoint(x, y: integer): TFlexControl; override;
   function  CreatePaintOrder(var PaintOrder: TPaintOrder): boolean;
  end;

  TFlexScheme = class(TFlexCustomScheme)
  private
   FBrushProp: TBrushProp;
   FPictureProp: TPictureProp;
   FBackgroundProp: TBackgroundOptionsProp;
  protected
   FCheckName: string;
   procedure ControlCreate; override;
   procedure CreateProperties; override;
   procedure Paint(Canvas: TCanvas; var PaintRect: TRect); override;
   procedure PropBeforeChanged(Sender: TObject; Prop: TCustomProp); override;
   procedure PropChanged(Sender: TObject; Prop: TCustomProp); override;
   procedure PropStored(Sender: TObject; Prop: TCustomProp;
     var IsStored: boolean; const PropName: string = ''); override;
   function  GetRefreshRect(RefreshX, RefreshY: integer): TRect; override;
  public
   property  BrushProp: TBrushProp read FBrushProp;
   property  PictureProp: TPictureProp read FPictureProp;
   property  DefaultProp: TBoolProp read FDefaultProp;
   property  BackgroundProp: TBackgroundOptionsProp read FBackgroundProp;
   property  Default;
  end;

  TFlexSchemes = class(TFlexServiceControl)
  private
   FVersionProp: TIntProp;
   FConnectorsMinGapProp: TIntProp;
   FConnectorsKeepLinkProp: TBoolProp;
   function  GetScheme(Index: integer): TFlexCustomScheme;
   function  GetByName(const Name: string): TFlexCustomScheme;
  protected
   procedure ControlCreate; override;
   procedure CreateProperties; override;
   procedure PropChanged(Sender: TObject; Prop: TCustomProp); override;
   procedure PropStored(Sender: TObject; Prop: TCustomProp;
     var IsStored: boolean; const PropName: string = ''); override;
  public
   function  Add(AControl: TFlexControl): integer; override;
   procedure Delete(Index: integer); override;
   procedure ChangeOrder(CurIndex, NewIndex: integer); override;
   property  Controls[Index: integer]: TFlexCustomScheme read GetScheme; default;
   property  ByName[const Name: string]: TFlexCustomScheme read GetByName;
   property  VersionProp: TIntProp read FVersionProp;
   property  ConnectorsMinGapProp: TIntProp read FConnectorsMinGapProp;
   property  ConnectorsKeepLinkProp: TBoolProp read FConnectorsKeepLinkProp;
  end;

  TFlexDragObject = class(TDragObject)
  private
   FDragGroup: TFlexGroup;
   FMouseDragDelta: TPoint;
   FDefaultFlex: TFlexPanel;
  protected
   procedure Finished(Target: TObject; X, Y: Integer; Accepted: Boolean);
     override;
  public
   destructor Destroy; override;
   procedure UpdateLink(Flex: TFlexPanel; MouseX, MouseY: integer); virtual;
   procedure Unlink; virtual;
   property  DragGroup: TFlexGroup read FDragGroup write FDragGroup;
   property  MouseDragDelta: TPoint read FMouseDragDelta write FMouseDragDelta;
   property  DefaultFlex: TFlexPanel read FDefaultFlex write FDefaultFlex;
  end;

  PFlexPaintStruct = ^TFlexPaintStruct;
  TFlexPaintStruct = record
   IsFirstPaint: boolean;
   Canvas: TCanvas;
   Origin: TPoint;
   Scale: integer;
   PaintRect: TRect;
   PaintWidth: integer;
   PaintHeight: integer;
   PaintForExport: boolean;
   UseOriginalBezier: boolean;
   UseImageClipTransparent: boolean;
  end;

  TFlexPaintList = class
  private
   FOwner: TFlexPanel;
   FList: TList;
   FFirstInUse: boolean;
  protected
   procedure Clear;
   procedure StoreParams(PaintStruct: PFlexPaintStruct; ACanvas: TCanvas);
   procedure RestoreParams(PaintStruct: PFlexPaintStruct);
  public
   constructor Create(AOwner: TFlexPanel);
   destructor Destroy; override;
   function  BeginPaint(ACanvas: TCanvas): PFlexPaintStruct;
   procedure EndPaint(PaintStruct: PFlexPaintStruct);
   property  Owner: TFlexPanel read FOwner;
  end;

  PFlexPaintCache = ^TFlexPaintCache;
  TFlexPaintCache = record
   DC: HDC;
   Bitmap: HBitmap;
   BitsPixel: integer;
   Width: integer;
   Height: integer;
   rcPaint: TRect;
  end;

  TFlexPanelHistory = class(THistory)
  private
   FPanel: TFlexPanel;
  protected
   procedure DoChange; override;
   function  DoGetActionSource(Action: THistoryAction;
     var Enabled: boolean): TObject; override;
   procedure DoSetActionSource(Action: THistoryAction;
     const Source: TObject); override;
   function  DoGetActionCaption(Action: THistoryAction;
     const Source: TObject): string; override;
   function  DoIsRecordable(var ActionClass: THistoryActionClass;
     var Source: TObject; Parent: THistoryGroup): boolean; override;
   function  DoIsSame(ExistedAction: THistoryAction;
     NewActionClass: THistoryActionClass;
     NewSource: TObject): boolean; override;
  public
   constructor Create(AOwner: TFlexPanel);
   function  Undo: boolean; override;
   function  Redo: boolean; override;
   function  SourceControl(Source: TObject): TFlexControl;
   procedure SourceInfo(Source: TObject;
     out Id: LongWord; out PropName: string);
   function  BeginPanelGroup(GroupClass: THistoryGroupClass): THistoryGroup;
   function  EndPanelGroup(GroupClass: THistoryGroupClass): boolean;
   function  RecordSelectedAsNew: boolean;
   property  Owner: TFlexPanel read FPanel;
  end;

  TFlexPaintEvent = procedure(ACanvas: TCanvas; AControl: TFlexControl;
     ChildrenOnly, SelectedOnly: boolean) of object;

  TFlexUpdateCursorEvent = procedure(Sender: TObject; var ACursor: TCursor)
    of object;
  TFlexNeedHintEvent = procedure(Sender: TObject; var IsNeedHint: boolean)
    of object;
  TFlexShowHintEvent = procedure(Sender: TObject; HintControl: TFlexControl;
    var HintInfo: THintInfo; var IsShowHint: boolean) of object;

  TFlexPanel = class(TScrollingWinControl)
  private
   FBorderStyle: TBorderStyle;
   FCanvas: TCanvas;
   FDocWidth: integer;
   FDocHeight: integer;
   FDocFrameColor: TColor;
   FDocShadowColor: TColor;
   FDocSpaceBrush: TBrush;
   FDocSpaceFill: boolean;
   FDocClipping: boolean;
   FSchemeBkStretch: boolean;
   FShowDocFrame: boolean;
   FAutoZoom: boolean;