teengine.pas

BCB第三方组件

  private
    FAxis: TChartAxis;
    procedure ReadAxis(Reader: TReader);
    procedure WriteAxis(Writer: TWriter);
  protected
    procedure DefineProperties(Filer: TFiler); override;
    class Function GetEditorClass:String; override;
    procedure SetAxis(const Value: TChartAxis); virtual;
  public
    Procedure Assign(Source:TPersistent); override;

    property Axis:TChartAxis read FAxis write SetAxis stored False;
  end;

  TChartPage=class(TPersistent) // 7.07
  private
    FAutoScale     : Boolean;
    FCurrent       : Integer;
    FPointsPerPage : Integer;
    FScaleLastPage : Boolean;

    IParent : TCustomAxisPanel;

    Procedure SetAutoScale(const Value:Boolean);
    procedure SetCurrent(Value:Integer);
    Procedure SetPointsPerPage(const Value:Integer);
    Procedure SetScaleLastPage(const Value:Boolean);
  public
    Constructor Create;

    procedure Assign(Source:TPersistent); override;
    function Count:Integer;
    function FirstValueIndex:Integer;
    Procedure NextPage;
    Procedure PreviousPage;

    property Parent:TCustomAxisPanel read IParent;
  published
    property AutoScale:Boolean read FAutoScale write SetAutoScale default False;
    property Current:Integer read FCurrent write SetCurrent default 1;
    property MaxPointsPerPage:Integer read FPointsPerPage write SetPointsPerPage default 0;
    property ScaleLastPage:Boolean read FScaleLastPage write SetScaleLastPage default True;
  end;

  TTeeEventClass=class of TTeeEvent;

  TTeeSeriesEvent=class(TTeeEvent)
    Event  : TChartSeriesEvent;
    Series : TCustomChartSeries;
  end;

  TSeriesNotifyEvent=Procedure(Sender:TCustomChartSeries) of object;

  TChartSeriesClass=class of TChartSeries;

  TCustomAxisPanel=class(TCustomTeePanelExtended)
  private
    { Private declarations }
    F3DPercent        : Integer;
    FAxes             : TChartAxes;
    FAxisBehind       : Boolean;
    FAxisVisible      : Boolean;
    FClipPoints       : Boolean;
    FCustomAxes       : TChartCustomAxes;
    FSeriesList       : TChartSeriesList;
    FDepthAxis        : TChartDepthAxis;
    FDepthTopAxis     : TChartDepthAxis;
    FTopAxis          : TChartAxis;
    FBottomAxis       : TChartAxis;
    FLeftAxis         : TChartAxis;
    FRightAxis        : TChartAxis;
    FView3DWalls      : Boolean;

    FOnAddSeries      : TSeriesNotifyEvent;
    FOnBeforeDrawChart: TNotifyEvent;
    FOnBeforeDrawAxes : TNotifyEvent;
    FOnBeforeDrawSeries:TNotifyEvent;
    FOnGetAxisLabel   : TAxisOnGetLabel;
    FOnGetNextAxisLabel:TAxisOnGetNextLabel;
    FOnPageChange     : TNotifyEvent;
    FOnRemoveSeries   : TSeriesNotifyEvent;

    FPage             : TChartPage;

    FMaxZOrder        : Integer;
    FSeriesWidth3D    : Integer;
    FSeriesHeight3D   : Integer;

    FTools            : TChartTools;

    InvertedRotation : Boolean;

    Procedure BroadcastTeeEventClass(Event:TTeeEventClass);
    Procedure BroadcastToolEvent(AEvent:TChartToolEvent);
    Procedure CalcInvertedRotation;
    Procedure CheckOtherSeries(Dest,Source:TChartSeries);
    Function GetAxisSeriesMaxPoints(Axis:TChartAxis):TChartSeries;
    function GetPage:Integer;
    function GetPointsPerPage:Integer;
    function GetScaleLastPage:Boolean;
    Function GetSeries(Index:Integer):TChartSeries; {$IFDEF D9}inline;{$ENDIF}
    function GetSeriesGroups:TSeriesGroups;
    Procedure InternalAddSeries(ASeries:TCustomChartSeries);
    Function InternalMinMax(AAxis:TChartAxis; IsMin,IsX:Boolean):Double;
    function IsSeriesGroupsStored:Boolean;
    Function NoActiveSeries(AAxis:TChartAxis):Boolean;
    procedure ReadMaxPointsPerPage(Reader: TReader); // obsolete
    procedure ReadPage(Reader: TReader); // obsolete
    procedure ReadScaleLastPage(Reader: TReader); // obsolete
    Procedure Set3DPercent(Value:Integer);
    Procedure SetAxisBehind(Value:Boolean);
    Procedure SetAxisVisible(Value:Boolean);
    Procedure SetBottomAxis(Value:TChartAxis);
    procedure SetClipPoints(Value:Boolean);
    Procedure SetCustomAxes(Value:TChartCustomAxes);
    Procedure SetDepthAxis(Value:TChartDepthAxis);
    procedure SetDepthTopAxis(const Value: TChartDepthAxis);
    Procedure SetLeftAxis(Value:TChartAxis);
    procedure SetPages(const Value:TChartPage);
    Procedure SetPointsPerPage(const Value:Integer);
    Procedure SetRightAxis(Value:TChartAxis);
    Procedure SetScaleLastPage(const Value:Boolean);
    procedure SetSeriesGroups(const Value:TSeriesGroups);
    Procedure SetTopAxis(Value:TChartAxis);
    procedure SetView3DWalls(Value:Boolean);
    function IsCustomAxesStored: Boolean;
  protected
    { Protected declarations }
    DoNotBroadcast   : Boolean;
    LegendColor      : TColor;
    LegendPen        : TChartPen;

    Procedure BroadcastSeriesEvent(ASeries:TCustomChartSeries; Event:TChartSeriesEvent);
    Function CalcIsAxisVisible(Axis:TChartAxis):Boolean;
    Procedure CalcWallsRect; virtual; abstract;
    Function CalcWallSize(Axis:TChartAxis):Integer; virtual; abstract;
    Function CheckMouseSeries(x,y:Integer):Boolean;
    procedure ColorPaletteChanged;

    procedure DefineProperties(Filer: TFiler); override;

    procedure DoOnAfterDraw; virtual;
    procedure DoOnBeforeDrawAxes; virtual;
    procedure DoOnBeforeDrawChart; virtual;
    procedure DoOnBeforeDrawSeries; virtual;
    procedure DrawTitlesAndLegend(BeforeSeries:Boolean); virtual; abstract;
    Function DrawBackWallAfter(Z:Integer):Boolean; virtual;
    procedure DrawLegendShape(const Rect:TRect); virtual;
    Procedure DrawWalls; virtual; abstract;
    function HasActiveSeries(Axis:TChartAxis; Default:Boolean=False):Boolean;
    Procedure InternalDraw(Const UserRectangle: TRect); override;
    Function IsAxisVisible(Axis:TChartAxis):Boolean;
    procedure RemovedDataSource( ASeries: TChartSeries;
                                 AComponent: TComponent ); dynamic;
    Procedure SetPage(const Value:Integer);

    {$IFNDEF CLR}
    {$IFNDEF D11}
    Procedure GetChildren(Proc:TGetChildProc; Root:TComponent); override;
    {$ENDIF}
    {$ENDIF}

    {$IFNDEF CLX}
    procedure CMMouseLeave(var Message: TMessage); message CM_MOUSELEAVE;
    {$ELSE}
    procedure MouseLeave(AControl: TControl); override;
    {$ENDIF}
  public
    { Public declarations }
    Designer : TTeeCustomDesigner; { used only at Design-Time }
    ColorPalette : TColorArray;

    Constructor Create(AOwner: TComponent); override;
    Destructor Destroy; override;

    { public methods }
    procedure Assign(Source:TPersistent); override;
    Function ActiveSeriesLegend(ItemIndex:Integer):TChartSeries;
    Function AddSeries(const ASeries:TChartSeries):TChartSeries; overload;  { 5.01 }
    Function AddSeries({$IFNDEF BCB}const{$ENDIF} ASeriesClass:TChartSeriesClass):TChartSeries; overload;

    {$IFNDEF BCB}
    procedure AddSeries(const SeriesArray:Array of TChartSeries); overload;
    {$ENDIF}

    Procedure CalcSize3DWalls;
    Procedure CheckDatasource(ASeries:TChartSeries); virtual;
    Function CountActiveSeries:Integer;
    Procedure ExchangeSeries(a,b:Integer); overload;
    Procedure ExchangeSeries(a,b:TCustomChartSeries); overload;
    Function FormattedValueLegend(ASeries:TChartSeries; ValueIndex:Integer):String; virtual;
    Procedure FreeAllSeries( SeriesClass:TChartSeriesClass=nil );
    Function GetAxisSeries(Axis:TChartAxis):TChartSeries;

    {$IFDEF CLR}
    Procedure GetChildren(Proc:TGetChildProc; Root:TComponent); override;
    {$ELSE}
    {$IFDEF D11}
    Procedure GetChildren(Proc:TGetChildProc; Root:TComponent); override;
    {$ENDIF}
    {$ENDIF}

    Function GetDefaultColor(Index:Integer):TColor;
    Function GetFreeSeriesColor(CheckBackground:Boolean=True; Series:TChartSeries=nil):TColor;
    Function GetMaxValuesCount:Integer;
    Function IsFreeSeriesColor(AColor: TColor; CheckBackground: Boolean;
                               Series:TChartSeries=nil):Boolean; virtual; abstract;
    Function IsValidDataSource(ASeries: TChartSeries; AComponent: TComponent):Boolean; dynamic;
    Function MaxXValue(AAxis: TChartAxis):Double;
    Function MaxYValue(AAxis: TChartAxis):Double;
    Function MinXValue(AAxis: TChartAxis):Double;
    Function MinYValue(AAxis: TChartAxis):Double;
    Function MaxMarkWidth:Integer;
    Function MaxTextWidth:Integer;
    Function MultiLineTextWidth(S:String; out NumLines:Integer):Integer;
    Function NumPages:Integer; dynamic;
    procedure PrintPages(FromPage: Integer=1; ToPage: Integer=0);
    Procedure RemoveSeries(ASeries: TCustomChartSeries); overload;
    Procedure RemoveSeries(SeriesIndex: Integer); overload;

    property Series[Index: Integer]:TChartSeries read GetSeries; default;
    Function SeriesCount:Integer; {$IFNDEF CLR}{$IFDEF D9}inline;{$ENDIF}{$ENDIF}

    Function SeriesLegend(ItemIndex: Integer; OnlyActive: Boolean):TChartSeries;
    Function SeriesTitleLegend(SeriesIndex: Integer; OnlyActive: Boolean=False):String;

    { public properties }
    property Axes:TChartAxes read FAxes;
    property AxesList:TChartAxes read FAxes; // compatibility v4
    property CustomAxes:TChartCustomAxes read FCustomAxes write SetCustomAxes stored IsCustomAxesStored;
    property MaxZOrder:Integer read FMaxZOrder write FMaxZOrder;
    property SeriesWidth3D:Integer read FSeriesWidth3D;
    property SeriesHeight3D:Integer read FSeriesHeight3D;

    { to be published properties }
    property AxisBehind:Boolean read FAxisBehind write SetAxisBehind default True;
    property AxisVisible:Boolean read FAxisVisible write SetAxisVisible default True;
    property BottomAxis:TChartAxis read FBottomAxis write SetBottomAxis;
    property Chart3DPercent:Integer read F3DPercent write Set3DPercent
                                    default TeeDef3DPercent;  // obsolete;
    property ClipPoints:Boolean read FClipPoints write SetClipPoints default True;
    property Color;
    property DepthAxis:TChartDepthAxis read FDepthAxis write SetDepthAxis;
    property DepthTopAxis:TChartDepthAxis read FDepthTopAxis write SetDepthTopAxis; // 7.0
    property LeftAxis:TChartAxis read FLeftAxis write SetLeftAxis;

    property MaxPointsPerPage:Integer read GetPointsPerPage write SetPointsPerPage;
    property Page:Integer read GetPage write SetPage;
    property Pages:TChartPage read FPage write SetPages;

    property RightAxis:TChartAxis read FRightAxis write SetRightAxis;
    property ScaleLastPage:Boolean read GetScaleLastPage write SetScaleLastPage;

    property SeriesGroups:TSeriesGroups read GetSeriesGroups
                          write SetSeriesGroups stored IsSeriesGroupsStored;

    property SeriesList:TChartSeriesList read FSeriesList;

    property Tools:TChartTools read FTools;
    property TopAxis:TChartAxis read FTopAxis write SetTopAxis;
    property View3DWalls:Boolean read FView3DWalls write SetView3DWalls default True;

    { to be published events }
    property OnAddSeries:TSeriesNotifyEvent read FOnAddSeries write FOnAddSeries;
    property OnBeforeDrawChart: TNotifyEvent read FOnBeforeDrawChart write FOnBeforeDrawChart;
    property OnBeforeDrawAxes:TNotifyEvent read FOnBeforeDrawAxes write FOnBeforeDrawAxes;
    property OnBeforeDrawSeries:TNotifyEvent read FOnBeforeDrawSeries write FOnBeforeDrawSeries;
    property OnGetAxisLabel:TAxisOnGetLabel read FOnGetAxisLabel write FOnGetAxisLabel;
    property OnGetNextAxisLabel:TAxisOnGetNextLabel read FOnGetNextAxisLabel
                                                    write FOnGetNextAxisLabel;
    property OnPageChange:TNotifyEvent read FOnPageChange write FOnPageChange;
    property OnRemoveSeries:TSeriesNotifyEvent read FOnRemoveSeries write FOnRemoveSeries;
  end;

  TSeriesMarkPosition=class
  public
    ArrowFrom : TPoint;
    ArrowFix  : Boolean;
    ArrowTo   : TPoint;
    Custom    : Boolean;
    Height    : Integer;
    LeftTop   : TPoint;
    Width     : Integer;
    MidPoint  : TPoint;
    HasMid    : Boolean;

    Procedure Assign(Source:TSeriesMarkPosition);
    Function Bounds:TRect;
  end;

  TSeriesMarks=class;

  TSeriesMarksPositions=class {$IFDEF CLR}sealed{$ENDIF} (TList)
  private
    IMarks : TSeriesMarks;

    Function Get(Index:Integer):TSeriesMarkPosition;
    Procedure Put(Index:Integer; APosition:TSeriesMarkPosition);
  public
    Procedure Automatic(Index:Integer);
    procedure Clear; override;
    Function ExistCustom:Boolean;
    procedure MoveTo(var Position:TSeriesMarkPosition; XPos,YPos:Integer);
    property Position[Index:Integer]:TSeriesMarkPosition read Get
                                    write Put; default;
  end;

  TMarksItem=class {$IFDEF CLR}sealed{$ENDIF} (TTeeCustomShape)
  private
    FText : TStrings;

    function GetText:TStrings;
    procedure SetText(const Value:TStrings);
  public
    Destructor Destroy; override;
  published
    property Bevel;
    property BevelWidth;
    property Color default ChartMarkColor;
    property Font;
    property Gradient;
    property Picture;
    property Shadow;
    property ShapeStyle;
    property Text:TStrings read GetText write SetText;
    property Transparency;
    property Transparent;
  end;

  TMarksItems=class {$IFDEF CLR}sealed{$ENDIF} (TList)
  private
    IMarks : TTeeCustomShape;
    ILoadingCustom : Boolean;
    function Get(Index:Integer):TMarksItem;
  public
    Procedure Clear; override;
    property Format[Index:Integer]:TMarksItem read Get; default;
  end;