16851 lines
545 KiB
ObjectPascal
16851 lines
545 KiB
ObjectPascal
{********************************************************************}
|
|
{ }
|
|
{ Developer Express Visual Component Library }
|
|
{ ExpressQuantumGrid }
|
|
{ }
|
|
{ Copyright (c) 1998-2009 Developer Express Inc. }
|
|
{ ALL RIGHTS RESERVED }
|
|
{ }
|
|
{ The entire contents of this file is protected by U.S. and }
|
|
{ International Copyright Laws. Unauthorized reproduction, }
|
|
{ reverse-engineering, and distribution of all or any portion of }
|
|
{ the code contained in this file is strictly prohibited and may }
|
|
{ result in severe civil and criminal penalties and will be }
|
|
{ prosecuted to the maximum extent possible under the law. }
|
|
{ }
|
|
{ RESTRICTIONS }
|
|
{ }
|
|
{ THIS SOURCE CODE AND ALL RESULTING INTERMEDIATE FILES }
|
|
{ (DCU, OBJ, DLL, ETC.) ARE CONFIDENTIAL AND PROPRIETARY TRADE }
|
|
{ SECRETS OF DEVELOPER EXPRESS INC. THE REGISTERED DEVELOPER IS }
|
|
{ LICENSED TO DISTRIBUTE THE EXPRESSQUANTUMGRID AND ALL }
|
|
{ ACCOMPANYING VCL CONTROLS AS PART OF AN EXECUTABLE PROGRAM ONLY. }
|
|
{ }
|
|
{ THE SOURCE CODE CONTAINED WITHIN THIS FILE AND ALL RELATED }
|
|
{ FILES OR ANY PORTION OF ITS CONTENTS SHALL AT NO TIME BE }
|
|
{ COPIED, TRANSFERRED, SOLD, DISTRIBUTED, OR OTHERWISE MADE }
|
|
{ AVAILABLE TO OTHER INDIVIDUALS WITHOUT EXPRESS WRITTEN CONSENT }
|
|
{ AND PERMISSION FROM DEVELOPER EXPRESS INC. }
|
|
{ }
|
|
{ CONSULT THE END USER LICENSE AGREEMENT FOR INFORMATION ON }
|
|
{ ADDITIONAL RESTRICTIONS. }
|
|
{ }
|
|
{********************************************************************}
|
|
|
|
unit cxGridChartView;
|
|
|
|
{$I cxVer.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
{$IFDEF DELPHI6}
|
|
Variants,
|
|
{$ENDIF}
|
|
Windows, Messages, Classes, Graphics, Controls, Forms, Menus, StdCtrls,
|
|
cxClasses, cxGraphics, cxLookAndFeels, cxLookAndFeelPainters, cxStyles, cxControls, cxStorage,
|
|
cxEdit, cxCheckBox, cxCheckListBox, cxDropDownEdit, cxLabel, cxPC,
|
|
cxVariants, cxCustomData, cxData, cxDataStorage,
|
|
cxGridCommon, cxGridCustomView;
|
|
|
|
const
|
|
cxGridChartCustomizationFormDefaultWidth = 200;
|
|
|
|
htChartBase = 50;
|
|
htChartTitle = htChartBase + 1;
|
|
htLegend = htChartBase + 2;
|
|
htLegendItem = htChartBase + 3;
|
|
htChartToolBox = htChartBase + 4;
|
|
htDataLevelInfo = htChartBase + 5;
|
|
htDataLevelActiveValueInfo = htChartBase + 6;
|
|
htChartCustomizeButton = htChartBase + 7;
|
|
htDiagramSelector = htChartBase + 8;
|
|
htChartValue = htChartBase + 9;
|
|
// histogram
|
|
htPlot = htChartBase + 10;
|
|
htCategoryAxisTitle = htChartBase + 11;
|
|
htValueAxisTitle = htChartBase + 12;
|
|
// line diagram
|
|
htChartValueLine = htChartBase + 13;
|
|
// area diagram
|
|
htChartValueArea = htChartBase + 14;
|
|
// pie diagram
|
|
htSeriesSite = htChartBase + 15;
|
|
htSeriesSiteCaption = htChartBase + 16;
|
|
|
|
ckToolBox = 2;
|
|
|
|
dsDiagramFirst = 0;
|
|
dsLegend = dsDiagramFirst;
|
|
dsValueCaptions = dsDiagramFirst + 1;
|
|
dsValues = dsDiagramFirst + 2;
|
|
dsAxis = dsDiagramFirst + 3;
|
|
dsCategoryAxis = dsDiagramFirst + 4;
|
|
dsValueAxis = dsDiagramFirst + 5;
|
|
dsAxisTitle = dsDiagramFirst + 6;
|
|
dsCategoryAxisTitle = dsDiagramFirst + 7;
|
|
dsValueAxisTitle = dsDiagramFirst + 8;
|
|
dsGridLines = dsDiagramFirst + 9;
|
|
dsCategoryGridLines = dsDiagramFirst + 10;
|
|
dsValueGridLines = dsDiagramFirst + 11;
|
|
dsPlot = dsDiagramFirst + 12;
|
|
dsValueMarkers = dsDiagramFirst + 13;
|
|
dsSeriesSiteCaptions = dsDiagramFirst + 14;
|
|
dsSeriesSites = dsDiagramFirst + 15;
|
|
dsDiagramLast = dsSeriesSites;
|
|
|
|
ssSeriesFirst = 0;
|
|
ssValues = ssSeriesFirst;
|
|
ssSeriesLast = ssValues;
|
|
|
|
vsChartFirst = vsCustomLast + 1;
|
|
vsTitle = vsChartFirst;
|
|
vsLegend = vsChartFirst + 1;
|
|
vsToolBox = vsChartFirst + 2;
|
|
vsDiagramSelector = vsChartFirst + 3;
|
|
vsDataLevelsInfo = vsChartFirst + 4;
|
|
vsDataLevelActiveValueInfo = vsChartFirst + 5;
|
|
vsActiveDataLevelInfo = vsChartFirst + 6;
|
|
vsChartLast = vsActiveDataLevelInfo;
|
|
|
|
cxGridChartColumnDiagramDefaultBorderWidth = 1;
|
|
cxGridChartLineDiagramDefaultHotSpotSize = 15;
|
|
cxGridChartLineDiagramDefaultLineWidth = 1;
|
|
cxGridChartLineDiagramDefaultMarkerSize = 7;
|
|
cxGridChartDefaultDataLevelActiveValueDropDownCount = 15;
|
|
|
|
cxGridChartItemDefaultSummaryKind = skSum;
|
|
|
|
type
|
|
TcxGridChartCustomizationForm = class;
|
|
TcxGridChartController = class;
|
|
TcxCustomGridChartTitleViewInfo = class;
|
|
TcxGridChartLegendItemViewInfo = class;
|
|
TcxGridChartLegendViewInfo = class;
|
|
TcxGridChartDiagramValueViewInfo = class;
|
|
TcxGridChartDiagramViewInfo = class;
|
|
TcxGridChartHistogramTickMarkLabelsViewInfo = class;
|
|
TcxGridChartHistogramViewInfo = class;
|
|
TcxGridChartColumnDiagramViewInfo = class;
|
|
TcxGridChartLineDiagramLegendItemViewInfo = class;
|
|
TcxGridChartLineDiagramValueViewInfoClass = class of TcxGridChartLineDiagramValueViewInfo;
|
|
TcxGridChartLineDiagramValueViewInfo = class;
|
|
TcxGridChartLineDiagramViewInfo = class;
|
|
TcxGridChartAreaDiagramValueViewInfo = class;
|
|
TcxGridChartPieDiagramValueViewInfo = class;
|
|
TcxGridChartPieSeriesSiteViewInfo = class;
|
|
TcxGridChartPieDiagramViewInfo = class;
|
|
TcxGridChartToolBoxItemViewInfo = class;
|
|
TcxGridChartToolBoxDataLevelActiveValueViewInfo = class;
|
|
TcxGridChartToolBoxDataLevelInfoViewInfo = class;
|
|
TcxGridChartToolBoxCustomizeButtonViewInfo = class;
|
|
TcxGridChartToolBoxDiagramSelectorViewInfo = class;
|
|
TcxGridChartToolBoxViewInfo = class;
|
|
TcxGridChartViewInfo = class;
|
|
TcxCustomGridChartTitle = class;
|
|
TcxGridChartDiagram = class;
|
|
TcxGridChartHistogramAxisTitle = class;
|
|
TcxGridChartHistogramAxis = class;
|
|
TcxGridChartHistogramAxisValue = class;
|
|
TcxGridChartHistogram = class;
|
|
TcxGridChartColumnDiagram = class;
|
|
TcxGridChartLineDiagram = class;
|
|
TcxGridChartAreaDiagram = class;
|
|
TcxGridChartPieDiagram = class;
|
|
TcxGridChartItemDataBinding = class;
|
|
TcxGridChartItemClass = class of TcxGridChartItem;
|
|
TcxGridChartItem = class;
|
|
TcxGridChartDataGroup = class;
|
|
TcxGridChartSeries = class;
|
|
TcxGridChartView = class;
|
|
|
|
TcxGridChartDataGroupContainerKind = Integer;
|
|
|
|
TcxGridChartPartAlignment = (cpaDefault, cpaStart, cpaCenter, cpaEnd);
|
|
TcxGridChartPartOrientation = (cpoDefault, cpoHorizontal, cpoVertical);
|
|
TcxGridChartPartPosition = (cppDefault, cppNone, cppLeft, cppTop, cppRight, cppBottom);
|
|
|
|
TcxGridChartColumnDiagramValueCaptionPosition = (cdvcpNone, cdvcpInsideBase,
|
|
cdvcpCenter, cdvcpInsideEnd, cdvcpOutsideEnd);
|
|
|
|
TcxGridChartLineDiagramValueCaptionPosition = (ldvcpNone, ldvcpLeft, ldvcpAbove,
|
|
ldvcpRight, ldvcpBelow, ldvcpCenter);
|
|
TcxGridChartLineStyle = (clsNone, clsSolid, clsDash, clsDot, clsDashDot, clsDashDotDot);
|
|
TcxGridChartMarkerStyle = (cmsNone, cmsSquare, cmsTriangle, cmsDiamond, cmsCircle);
|
|
|
|
TcxGridChartPieDiagramValueCaptionPosition = (pdvcpNone, pdvcpCenter,
|
|
pdvcpInsideEnd, pdvcpOutsideEnd, pdvcpOutsideEndWithLeaderLines);
|
|
|
|
{ hit tests }
|
|
|
|
TcxGridChartTitleHitTest = class(TcxCustomGridViewHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
end;
|
|
|
|
TcxGridChartLegendHitTest = class(TcxCustomGridViewHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
end;
|
|
|
|
TcxGridChartLegendItemHitTest = class(TcxCustomGridViewHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
public
|
|
Index: Integer;
|
|
Series: TcxGridChartSeries;
|
|
ValueIndex: Integer;
|
|
end;
|
|
|
|
TcxGridChartToolBoxHitTest = class(TcxCustomGridViewHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
end;
|
|
|
|
TcxGridChartDataLevelInfoHitTest = class(TcxCustomGridViewHitTest)
|
|
private
|
|
FDataLevel: Integer;
|
|
FDataLevelObject: TcxGridChartDataGroup;
|
|
procedure SetDataLevel(Value: Integer);
|
|
procedure SetDataLevelObject(Value: TcxGridChartDataGroup);
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
public
|
|
DataLevelObjectContainerKind: TcxGridChartDataGroupContainerKind;
|
|
function DragAndDropObjectClass: TcxCustomGridDragAndDropObjectClass; override;
|
|
property DataLevel: Integer read FDataLevel write SetDataLevel;
|
|
property DataLevelObject: TcxGridChartDataGroup read FDataLevelObject write SetDataLevelObject;
|
|
end;
|
|
|
|
TcxGridChartDataLevelActiveValueInfoHitTest = class(TcxGridChartDataLevelInfoHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
public
|
|
CanDropDown: Boolean;
|
|
function Cursor: TCursor; override;
|
|
function DragAndDropObjectClass: TcxCustomGridDragAndDropObjectClass; override;
|
|
end;
|
|
|
|
TcxGridChartCustomizeButtonHitTest = class(TcxCustomGridViewHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
end;
|
|
|
|
TcxGridChartDiagramSelectorHitTest = class(TcxCustomGridViewHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
public
|
|
CanDropDown: Boolean;
|
|
function Cursor: TCursor; override;
|
|
end;
|
|
|
|
TcxGridChartValueHitTest = class(TcxCustomGridViewHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
public
|
|
CanDrillDown: Boolean;
|
|
Series: TcxGridChartSeries;
|
|
ValueIndex: Integer;
|
|
function Cursor: TCursor; override;
|
|
end;
|
|
|
|
TcxCustomGridChartDiagramHitTest = class(TcxCustomGridViewHitTest)
|
|
public
|
|
Diagram: TcxGridChartDiagram;
|
|
end;
|
|
|
|
// histogram
|
|
|
|
TcxGridChartHistogramPlotHitTest = class(TcxCustomGridChartDiagramHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
end;
|
|
|
|
TcxCustomGridChartHistogramAxisHitTest = class(TcxCustomGridChartDiagramHitTest);
|
|
|
|
TcxGridChartHistogramCategoryAxisTitleHitTest = class(TcxCustomGridChartHistogramAxisHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
end;
|
|
|
|
TcxGridChartHistogramValueAxisTitleHitTest = class(TcxCustomGridChartHistogramAxisHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
end;
|
|
|
|
// line diagram
|
|
|
|
TcxGridChartValueLineHitTest = class(TcxGridChartValueHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
end;
|
|
|
|
// area diagram
|
|
|
|
TcxGridChartValueAreaHitTest = class(TcxGridChartValueHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
end;
|
|
|
|
// pie diagram
|
|
|
|
TcxGridChartPieSeriesSiteHitTest = class(TcxCustomGridChartDiagramHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
public
|
|
Series: TcxGridChartSeries;
|
|
end;
|
|
|
|
TcxGridChartPieSeriesSiteCaptionHitTest = class(TcxGridChartPieSeriesSiteHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
end;
|
|
|
|
{ controller }
|
|
|
|
// drag&drop objects
|
|
|
|
TcxCustomGridChartMovingObject = class(TcxCustomGridMovingObject)
|
|
private
|
|
function GetController: TcxGridChartController;
|
|
function GetCustomizationForm: TcxGridChartCustomizationForm;
|
|
function GetGridView: TcxGridChartView;
|
|
function GetViewInfo: TcxGridChartViewInfo;
|
|
protected
|
|
property Controller: TcxGridChartController read GetController;
|
|
property CustomizationForm: TcxGridChartCustomizationForm read GetCustomizationForm;
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
property ViewInfo: TcxGridChartViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
TcxGridChartDataGroupMovingObjectClass = class of TcxGridChartDataGroupMovingObject;
|
|
|
|
TcxGridChartDataGroupMovingObject = class(TcxCustomGridChartMovingObject)
|
|
private
|
|
FDestDataLevel: Integer;
|
|
FSourceItemContainerKind: TcxGridChartDataGroupContainerKind;
|
|
function GetSourceItem: TcxGridChartDataGroup;
|
|
procedure SetDestDataLevel(Value: Integer);
|
|
procedure SetSourceItem(Value: TcxGridChartDataGroup);
|
|
protected
|
|
function CanRemove: Boolean; override;
|
|
function GetArrowAreaBounds(APlace: TcxGridArrowPlace): TRect; override;
|
|
function GetCustomizationFormListBox: TcxCustomGridItemsListBox; override;
|
|
function GetSourceItemViewInfo: TcxCustomGridCellViewInfo; override;
|
|
function IsSourceCustomizationForm: Boolean; override;
|
|
function IsValidDestination: Boolean; override;
|
|
|
|
procedure BeginDragAndDrop; override;
|
|
procedure DragAndDrop(const P: TPoint; var Accepted: Boolean); override;
|
|
procedure EndDragAndDrop(Accepted: Boolean); override;
|
|
|
|
property DestDataLevel: Integer read FDestDataLevel write SetDestDataLevel;
|
|
property SourceItem: TcxGridChartDataGroup read GetSourceItem write SetSourceItem;
|
|
property SourceItemContainerKind: TcxGridChartDataGroupContainerKind
|
|
read FSourceItemContainerKind write FSourceItemContainerKind;
|
|
public
|
|
constructor Create(AControl: TcxControl); override;
|
|
procedure Init(const P: TPoint; AParams: TcxCustomGridHitTest); override;
|
|
end;
|
|
|
|
// customization form
|
|
|
|
TcxGridChartSeriesInnerCheckListBox = class(TcxCustomInnerCheckListBox)
|
|
protected
|
|
function GetMetrics: TcxCheckListBoxMetrics; override;
|
|
public
|
|
function GetSeriesImageSize: Integer; virtual;
|
|
end;
|
|
|
|
TcxGridChartSeriesCheckListBoxClass = class of TcxGridChartSeriesCheckListBox;
|
|
|
|
TcxGridChartSeriesCheckListBox = class(TcxCheckListBox)
|
|
private
|
|
FDraggingSeries: TcxGridChartSeries;
|
|
FGridView: TcxGridChartView;
|
|
FLockRefreshItems: Boolean;
|
|
FSeriesImages: TImageList;
|
|
function GetSeries(AIndex: Integer): TcxGridChartSeries;
|
|
protected
|
|
procedure CheckClicked(Sender: TObject; AIndex: Integer;
|
|
APrevState, ANewState: TcxCheckBoxState); virtual;
|
|
procedure CreateWnd; override;
|
|
procedure DragOver(Source: TObject; X, Y: Integer; State: TDragState;
|
|
var Accept: Boolean); override;
|
|
procedure DrawSeriesImage(ACanvas: TcxCanvas; const R: TRect; ASeries: TcxGridChartSeries); virtual;
|
|
function GetInnerCheckListBoxClass: TcxCustomInnerCheckListBoxClass; override;
|
|
procedure LookAndFeelChanged(Sender: TcxLookAndFeel; AChangedValues: TcxLookAndFeelValues); override;
|
|
procedure RefreshImages;
|
|
procedure RefreshSeriesImages; virtual;
|
|
|
|
property DraggingSeries: TcxGridChartSeries read FDraggingSeries write FDraggingSeries;
|
|
property GridView: TcxGridChartView read FGridView;
|
|
property LockRefreshItems: Boolean read FLockRefreshItems write FLockRefreshItems;
|
|
property Series[AIndex: Integer]: TcxGridChartSeries read GetSeries;
|
|
property SeriesImages: TImageList read FSeriesImages;
|
|
public
|
|
constructor Create(AOwner: TComponent; AGridView: TcxGridChartView); reintroduce; virtual;
|
|
destructor Destroy; override;
|
|
procedure RefreshItems; virtual;
|
|
function StartDrag(DragObject: TDragObject): Boolean; override;
|
|
end;
|
|
|
|
TcxGridChartSortBySeriesComboBoxClass = class of TcxGridChartSortBySeriesComboBox;
|
|
|
|
TcxGridChartSortBySeriesComboBox = class(TcxComboBox)
|
|
private
|
|
FDirectionButton: TcxEditButton;
|
|
FGridView: TcxGridChartView;
|
|
protected
|
|
procedure Click; override;
|
|
procedure DirectionButtonClick; virtual;
|
|
procedure DoButtonClick(AButtonVisibleIndex: Integer); override;
|
|
procedure DrawItem(AControl: TcxCustomComboBox; ACanvas: TcxCanvas;
|
|
AIndex: Integer; const ARect: TRect; AState: TOwnerDrawState); virtual;
|
|
procedure MeasureItem(AControl: TcxCustomComboBox; AIndex: Integer;
|
|
ACanvas: TcxCanvas; var AHeight: Integer); virtual;
|
|
procedure RefreshDirectionButton; virtual;
|
|
|
|
property DirectionButton: TcxEditButton read FDirectionButton;
|
|
property GridView: TcxGridChartView read FGridView;
|
|
public
|
|
constructor Create(AOwner: TComponent; AGridView: TcxGridChartView); reintroduce; virtual;
|
|
procedure RefreshItems; virtual;
|
|
end;
|
|
|
|
TcxGridChartDataGroupsListBoxClass = class of TcxGridChartDataGroupsListBox;
|
|
|
|
TcxGridChartDataGroupsListBox = class(TcxCustomGridItemsListBox)
|
|
private
|
|
function GetGridView: TcxGridChartView;
|
|
protected
|
|
function CalculateItemHeight: Integer; override;
|
|
procedure DoRefreshItems; override;
|
|
function GetDragAndDropParams: TcxCustomGridHitTest; override;
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
public
|
|
procedure PaintItem(ACanvas: TcxCanvas; R: TRect; AIndex: Integer; AFocused: Boolean); override;
|
|
end;
|
|
|
|
TcxGridChartOptionsTreeViewClass = class of TcxGridChartOptionsTreeView;
|
|
|
|
TcxGridChartOptionsTreeView = class(TcxGridOptionsTreeView)
|
|
private
|
|
FGridView: TcxGridChartView;
|
|
protected
|
|
LegendID: Integer;
|
|
LegendAlignmentID: Integer;
|
|
LegendBorderID: Integer;
|
|
LegendKeyBorderID: Integer;
|
|
LegendOrientationID: Integer;
|
|
LegendPositionID: Integer;
|
|
TitleID: Integer;
|
|
TitleAlignmentID: Integer;
|
|
TitlePositionID: Integer;
|
|
ToolBoxID: Integer;
|
|
ToolBoxBorderID: Integer;
|
|
ToolBoxDiagramSelectorID: Integer;
|
|
ToolBoxPositionID: Integer;
|
|
OtherID: Integer;
|
|
OtherValueHintsID: Integer;
|
|
|
|
procedure AddItems; override;
|
|
function IsItemChecked(AParentID, AID: Integer): Boolean; override;
|
|
procedure ItemClicked(AParentID, AID: Integer); override;
|
|
|
|
property GridView: TcxGridChartView read FGridView;
|
|
public
|
|
constructor Create(AOwner: TComponent; AGridView: TcxGridChartView); reintroduce; virtual;
|
|
end;
|
|
|
|
TcxGridChartCustomizationForm = class(TcxCustomGridCustomizationForm)
|
|
private
|
|
FDataGroupsListBox: TcxGridChartDataGroupsListBox;
|
|
FDataGroupsPage: TcxTabSheet;
|
|
FOptionsPage: TcxTabSheet;
|
|
FOptionsTreeView: TcxGridChartOptionsTreeView;
|
|
FSeriesCheckListBox: TcxGridChartSeriesCheckListBox;
|
|
FSortBySeriesComboBox: TcxGridChartSortBySeriesComboBox;
|
|
FSortBySeriesLabel: TcxLabel;
|
|
FSeriesPage: TcxTabSheet;
|
|
function GetGridView: TcxGridChartView;
|
|
protected
|
|
function CanChangeSortedSeries: Boolean; virtual;
|
|
procedure CreateControls; override;
|
|
function GetDataGroupsListBoxClass: TcxGridChartDataGroupsListBoxClass; virtual;
|
|
function GetDataGroupsPageVisible: Boolean; virtual;
|
|
function GetOptionsPageVisible: Boolean; virtual;
|
|
function GetOptionsTreeViewClass: TcxGridChartOptionsTreeViewClass; virtual;
|
|
function GetSeriesCheckListBoxClass: TcxGridChartSeriesCheckListBoxClass; virtual;
|
|
function GetSeriesPageVisible: Boolean; virtual;
|
|
function GetSortBySeriesComboBoxClass: TcxGridChartSortBySeriesComboBoxClass; virtual;
|
|
procedure GridViewChanged; override;
|
|
procedure InitPageControl; override;
|
|
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
public
|
|
procedure PrepareForDataGroupDragAndDrop; virtual;
|
|
procedure RefreshData; override;
|
|
|
|
property DataGroupsListBox: TcxGridChartDataGroupsListBox read FDataGroupsListBox;
|
|
property DataGroupsPage: TcxTabSheet read FDataGroupsPage;
|
|
property OptionsPage: TcxTabSheet read FOptionsPage;
|
|
property OptionsTreeView: TcxGridChartOptionsTreeView read FOptionsTreeView;
|
|
property SeriesCheckListBox: TcxGridChartSeriesCheckListBox read FSeriesCheckListBox;
|
|
property SeriesPage: TcxTabSheet read FSeriesPage;
|
|
property SortBySeriesComboBox: TcxGridChartSortBySeriesComboBox read FSortBySeriesComboBox;
|
|
property SortBySeriesLabel: TcxLabel read FSortBySeriesLabel;
|
|
end;
|
|
|
|
// popups
|
|
|
|
IcxGridChartDataLevelActiveValuePopupOwner = interface(IcxCustomGridPopupOwner)
|
|
['{94AE5C9F-9A81-401D-8B76-E3278CDD0CEB}']
|
|
function GetDataGroup: TcxGridChartDataGroup;
|
|
end;
|
|
|
|
TcxGridChartDataLevelActiveValuePopupClass = class of TcxGridChartDataLevelActiveValuePopup;
|
|
|
|
TcxGridChartDataLevelActiveValuePopup = class(TcxCustomGridPopup)
|
|
private
|
|
FDataGroup: TcxGridChartDataGroup;
|
|
FListBox: TcxGridPopupListBox;
|
|
function GetGridView: TcxGridChartView;
|
|
procedure ListBoxAction(Sender: TcxGridPopupListBox; AItemIndex: Integer);
|
|
protected
|
|
Values: TVariantArray;
|
|
procedure AddValueItems(AStrings: TStrings; out AValues: TVariantArray); virtual;
|
|
procedure AdjustListBoxSize; virtual;
|
|
procedure InitPopup; override;
|
|
procedure SetDataGroupActiveValue(AItemIndex: Integer); virtual;
|
|
property ListBox: TcxGridPopupListBox read FListBox;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); override;
|
|
property DataGroup: TcxGridChartDataGroup read FDataGroup;
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
end;
|
|
|
|
TcxGridChartDiagramSelectorPopupListBox = class(TcxGridPopupListBox)
|
|
protected
|
|
function CalculateItemHeight: Integer; override;
|
|
procedure DrawItemContent(ACanvas: TcxCanvas; AIndex: Integer; ARect: TRect;
|
|
AState: TOwnerDrawState); override;
|
|
end;
|
|
|
|
TcxGridChartDiagramSelectorPopupClass = class of TcxGridChartDiagramSelectorPopup;
|
|
|
|
TcxGridChartDiagramSelectorPopup = class(TcxCustomGridPopup)
|
|
private
|
|
FListBox: TcxGridChartDiagramSelectorPopupListBox;
|
|
function GetGridView: TcxGridChartView;
|
|
procedure ListBoxAction(Sender: TcxGridPopupListBox; AItemIndex: Integer);
|
|
protected
|
|
procedure AddDiagramItems(AStrings: TStrings); virtual;
|
|
function GetImageOffset: Integer; virtual;
|
|
procedure InitPopup; override;
|
|
procedure SelectDiagram(AItemIndex: Integer); virtual;
|
|
property ListBox: TcxGridChartDiagramSelectorPopupListBox read FListBox;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); override;
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
property ImageOffset: Integer read GetImageOffset;
|
|
end;
|
|
|
|
// controller
|
|
|
|
TcxGridChartController = class(TcxCustomGridController)
|
|
private
|
|
FDataLevelActiveValuePopup: TcxGridChartDataLevelActiveValuePopup;
|
|
FDiagramSelectorPopup: TcxGridChartDiagramSelectorPopup;
|
|
FFirstVisibleCategoryIndex: Integer;
|
|
FFirstVisibleCategoryIndexes: array of Integer;
|
|
FMovingDataGroup: TcxGridChartDataGroup;
|
|
FStoredFirstVisibleCategoryIndex: Integer;
|
|
function GetCustomizationForm: TcxGridChartCustomizationForm;
|
|
function GetDataLevelActiveValuePopup: TcxGridChartDataLevelActiveValuePopup;
|
|
function GetDiagramSelectorPopup: TcxGridChartDiagramSelectorPopup;
|
|
function GetGridView: TcxGridChartView;
|
|
function GetIsDataGroupMoving: Boolean;
|
|
function GetViewInfo: TcxGridChartViewInfo;
|
|
function GetVisibleCategoryCountValue: Integer;
|
|
procedure SetFirstVisibleCategoryIndex(Value: Integer);
|
|
protected
|
|
procedure ActiveDataLevelChanged(APrevActiveDataLevel, AActiveDataLevel: Integer); virtual;
|
|
procedure ActiveDiagramChanged(ADiagram: TcxGridChartDiagram); virtual;
|
|
procedure CheckCoordinates; override;
|
|
procedure DataLevelsChanged; virtual;
|
|
procedure FirstVisibleCategoryIndexChanged; virtual;
|
|
function GetDataLevelActiveValuePopupClass: TcxGridChartDataLevelActiveValuePopupClass; virtual;
|
|
function GetDesignHitTest(AHitTest: TcxCustomGridHitTest): Boolean; override;
|
|
function GetDiagramSelectorPopupClass: TcxGridChartDiagramSelectorPopupClass; virtual;
|
|
function GetPatternObject(AObject: TPersistent): TPersistent; override;
|
|
|
|
function GetFirstVisibleCategoryIndex: Integer; virtual;
|
|
function GetVisibleCategoryCount(ACheckCount: Boolean): Integer; virtual;
|
|
|
|
function CanDataDrillDown(AValueIndex: Integer): Boolean; virtual;
|
|
function CanDataDrillUp: Boolean; virtual;
|
|
function DoDataDrillDown(AValueIndex: Integer): Boolean; virtual;
|
|
function DoDataDrillUp: Boolean; virtual;
|
|
function MayDataDrillDown(ACheckDesignTime: Boolean = True): Boolean; virtual;
|
|
|
|
// scrollbar
|
|
function CanShowScrollBar: Boolean; virtual;
|
|
function GetScrollBarKind: TScrollBarKind; virtual;
|
|
function GetScrollBarPageSize: Integer; virtual;
|
|
function GetScrollBarPos: Integer; virtual;
|
|
function GetScrollBarSize: Integer; virtual;
|
|
function ScrollPosToCategoryIndex(AScrollPos: Integer): Integer; virtual;
|
|
|
|
function CanShowDataLevelActiveValuePopup(ACheckDesignTime: Boolean = True): Boolean; virtual;
|
|
|
|
// customization
|
|
procedure CustomizationChanged; override;
|
|
function GetCustomizationFormClass: TcxCustomGridCustomizationFormClass; override;
|
|
function GetCustomizationFormDefaultWidth: Integer; override;
|
|
function GetDataLevelInfoDragAndDropObjectClass: TcxGridChartDataGroupMovingObjectClass; virtual;
|
|
|
|
property ViewInfo: TcxGridChartViewInfo read GetViewInfo;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); override;
|
|
destructor Destroy; override;
|
|
function HasDataLevelActiveValuePopup: Boolean;
|
|
function HasDiagramSelectorPopup: Boolean;
|
|
procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
|
|
|
|
procedure InitScrollBarsParameters; override;
|
|
procedure Scroll(AScrollBarKind: TScrollBarKind; AScrollCode: TScrollCode;
|
|
var AScrollPos: Integer); override;
|
|
|
|
function GetValueHintText(ASeries: TcxGridChartSeries; AValueIndex: Integer): string; virtual;
|
|
|
|
// data drill down
|
|
function DataDrillDown(AValueIndex: Integer): Boolean; virtual;
|
|
function DataDrillUp: Boolean; virtual;
|
|
function IsDataDrillDownPossible(AValueIndex: Integer): Boolean;
|
|
|
|
// paging
|
|
function ActiveDiagramSupportsPaging: Boolean;
|
|
property FirstVisibleCategoryIndex: Integer read GetFirstVisibleCategoryIndex write SetFirstVisibleCategoryIndex;
|
|
property VisibleCategoryCount: Integer read GetVisibleCategoryCountValue;
|
|
|
|
property CustomizationForm: TcxGridChartCustomizationForm read GetCustomizationForm;
|
|
property DataLevelActiveValuePopup: TcxGridChartDataLevelActiveValuePopup read GetDataLevelActiveValuePopup;
|
|
property DiagramSelectorPopup: TcxGridChartDiagramSelectorPopup read GetDiagramSelectorPopup;
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
property IsDataGroupMoving: Boolean read GetIsDataGroupMoving;
|
|
property MovingDataGroup: TcxGridChartDataGroup read FMovingDataGroup;
|
|
end;
|
|
|
|
{ datacontroller }
|
|
|
|
{$HPPEMIT '__interface IcxGridChartItem;'}
|
|
|
|
IcxGridChartItem = interface
|
|
['{CDDAE712-6292-4814-A69E-7D871B299EB2}']
|
|
procedure DataChanged;
|
|
function GetDataBinding: TcxGridChartItemDataBinding;
|
|
function GetID: Integer;
|
|
procedure ValueTypeClassChanged;
|
|
end;
|
|
|
|
IcxGridChartViewItemsProvider = interface
|
|
['{852B466D-5068-4600-BBC6-0061BF69A0B0}']
|
|
function GetItem(AItemClass: TcxGridChartItemClass; AIndex: Integer): TcxGridChartItem;
|
|
procedure GetItemCaptions(AItemClass: TcxGridChartItemClass; ACaptions: TStringList);
|
|
procedure InitItem(AItem: TcxGridChartItem; AIndex: Integer);
|
|
end;
|
|
|
|
TcxGridChartDataController = class(TcxDataController, IcxCustomGridDataController)
|
|
private
|
|
function GetGridViewValue: TcxGridChartView;
|
|
function GetOnAfterSummary: TcxAfterSummaryEvent;
|
|
function GetOnSummary: TcxSummaryEvent;
|
|
procedure SetOnAfterSummary(Value: TcxAfterSummaryEvent);
|
|
procedure SetOnSummary(Value: TcxSummaryEvent);
|
|
protected
|
|
{ IcxCustomGridDataController }
|
|
procedure AssignData(ADataController: TcxCustomDataController);
|
|
procedure CreateAllItems(AMissingItemsOnly: Boolean);
|
|
procedure DeleteAllItems;
|
|
procedure GetFakeComponentLinks(AList: TList);
|
|
function GetGridView: TcxCustomGridView;
|
|
function HasAllItems: Boolean;
|
|
function IsDataChangeable: Boolean;
|
|
function IsDataLinked: Boolean;
|
|
function SupportsCreateAllItems: Boolean;
|
|
|
|
procedure DoValueTypeClassChanged(AItemIndex: Integer); override;
|
|
//function GetChartViewItemIndex: Integer; override;
|
|
function GetItemID(AItem: TObject): Integer; override;
|
|
function GetSortingBySummaryEngineClass: TcxSortingBySummaryEngineClass; override;
|
|
procedure Unlocked; override;
|
|
public
|
|
procedure BeginFullUpdate; override;
|
|
procedure EndFullUpdate; override;
|
|
function GetItem(Index: Integer): TObject; override;
|
|
property GridView: TcxGridChartView read GetGridViewValue;
|
|
published
|
|
property Options;
|
|
property OnAfterSummary: TcxAfterSummaryEvent read GetOnAfterSummary write SetOnAfterSummary;
|
|
property OnCompare;
|
|
property OnDataChanged;
|
|
property OnFilterRecord;
|
|
property OnRecordChanged;
|
|
property OnSummary: TcxSummaryEvent read GetOnSummary write SetOnSummary;
|
|
end;
|
|
|
|
{ painter }
|
|
|
|
// title
|
|
|
|
TcxGridChartTitlePainter = class(TcxCustomGridCellPainter)
|
|
private
|
|
function GetViewInfo: TcxCustomGridChartTitleViewInfo;
|
|
protected
|
|
procedure PrepareCanvasForDrawText; override;
|
|
procedure UnprepareCanvasForDrawText; override;
|
|
public
|
|
property ViewInfo: TcxCustomGridChartTitleViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
// legend
|
|
|
|
TcxGridChartLegendItemPainter = class(TcxCustomGridCellPainter)
|
|
private
|
|
function GetViewInfo: TcxGridChartLegendItemViewInfo;
|
|
protected
|
|
procedure DrawContent; override;
|
|
procedure DrawLegendKey; virtual;
|
|
property ViewInfo: TcxGridChartLegendItemViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
TcxGridChartLegendPainter = class(TcxCustomGridCellPainter)
|
|
private
|
|
function GetViewInfo: TcxGridChartLegendViewInfo;
|
|
protected
|
|
procedure DrawContent; override;
|
|
function ExcludeFromClipRect: Boolean; override;
|
|
property ViewInfo: TcxGridChartLegendViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
// custom diagram
|
|
|
|
TcxGridChartDiagramPainter = class(TcxCustomGridCellPainter)
|
|
private
|
|
function GetViewInfo: TcxGridChartDiagramViewInfo;
|
|
protected
|
|
procedure DrawValueCaptions; virtual;
|
|
procedure DrawValues; virtual;
|
|
procedure FillAndExcludeRect(const R: TRect);
|
|
function NeedsPainting: Boolean; override;
|
|
procedure Paint; override;
|
|
procedure PrepareClipRegionForValueDrawing(AValueViewInfo: TcxGridChartDiagramValueViewInfo;
|
|
AOriginalClipRegion: TcxRegion); virtual;
|
|
property ViewInfo: TcxGridChartDiagramViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
// histogram
|
|
|
|
TcxGridChartHistogramTickMarkLabelsPainter = class(TcxCustomGridCellPainter)
|
|
private
|
|
function GetViewInfo: TcxGridChartHistogramTickMarkLabelsViewInfo;
|
|
protected
|
|
procedure DrawCaptions; virtual;
|
|
procedure DrawContent; override;
|
|
public
|
|
property ViewInfo: TcxGridChartHistogramTickMarkLabelsViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
TcxGridChartHistogramPainter = class(TcxGridChartDiagramPainter)
|
|
private
|
|
function GetViewInfo: TcxGridChartHistogramViewInfo;
|
|
protected
|
|
procedure DrawCategoryAxis; virtual;
|
|
procedure DrawCategoryGridLines; virtual;
|
|
procedure DrawContent; override;
|
|
procedure DrawPlotBackground; virtual;
|
|
procedure DrawValueAxis; virtual;
|
|
procedure DrawValueGridLines; virtual;
|
|
procedure DrawValuesBackground; virtual;
|
|
function GetTransparentValues: Boolean; virtual; abstract;
|
|
function GetValuesClipRect: TRect; virtual;
|
|
procedure SetValuesClipRegion; virtual;
|
|
|
|
property TransparentValues: Boolean read GetTransparentValues;
|
|
property ViewInfo: TcxGridChartHistogramViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
// column diagram
|
|
|
|
TcxGridChartColumnDiagramValuePainter = class(TcxCustomGridCellPainter)
|
|
protected
|
|
function ExcludeFromClipRect: Boolean; override;
|
|
end;
|
|
|
|
TcxGridChartColumnDiagramPainter = class(TcxGridChartHistogramPainter)
|
|
protected
|
|
function GetTransparentValues: Boolean; override;
|
|
end;
|
|
|
|
// line diagram
|
|
|
|
TcxGridChartLineDiagramLegendItemPainter = class(TcxGridChartLegendItemPainter)
|
|
private
|
|
function GetViewInfo: TcxGridChartLineDiagramLegendItemViewInfo;
|
|
protected
|
|
procedure DrawLegendKey; override;
|
|
procedure DrawLine; virtual;
|
|
procedure DrawMarker; virtual;
|
|
property ViewInfo: TcxGridChartLineDiagramLegendItemViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
TcxGridChartLineDiagramValuePainterClass = class of TcxGridChartLineDiagramValuePainter;
|
|
|
|
TcxGridChartLineDiagramValuePainter = class(TcxCustomGridCellPainter)
|
|
private
|
|
function GetViewInfo: TcxGridChartLineDiagramValueViewInfo;
|
|
protected
|
|
function CanDrawDesignSelection: Boolean; override;
|
|
procedure DrawContent; override;
|
|
procedure DrawLine; virtual;
|
|
procedure DrawMarker; virtual;
|
|
property ViewInfo: TcxGridChartLineDiagramValueViewInfo read GetViewInfo;
|
|
public
|
|
class procedure DrawLineEx(ACanvas: TcxCanvas; const AStart, AFinish: TPoint;
|
|
AStyle: TcxGridChartLineStyle; AWidth: Integer; AColor: TColor); virtual;
|
|
class procedure DrawLines(ACanvas: TcxCanvas; const APoints: TPointArray;
|
|
AStyle: TcxGridChartLineStyle; AWidth: Integer; AColor: TColor); virtual;
|
|
class procedure DrawMarkerEx(ACanvas: TcxCanvas; const ABounds: TRect;
|
|
const APoints: TPointArray; AStyle: TcxGridChartMarkerStyle;
|
|
const AParams: TcxViewParams); virtual;
|
|
end;
|
|
|
|
TcxGridChartLineDiagramPainter = class(TcxGridChartHistogramPainter)
|
|
protected
|
|
procedure DrawContent; override;
|
|
procedure DrawValuesDesignSelection; virtual;
|
|
function GetTransparentValues: Boolean; override;
|
|
end;
|
|
|
|
// area diagram
|
|
|
|
TcxGridChartAreaDiagramLegendItemPainter = class(TcxGridChartLineDiagramLegendItemPainter)
|
|
protected
|
|
procedure DrawAreaBackground; virtual;
|
|
procedure DrawAreaBorder; virtual;
|
|
procedure DrawLegendKey; override;
|
|
end;
|
|
|
|
TcxGridChartAreaDiagramValuePainter = class(TcxGridChartLineDiagramValuePainter)
|
|
private
|
|
function GetViewInfo: TcxGridChartAreaDiagramValueViewInfo;
|
|
protected
|
|
procedure DoDrawArea; virtual;
|
|
procedure DrawArea; virtual;
|
|
property ViewInfo: TcxGridChartAreaDiagramValueViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
TcxGridChartAreaDiagramPainter = class(TcxGridChartLineDiagramPainter)
|
|
protected
|
|
procedure DrawValuesBackground; override;
|
|
end;
|
|
|
|
// pie diagram
|
|
|
|
TcxGridChartPieDiagramValuePainter = class(TcxCustomGridCellPainter)
|
|
private
|
|
function GetViewInfo: TcxGridChartPieDiagramValueViewInfo;
|
|
protected
|
|
procedure DrawContent; override;
|
|
procedure DrawLeaderLine; virtual;
|
|
procedure DrawSlice; virtual;
|
|
property ViewInfo: TcxGridChartPieDiagramValueViewInfo read GetViewInfo;
|
|
public
|
|
procedure MainPaint; override;
|
|
end;
|
|
|
|
TcxGridChartPieSeriesSiteCaptionPainter = class(TcxCustomGridCellPainter)
|
|
protected
|
|
function ExcludeFromClipRect: Boolean; override;
|
|
end;
|
|
|
|
TcxGridChartPieSeriesSitePainter = class(TcxCustomGridCellPainter)
|
|
protected
|
|
function CanDrawDesignSelection: Boolean; override;
|
|
function ExcludeFromClipRect: Boolean; override;
|
|
end;
|
|
|
|
TcxGridChartPieDiagramPainter = class(TcxGridChartDiagramPainter)
|
|
private
|
|
function GetViewInfo: TcxGridChartPieDiagramViewInfo;
|
|
protected
|
|
procedure DrawContent; override;
|
|
procedure DrawSeriesDesignSelection; virtual;
|
|
procedure DrawSeriesSites; virtual;
|
|
procedure DrawValues; override;
|
|
procedure ExcludeSeriesPieAreasFromClipRegion; virtual;
|
|
procedure PrepareClipRegionForValueDrawing(AValueViewInfo: TcxGridChartDiagramValueViewInfo;
|
|
AOriginalClipRegion: TcxRegion); override;
|
|
property ViewInfo: TcxGridChartPieDiagramViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
// ToolBox
|
|
|
|
TcxGridChartToolBoxItemSeparatorPainter = class(TcxCustomGridCellPainter)
|
|
protected
|
|
procedure DrawContent; override;
|
|
end;
|
|
|
|
TcxGridChartToolBoxDataLevelActiveValuePainter = class(TcxCustomGridCellPainter)
|
|
private
|
|
function GetViewInfo: TcxGridChartToolBoxDataLevelActiveValueViewInfo;
|
|
protected
|
|
procedure PrepareCanvasForDrawText; override;
|
|
property ViewInfo: TcxGridChartToolBoxDataLevelActiveValueViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
TcxGridChartToolBoxDataLevelInfoPainter = class(TcxCustomGridCellPainter)
|
|
protected
|
|
procedure DrawBackground; override;
|
|
function ExcludeFromClipRect: Boolean; override;
|
|
end;
|
|
|
|
TcxGridChartToolBoxCustomizeButtonPainter = class(TcxCustomGridCellPainter)
|
|
private
|
|
function GetViewInfo: TcxGridChartToolBoxCustomizeButtonViewInfo;
|
|
protected
|
|
procedure Paint; override;
|
|
property ViewInfo: TcxGridChartToolBoxCustomizeButtonViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
TcxGridChartToolBoxDiagramSelectorPainter = class(TcxCustomGridCellPainter)
|
|
private
|
|
function GetViewInfo: TcxGridChartToolBoxDiagramSelectorViewInfo;
|
|
protected
|
|
procedure DrawContent; override;
|
|
procedure DrawImage; virtual;
|
|
procedure PrepareCanvasForDrawText; override;
|
|
property ViewInfo: TcxGridChartToolBoxDiagramSelectorViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
TcxGridChartToolBoxPainter = class(TcxCustomGridCellPainter)
|
|
private
|
|
function GetViewInfo: TcxGridChartToolBoxViewInfo;
|
|
protected
|
|
procedure DrawContent; override;
|
|
procedure DrawDataLevelInfoConnectors; virtual;
|
|
procedure DrawItems(AOpaqueItems: Boolean); virtual;
|
|
function ExcludeFromClipRect: Boolean; override;
|
|
property ViewInfo: TcxGridChartToolBoxViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
// view
|
|
|
|
TcxGridChartPainter = class(TcxCustomGridPainter)
|
|
private
|
|
function GetViewInfo: TcxGridChartViewInfo;
|
|
protected
|
|
procedure PaintAfter; override;
|
|
procedure PaintContent; override;
|
|
public
|
|
property ViewInfo: TcxGridChartViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
{ view data }
|
|
|
|
TcxGridChartViewData = class(TcxCustomGridViewData)
|
|
private
|
|
FDataGroupIndex: Integer;
|
|
FSumOfValues: TVariantArray;
|
|
function GetCategory(AIndex: Integer): Variant;
|
|
function GetCategoryCount: Integer;
|
|
function GetChildCount: Integer;
|
|
function GetChildDataGroupIndex(Index: Integer): Integer;
|
|
function GetChildLevel: Integer;
|
|
function GetChildRecordIndex(Index: Integer): Integer;
|
|
function GetDataGroupIndex: Integer;
|
|
function GetGridView: TcxGridChartView;
|
|
function GetGroupValue(ADataGroupIndex, AIndex: Integer): Variant;
|
|
function GetSumOfValues(ASeriesIndex: Integer): Variant;
|
|
function GetValue(ASeriesIndex, AIndex: Integer): Variant;
|
|
function GetVisibleCategory(AIndex: Integer): Variant;
|
|
function GetVisibleCategoryCount: Integer;
|
|
function GetVisibleGroupValue(AVisibleDataGroupIndex, AIndex: Integer): Variant;
|
|
function GetVisibleGroupValueCount(AVisibleDataGroupIndex: Integer): Integer;
|
|
function GetVisibleValue(ASeriesIndex, AIndex: Integer): Variant;
|
|
procedure SetCategory(AIndex: Integer; const Value: Variant);
|
|
procedure SetCategoryCount(Value: Integer);
|
|
procedure SetGroupValue(ADataGroupIndex, AIndex: Integer; const Value: Variant);
|
|
procedure SetValue(ASeriesIndex, AIndex: Integer; const Value: Variant);
|
|
protected
|
|
function CalculateDataGroupIndex: Integer; virtual;
|
|
function CalculateSumOfValues(ASeriesIndex: Integer): Variant; virtual;
|
|
procedure CheckValueAtLevel(ALevel: Integer; var AValue: Variant);
|
|
function GetDataGroupIndexByLevel(ALevel: Integer): Integer;
|
|
function GetRecordIndexByValueIndex(AValueIndex: Integer): Integer;
|
|
procedure DataLevelsChanged; virtual;
|
|
function IsDataGrouped: Boolean;
|
|
function IsSummaryLevel: Boolean;
|
|
procedure CalculateSumsOfValues;
|
|
procedure SeriesPosChanged(ASeries: TcxGridChartSeries); virtual;
|
|
procedure Update(AInfo: TcxUpdateControlInfo); virtual;
|
|
procedure UpdateDataGroupIndex;
|
|
procedure UpdateSumsOfValues;
|
|
|
|
property ChildCount: Integer read GetChildCount;
|
|
property ChildDataGroupIndex[Index: Integer]: Integer read GetChildDataGroupIndex;
|
|
property ChildLevel: Integer read GetChildLevel;
|
|
property ChildRecordIndex[Index: Integer]: Integer read GetChildRecordIndex;
|
|
property DataGroupIndex: Integer read GetDataGroupIndex;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); override;
|
|
procedure GetVisibleGroupValues(ADataGroup: TcxGridChartDataGroup; AStrings: TStrings;
|
|
out AValues: TVariantArray);
|
|
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
property SumOfValues[ASeriesIndex: Integer]: Variant read GetSumOfValues;
|
|
|
|
// all values
|
|
property Categories[AIndex: Integer]: Variant read GetCategory write SetCategory;
|
|
property CategoryCount: Integer read GetCategoryCount write SetCategoryCount;
|
|
property GroupValues[ADataGroupIndex, AIndex: Integer]: Variant read GetGroupValue write SetGroupValue;
|
|
property Values[ASeriesIndex, AIndex: Integer]: Variant read GetValue write SetValue;
|
|
|
|
// visible values
|
|
property VisibleCategories[AIndex: Integer]: Variant read GetVisibleCategory;
|
|
property VisibleCategoryCount: Integer read GetVisibleCategoryCount;
|
|
property VisibleValues[ASeriesIndex, AIndex: Integer]: Variant read GetVisibleValue;
|
|
|
|
property VisibleGroupValueCount[AVisibleDataGroupIndex: Integer]: Integer read GetVisibleGroupValueCount;
|
|
property VisibleGroupValues[AVisibleDataGroupIndex, AIndex: Integer]: Variant read GetVisibleGroupValue;
|
|
end;
|
|
|
|
{ view info }
|
|
|
|
// part
|
|
|
|
TcxCustomGridChartPartViewInfo = class(TcxCustomGridViewCellViewInfo)
|
|
private
|
|
function GetGridView: TcxGridChartView;
|
|
function GetGridViewInfo: TcxGridChartViewInfo;
|
|
protected
|
|
function GetAlignment: TcxGridChartPartAlignment; virtual; abstract;
|
|
function GetHeight: Integer; override;
|
|
function GetOrientation: TcxGridChartPartOrientation; virtual; abstract;
|
|
function GetPosition: TcxGridChartPartPosition; virtual; abstract;
|
|
function GetVisible: Boolean; override;
|
|
function GetWidth: Integer; override;
|
|
public
|
|
property Alignment: TcxGridChartPartAlignment read GetAlignment;
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
property GridViewInfo: TcxGridChartViewInfo read GetGridViewInfo;
|
|
property Orientation: TcxGridChartPartOrientation read GetOrientation;
|
|
property Position: TcxGridChartPartPosition read GetPosition;
|
|
end;
|
|
|
|
// custom title
|
|
|
|
TcxCustomGridChartTitleViewInfo = class(TcxCustomGridChartPartViewInfo)
|
|
private
|
|
FTitle: TcxCustomGridChartTitle;
|
|
protected
|
|
function CalculateHeight: Integer; override;
|
|
function CalculateWidth: Integer; override;
|
|
function GetAlignment: TcxGridChartPartAlignment; override;
|
|
function GetOrientation: TcxGridChartPartOrientation; override;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
function GetPosition: TcxGridChartPartPosition; override;
|
|
function GetText: string; override;
|
|
function GetTextAreaBounds: TRect; override;
|
|
function HasBackground: Boolean; override;
|
|
public
|
|
constructor Create(AGridViewInfo: TcxCustomGridViewInfo; ATitle: TcxCustomGridChartTitle); reintroduce; virtual;
|
|
property Title: TcxCustomGridChartTitle read FTitle;
|
|
end;
|
|
|
|
// custom legend
|
|
|
|
TcxGridChartLegendItemViewInfoClass = class of TcxGridChartLegendItemViewInfo;
|
|
|
|
TcxGridChartLegendItemViewInfo = class(TcxCustomGridViewCellViewInfo)
|
|
private
|
|
FContainer: TcxGridChartLegendViewInfo;
|
|
FIndex: Integer;
|
|
function GetDiagram: TcxGridChartDiagram;
|
|
function GetGridView: TcxGridChartView;
|
|
function GetLegendKeyHeight: Integer;
|
|
function GetLegendKeyWidth: Integer;
|
|
function GetSeries: TcxGridChartSeries;
|
|
protected
|
|
function CalculateContentBounds: TRect; override;
|
|
function CalculateHeight: Integer; override;
|
|
function CalculateWidth: Integer; override;
|
|
function CalculateLegendKeyHeight: Integer; virtual;
|
|
function CalculateLegendKeySize: Integer; virtual;
|
|
function CalculateLegendKeyWidth: Integer; virtual;
|
|
function CustomDraw(ACanvas: TcxCanvas): Boolean; override;
|
|
procedure DoCalculateParams; override;
|
|
function GetDesignSelectionBounds: TRect; override;
|
|
function GetHitTestClass: TcxCustomGridHitTestClass; override;
|
|
function GetIsDesignSelected: Boolean; override;
|
|
function GetLegendKeyBorders: TcxBorders; virtual;
|
|
function GetLegendKeyBounds: TRect; virtual;
|
|
function GetLegendKeyOffset: Integer; virtual;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
function GetText: string; override;
|
|
function GetTextAreaBounds: TRect; override;
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
function HasBackground: Boolean; override;
|
|
function HasCustomDraw: Boolean; override;
|
|
procedure InitHitTest(AHitTest: TcxCustomGridHitTest); override;
|
|
|
|
property LegendKeyHeight: Integer read GetLegendKeyHeight;
|
|
property LegendKeyOffset: Integer read GetLegendKeyOffset;
|
|
property LegendKeyWidth: Integer read GetLegendKeyWidth;
|
|
public
|
|
LegendKeyParams: TcxViewParams;
|
|
constructor Create(AContainer: TcxGridChartLegendViewInfo; AIndex: Integer); reintroduce; virtual;
|
|
function GetAreaBoundsForPainting: TRect; override;
|
|
function MouseDown(AHitTest: TcxCustomGridHitTest; AButton: TMouseButton;
|
|
AShift: TShiftState): Boolean; override;
|
|
property Container: TcxGridChartLegendViewInfo read FContainer;
|
|
property Diagram: TcxGridChartDiagram read GetDiagram;
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
property Index: Integer read FIndex;
|
|
property LegendKeyBorders: TcxBorders read GetLegendKeyBorders;
|
|
property LegendKeyBounds: TRect read GetLegendKeyBounds;
|
|
property Series: TcxGridChartSeries read GetSeries;
|
|
end;
|
|
|
|
TcxGridChartLegendKind = (lkSeries, lkCategories);
|
|
|
|
TcxGridChartLegendViewInfoClass = class of TcxGridChartLegendViewInfo;
|
|
|
|
TcxGridChartLegendViewInfo = class(TcxCustomGridChartPartViewInfo)
|
|
private
|
|
FDiagram: TcxGridChartDiagram;
|
|
FItemLegendKeyWidth: Integer;
|
|
FItemLegendKeyHeight: Integer;
|
|
FItemOffset: Integer;
|
|
FItems: TList;
|
|
function GetCount: Integer;
|
|
function GetItem(Index: Integer): TcxGridChartLegendItemViewInfo;
|
|
function GetItemLegendKeyWidth: Integer;
|
|
function GetItemLegendKeyHeight: Integer;
|
|
function GetItemOffset: Integer;
|
|
protected
|
|
function CalculateHeight: Integer; override;
|
|
function CalculateWidth: Integer; override;
|
|
function CalculateItemLegendKeyWidth: Integer; virtual;
|
|
function CalculateItemLegendKeyHeight: Integer; virtual;
|
|
function CalculateItemOffset: Integer; virtual;
|
|
function CustomDraw(ACanvas: TcxCanvas): Boolean; override;
|
|
function GetAlignment: TcxGridChartPartAlignment; override;
|
|
function GetBorderColor(AIndex: TcxBorder): TColor; override;
|
|
function GetBorders: TcxBorders; override;
|
|
function GetBorderWidth(AIndex: TcxBorder): Integer; override;
|
|
function GetHitTestClass: TcxCustomGridHitTestClass; override;
|
|
function GetOrientation: TcxGridChartPartOrientation; override;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
function GetPosition: TcxGridChartPartPosition; override;
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
function GetVisible: Boolean; override;
|
|
function HasCustomDraw: Boolean; override;
|
|
|
|
function AddItem: TcxGridChartLegendItemViewInfo;
|
|
procedure CalculateItems; virtual;
|
|
function GetItemCaption(AIndex: Integer): string; virtual;
|
|
function GetItemClass: TcxGridChartLegendItemViewInfoClass; virtual;
|
|
function GetItemCount: Integer; virtual;
|
|
function GetItemObjectIndex(AIndex: Integer): Integer; virtual; abstract;
|
|
function GetItemSeriesIndex(AIndex: Integer): Integer; virtual;
|
|
function GetItemValueIndex(AIndex: Integer): Integer; virtual;
|
|
function GetKind: TcxGridChartLegendKind; virtual; abstract;
|
|
//function ItemLegendKeyBorderIsValueBorder: Boolean; virtual;
|
|
|
|
property ItemLegendKeyWidth: Integer read GetItemLegendKeyWidth;
|
|
property ItemLegendKeyHeight: Integer read GetItemLegendKeyHeight;
|
|
property ItemOffset: Integer read GetItemOffset;
|
|
public
|
|
constructor Create(AGridViewInfo: TcxCustomGridViewInfo; ADiagram: TcxGridChartDiagram); reintroduce; virtual;
|
|
destructor Destroy; override;
|
|
procedure Calculate(ALeftBound, ATopBound: Integer; AWidth: Integer = -1;
|
|
AHeight: Integer = -1); override;
|
|
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; override;
|
|
procedure GetItemLegendKeyParams(AIndex: Integer; out AParams: TcxViewParams); virtual;
|
|
property Diagram: TcxGridChartDiagram read FDiagram;
|
|
property Count: Integer read GetCount;
|
|
property Items[Index: Integer]: TcxGridChartLegendItemViewInfo read GetItem;
|
|
property Kind: TcxGridChartLegendKind read GetKind;
|
|
end;
|
|
|
|
// custom diagram
|
|
|
|
TcxGridChartDiagramValueCaptionViewInfoClass = class of TcxGridChartDiagramValueCaptionViewInfo;
|
|
|
|
TcxGridChartDiagramValueCaptionViewInfo = class(TcxCustomGridViewCellViewInfo)
|
|
private
|
|
FValueViewInfo: TcxGridChartDiagramValueViewInfo;
|
|
protected
|
|
function GetAlignmentHorz: TAlignment; override;
|
|
function GetAlignmentVert: TcxAlignmentVert; override;
|
|
function CalculateHeight: Integer; override;
|
|
function CalculateWidth: Integer; override;
|
|
function GetText: string; override;
|
|
function GetTextAreaBounds: TRect; override;
|
|
function GetTextAttributes(AForPainting: Boolean): Integer; override;
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
function GetVisible: Boolean; override;
|
|
function HasBackground: Boolean; override;
|
|
function HasVisualCompensation: Boolean; virtual;
|
|
public
|
|
constructor Create(AValueViewInfo: TcxGridChartDiagramValueViewInfo); reintroduce; virtual;
|
|
property ValueViewInfo: TcxGridChartDiagramValueViewInfo read FValueViewInfo;
|
|
end;
|
|
|
|
TcxGridChartDiagramValueViewInfoClass = class of TcxGridChartDiagramValueViewInfo;
|
|
|
|
TcxGridChartDiagramValueViewInfo = class(TcxCustomGridViewCellViewInfo)
|
|
private
|
|
FCaptionViewInfo: TcxGridChartDiagramValueCaptionViewInfo;
|
|
FDiagramViewInfo: TcxGridChartDiagramViewInfo;
|
|
FSeriesIndex: Integer;
|
|
FVisibleValueIndex: Integer;
|
|
function GetController: TcxGridChartController;
|
|
function GetDiagram: TcxGridChartDiagram;
|
|
function GetGridView: TcxGridChartView;
|
|
function GetSeries: TcxGridChartSeries;
|
|
function GetValueIndex: Integer;
|
|
protected
|
|
function CalculateCaptionBounds: TRect; virtual; abstract;
|
|
function CanShowHint: Boolean; override;
|
|
function CustomDraw(ACanvas: TcxCanvas): Boolean; override;
|
|
function GetCaptionViewInfoClass: TcxGridChartDiagramValueCaptionViewInfoClass; virtual;
|
|
function GetCaptionText: string; virtual;
|
|
procedure GetCaptionViewParams(var AParams: TcxViewParams); virtual;
|
|
function GetCellBoundsForHint: TRect; override;
|
|
function GetHintText: string; override;
|
|
function GetHintTextRect(const AMousePos: TPoint): TRect; override;
|
|
function GetHitTestClass: TcxCustomGridHitTestClass; override;
|
|
function GetHotTrack: Boolean; override;
|
|
function GetIsDesignSelected: Boolean; override;
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
function HasCaption: Boolean; virtual;
|
|
function HasCaptionVisualCompensation: Boolean; virtual;
|
|
function HasCustomDraw: Boolean; override;
|
|
function HasHintPoint(const P: TPoint): Boolean; override;
|
|
procedure InitHitTest(AHitTest: TcxCustomGridHitTest); override;
|
|
function IsHintForText: Boolean; override;
|
|
function IsHintMultiLine: Boolean; override;
|
|
procedure StateChanged(APrevState: TcxGridCellState); override;
|
|
|
|
property Controller: TcxGridChartController read GetController;
|
|
property Diagram: TcxGridChartDiagram read GetDiagram;
|
|
public
|
|
constructor Create(ADiagramViewInfo: TcxGridChartDiagramViewInfo;
|
|
ASeriesIndex, AVisibleValueIndex: Integer); reintroduce; virtual;
|
|
destructor Destroy; override;
|
|
procedure Calculate(ALeftBound, ATopBound: Integer; AWidth: Integer = -1;
|
|
AHeight: Integer = -1); override;
|
|
function MouseDown(AHitTest: TcxCustomGridHitTest; AButton: TMouseButton;
|
|
AShift: TShiftState): Boolean; override;
|
|
property CaptionViewInfo: TcxGridChartDiagramValueCaptionViewInfo read FCaptionViewInfo;
|
|
property DiagramViewInfo: TcxGridChartDiagramViewInfo read FDiagramViewInfo;
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
property Series: TcxGridChartSeries read GetSeries;
|
|
property SeriesIndex: Integer read FSeriesIndex;
|
|
property ValueIndex: Integer read GetValueIndex;
|
|
property VisibleValueIndex: Integer read FVisibleValueIndex;
|
|
end;
|
|
|
|
TcxGridChartDiagramViewInfoClass = class of TcxGridChartDiagramViewInfo;
|
|
|
|
TcxGridChartDiagramViewInfo = class(TcxCustomGridViewCellViewInfo)
|
|
private
|
|
FDiagram: TcxGridChartDiagram;
|
|
FValueViewInfos: TList;
|
|
function GetCategory(AIndex: Integer): string;
|
|
function GetGridView: TcxGridChartView;
|
|
function GetSeries(AIndex: Integer): TcxGridChartSeries;
|
|
function GetSeriesCount: Integer;
|
|
function GetValueCount: Integer;
|
|
function GetValueViewInfoValue(Index: Integer): TcxGridChartDiagramValueViewInfo;
|
|
function GetValueViewInfoCount: Integer;
|
|
function GetViewData: TcxGridChartViewData;
|
|
protected
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
procedure InitHitTest(AHitTest: TcxCustomGridHitTest); override;
|
|
|
|
function CreateValueViewInfo(ASeriesIndex, AVisibleValueIndex: Integer): TcxGridChartDiagramValueViewInfo;
|
|
function GetValue(ASeriesIndex, AIndex: Integer): Variant; virtual;
|
|
function GetValueCaption(ASeriesIndex, AVisibleValueIndex: Integer): string; virtual;
|
|
function GetValueIndex(AVisibleValueIndex: Integer): Integer; virtual;
|
|
class function GetValueViewInfoClass: TcxGridChartDiagramValueViewInfoClass; virtual; // abstract; - because of CLR, BCB
|
|
function GetValueViewInfoIndex(ASeriesIndex, AVisibleIndex: Integer): Integer; virtual; abstract;
|
|
function GetVisibleCategory(AIndex: Integer): string; virtual;
|
|
function GetVisibleValue(ASeriesIndex, AIndex: Integer): Variant; virtual;
|
|
function GetVisibleValueCount: Integer; virtual;
|
|
|
|
property Categories[AIndex: Integer]: string read GetCategory;
|
|
property Values[ASeriesIndex, AIndex: Integer]: Variant read GetValue;
|
|
property Series[AIndex: Integer]: TcxGridChartSeries read GetSeries;
|
|
public
|
|
constructor Create(AGridViewInfo: TcxCustomGridViewInfo; ADiagram: TcxGridChartDiagram); reintroduce; virtual;
|
|
destructor Destroy; override;
|
|
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; override;
|
|
function GetValueViewInfo(ASeriesIndex, AVisibleIndex: Integer): TcxGridChartDiagramValueViewInfo;
|
|
property Diagram: TcxGridChartDiagram read FDiagram;
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
property SeriesCount: Integer read GetSeriesCount;
|
|
property ValueCount: Integer read GetValueCount;
|
|
property ValueViewInfoCount: Integer read GetValueViewInfoCount;
|
|
property ValueViewInfos[Index: Integer]: TcxGridChartDiagramValueViewInfo read GetValueViewInfoValue;
|
|
property ViewData: TcxGridChartViewData read GetViewData;
|
|
property VisibleCategories[AIndex: Integer]: string read GetVisibleCategory;
|
|
property VisibleValueCount: Integer read GetVisibleValueCount;
|
|
property VisibleValues[ASeriesIndex, AIndex: Integer]: Variant read GetVisibleValue;
|
|
end;
|
|
|
|
// histogram legend
|
|
|
|
TcxGridChartHistogramLegendViewInfo = class(TcxGridChartLegendViewInfo)
|
|
private
|
|
function GetDiagram: TcxGridChartHistogram;
|
|
protected
|
|
function GetItemObjectIndex(AIndex: Integer): Integer; override;
|
|
function GetItemsInReverseOrder: Boolean; virtual;
|
|
function GetKind: TcxGridChartLegendKind; override;
|
|
property ItemsInReverseOrder: Boolean read GetItemsInReverseOrder;
|
|
public
|
|
property Diagram: TcxGridChartHistogram read GetDiagram;
|
|
end;
|
|
|
|
// histogram
|
|
|
|
TcxGridChartHistogramValueViewInfo = class(TcxGridChartDiagramValueViewInfo)
|
|
private
|
|
function GetCategoryDirection: TcxDirection;
|
|
function GetDiagramViewInfo: TcxGridChartHistogramViewInfo;
|
|
function GetValueDirection: TcxDirection;
|
|
public
|
|
property CategoryDirection: TcxDirection read GetCategoryDirection;
|
|
property DiagramViewInfo: TcxGridChartHistogramViewInfo read GetDiagramViewInfo;
|
|
property ValueDirection: TcxDirection read GetValueDirection;
|
|
end;
|
|
|
|
TcxGridChartHistogramAxisTitleViewInfoClass = class of TcxGridChartHistogramAxisTitleViewInfo;
|
|
|
|
TcxGridChartHistogramAxisTitleViewInfo = class(TcxCustomGridChartTitleViewInfo)
|
|
private
|
|
FContainer: TcxGridChartHistogramTickMarkLabelsViewInfo;
|
|
function GetTitle: TcxGridChartHistogramAxisTitle;
|
|
protected
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
procedure InitHitTest(AHitTest: TcxCustomGridHitTest); override;
|
|
public
|
|
constructor Create(AContainer: TcxGridChartHistogramTickMarkLabelsViewInfo;
|
|
ATitle: TcxCustomGridChartTitle); reintroduce; virtual;
|
|
property Container: TcxGridChartHistogramTickMarkLabelsViewInfo read FContainer;
|
|
property Title: TcxGridChartHistogramAxisTitle read GetTitle;
|
|
end;
|
|
|
|
TcxGridChartAxisPosition = cppLeft..cppBottom;
|
|
|
|
TcxGridChartHistogramTickMarkLabelsViewInfo = class(TcxCustomGridViewCellViewInfo)
|
|
private
|
|
FCaptionBounds: TRectArray;
|
|
FCaptionHeight: Integer;
|
|
FCaptionWidths: array of Integer;
|
|
FDiagramViewInfo: TcxGridChartHistogramViewInfo;
|
|
FIsTwoRowLayout: Boolean;
|
|
FTitleViewInfo: TcxGridChartHistogramAxisTitleViewInfo;
|
|
function GetCaptionBounds(Index: Integer): TRect;
|
|
function GetCaptionHeight: Integer;
|
|
function GetCaptionWidth(Index: Integer): Integer;
|
|
function GetDiagram: TcxGridChartHistogram;
|
|
function GetIsVertical: Boolean;
|
|
procedure SetCaptionBounds(Index: Integer; const Value: TRect);
|
|
protected
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
function GetTitleViewInfoClass: TcxGridChartHistogramAxisTitleViewInfoClass; virtual;
|
|
|
|
function GetCaption(Index: Integer): string; virtual;
|
|
function GetCount: Integer; virtual; abstract;
|
|
function GetIsReverseOrder: Boolean; virtual; abstract;
|
|
function GetValue(Index: Integer): Variant; virtual; abstract;
|
|
|
|
function CalculateCaptionBounds(AIndex: Integer): TRect; virtual;
|
|
procedure CalculateCaptionsBounds; virtual;
|
|
function CalculateHeight(AWidth, ALeftReduction, ARightReduction: Integer): Integer; {overload;}reintroduce; virtual;
|
|
function CalculateWidth: Integer; override;
|
|
function CalculateIsTwoRowLayout(AWidth, ALeftReduction, ARightReduction: Integer): Boolean; virtual;
|
|
procedure CalculateTitleBounds(out ATitleBounds, AContentBounds: TRect); virtual;
|
|
function GetAlignmentHorz: TAlignment; override;
|
|
function GetAxis: TcxGridChartHistogramAxis; virtual; abstract;
|
|
function GetCaptionPosition(AIndex: Integer): Integer; virtual; abstract;
|
|
function GetCaptionsVisible: Boolean; virtual;
|
|
procedure GetEdgeCaptionsReductions(var ALeftReduction, ARightReduction: Integer); virtual;
|
|
function GetIsEdgeCaptions: Boolean; virtual; abstract;
|
|
function GetPosition: TcxGridChartAxisPosition; virtual; abstract;
|
|
function GetTextAttributes(AForPainting: Boolean): Integer; override;
|
|
procedure GetTitleViewParams(var AParams: TcxViewParams); virtual; abstract;
|
|
function GetVisible: Boolean; override;
|
|
|
|
property Axis: TcxGridChartHistogramAxis read GetAxis;
|
|
property CaptionHeight: Integer read GetCaptionHeight;
|
|
property CaptionWidths[Index: Integer]: Integer read GetCaptionWidth;
|
|
property Diagram: TcxGridChartHistogram read GetDiagram;
|
|
property IsEdgeCaptions: Boolean read GetIsEdgeCaptions;
|
|
property IsReverseOrder: Boolean read GetIsReverseOrder;
|
|
property IsTwoRowLayout: Boolean read FIsTwoRowLayout write FIsTwoRowLayout;
|
|
property IsVertical: Boolean read GetIsVertical;
|
|
public
|
|
constructor Create(ADiagramViewInfo: TcxGridChartHistogramViewInfo); reintroduce; virtual;
|
|
destructor Destroy; override;
|
|
procedure Calculate(ALeftBound, ATopBound: Integer; AWidth: Integer = -1;
|
|
AHeight: Integer = -1); override;
|
|
procedure FitCaptionsHorz(AWidth: Integer; var ALeftReduction, ARightReduction: Integer); virtual;
|
|
procedure FitCaptionsVert(var ATopReduction, ABottomReduction: Integer); virtual;
|
|
function GetCaptionSpace(AWidth, ALeftReduction, ARightReduction: Integer): Integer; virtual;
|
|
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; override;
|
|
|
|
property CaptionBounds[Index: Integer]: TRect read GetCaptionBounds write SetCaptionBounds;
|
|
property Captions[Index: Integer]: string read GetCaption;
|
|
property CaptionsVisible: Boolean read GetCaptionsVisible;
|
|
property Count: Integer read GetCount;
|
|
property DiagramViewInfo: TcxGridChartHistogramViewInfo read FDiagramViewInfo;
|
|
property Position: TcxGridChartAxisPosition read GetPosition;
|
|
property TitleViewInfo: TcxGridChartHistogramAxisTitleViewInfo read FTitleViewInfo;
|
|
property Values[Index: Integer]: Variant read GetValue;
|
|
end;
|
|
|
|
TcxGridChartHistogramCategoryAxisTitleViewInfo = class(TcxGridChartHistogramAxisTitleViewInfo)
|
|
protected
|
|
function GetHitTestClass: TcxCustomGridHitTestClass; override;
|
|
end;
|
|
|
|
TcxGridChartHistogramCategoryTickMarkLabelsViewInfoClass = class of TcxGridChartHistogramCategoryTickMarkLabelsViewInfo;
|
|
|
|
TcxGridChartHistogramCategoryTickMarkLabelsViewInfo = class(TcxGridChartHistogramTickMarkLabelsViewInfo)
|
|
protected
|
|
function GetTitleViewInfoClass: TcxGridChartHistogramAxisTitleViewInfoClass; override;
|
|
|
|
function GetCount: Integer; override;
|
|
function GetIsReverseOrder: Boolean; override;
|
|
function GetValue(Index: Integer): Variant; override;
|
|
|
|
function GetAxis: TcxGridChartHistogramAxis; override;
|
|
function GetCaptionPosition(AIndex: Integer): Integer; override;
|
|
function GetIsEdgeCaptions: Boolean; override;
|
|
function GetPosition: TcxGridChartAxisPosition; override;
|
|
procedure GetTitleViewParams(var AParams: TcxViewParams); override;
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
end;
|
|
|
|
TcxGridChartHistogramValueAxisTitleViewInfo = class(TcxGridChartHistogramAxisTitleViewInfo)
|
|
protected
|
|
function GetHitTestClass: TcxCustomGridHitTestClass; override;
|
|
end;
|
|
|
|
TcxGridChartHistogramValueTickMarkLabelsViewInfoClass = class of TcxGridChartHistogramValueTickMarkLabelsViewInfo;
|
|
|
|
TcxGridChartHistogramValueTickMarkLabelsViewInfo = class(TcxGridChartHistogramTickMarkLabelsViewInfo)
|
|
private
|
|
function GetAxisValue: TcxGridChartHistogramAxisValue;
|
|
protected
|
|
function GetTitleViewInfoClass: TcxGridChartHistogramAxisTitleViewInfoClass; override;
|
|
|
|
function GetCaption(Index: Integer): string; override;
|
|
function GetCount: Integer; override;
|
|
function GetIsReverseOrder: Boolean; override;
|
|
function GetValue(Index: Integer): Variant; override;
|
|
|
|
function GetAxis: TcxGridChartHistogramAxis; override;
|
|
function GetCaptionPosition(AIndex: Integer): Integer; override;
|
|
function GetIsEdgeCaptions: Boolean; override;
|
|
function GetPosition: TcxGridChartAxisPosition; override;
|
|
procedure GetTitleViewParams(var AParams: TcxViewParams); override;
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
|
|
property Axis: TcxGridChartHistogramAxisValue read GetAxisValue;
|
|
end;
|
|
|
|
TcxGridChartHistogramMark = record
|
|
Value: Variant;
|
|
Position: Integer;
|
|
end;
|
|
TcxGridChartHistogramMarks = array of TcxGridChartHistogramMark;
|
|
|
|
TcxGridChartHistogramViewInfo = class(TcxGridChartDiagramViewInfo)
|
|
private
|
|
FCategoryTickMarkLabelsViewInfo: TcxGridChartHistogramCategoryTickMarkLabelsViewInfo;
|
|
FCategoryMarkHeight: Integer;
|
|
FCategoryMarks: TcxGridChartHistogramMarks;
|
|
FHasValuesOutOfRange: Boolean;
|
|
FIsPlotBoundsCalculated: Boolean;
|
|
FMinValue: Extended;
|
|
FMaxValue: Extended;
|
|
FMinVisualValue: Extended;
|
|
FMaxVisualValue: Extended;
|
|
FPlotBounds: TRect;
|
|
FSumOfValues: TVariantArray;
|
|
FValueTickMarkLabelsViewInfo: TcxGridChartHistogramValueTickMarkLabelsViewInfo;
|
|
FValueMarkHeight: Integer;
|
|
FValueMarks: TcxGridChartHistogramMarks;
|
|
FValueStep: Extended;
|
|
function GetCategoryAxisColor: TColor;
|
|
function GetCategoryGridLineColor: TColor;
|
|
function GetCategoryMarkCount: Integer;
|
|
function GetCategoryMarkPosition(Index: Integer): Integer;
|
|
function GetCategoryMarkValue(Index: Integer): Integer;
|
|
function GetDiagram: TcxGridChartHistogram;
|
|
function GetHasCategoryAxis: Boolean;
|
|
function GetHasCategoryGridLines: Boolean;
|
|
function GetHasValueAxis: Boolean;
|
|
function GetHasValueGridLines: Boolean;
|
|
function GetIsCategoriesInReverseOrder: Boolean;
|
|
function GetIsCategoryAxisHorz: Boolean;
|
|
function GetIsValueAxisVert: Boolean;
|
|
function GetPlotBounds: TRect;
|
|
function GetSumOfValues(AValueIndex: Integer): Variant;
|
|
function GetValueAxisColor: TColor;
|
|
function GetValueGridLineColor: TColor;
|
|
function GetValueMarkCount: Integer;
|
|
function GetValueMarkPosition(Index: Integer): Integer;
|
|
function GetValueMarkValue(Index: Integer): Extended;
|
|
function GetZeroValueOffset: Integer;
|
|
procedure SetCategoryMarkPosition(Index: Integer; Value: Integer);
|
|
procedure SetValueMarkPosition(Index: Integer; Value: Integer);
|
|
protected
|
|
function GetCategoryTickMarkLabelsViewInfoClass: TcxGridChartHistogramCategoryTickMarkLabelsViewInfoClass; virtual;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
function GetValueTickMarkLabelsViewInfoClass: TcxGridChartHistogramValueTickMarkLabelsViewInfoClass; virtual;
|
|
|
|
procedure DoCalculateParams; override;
|
|
procedure GetPlotBackgroundParams(out AParams: TcxViewParams); virtual;
|
|
|
|
function GetCategoryDirection: TcxDirection; virtual;
|
|
function GetCategoryTickMarkLabelOffsetUnits(AIndex: Integer): Integer; virtual; abstract;
|
|
function GetCategoryTickMarkOffsetUnits(AIndex: Integer; AValueAxisBetweenCategories: Boolean): Integer; virtual; abstract;
|
|
function GetUnitAdjustedOffset(AIndex: Integer): Integer; virtual;
|
|
function GetUnitCount: Integer; virtual; abstract;
|
|
function GetUnitOffset(AIndex: Integer): Integer; virtual;
|
|
function IsEdgeCategoryTickMarkLabels: Boolean; virtual; abstract;
|
|
|
|
procedure CalculateMinMaxValues(out AMinValue, AMaxValue: Extended;
|
|
out AHasValuesOutOfRange: Boolean); virtual;
|
|
procedure CalculateMinMaxVisualValues(out AMinVisualValue, AMaxVisualValue: Extended); virtual;
|
|
function CalculateSumOfValues(AValueIndex: Integer): Variant; virtual;
|
|
function CalculateValueStep: Extended; virtual;
|
|
function GetValue(ASeriesIndex, AIndex: Integer): Variant; override;
|
|
function GetValueDirection(ASeriesIndex, AVisibleValueIndex: Integer): TcxDirection; virtual;
|
|
function GetValueOffset(const AValue: Variant): Integer; virtual;
|
|
function GetZeroValue: Extended; virtual;
|
|
function IsDataInteger: Boolean;
|
|
function IsValuePositive(ASeriesIndex, AVisibleValueIndex: Integer): Boolean; virtual;
|
|
function NeedsMinMaxValuesOffset: Boolean; virtual;
|
|
|
|
procedure AddMark(var AMarks: TcxGridChartHistogramMarks; const AValue: Variant);
|
|
|
|
procedure AddCategoryMark(AValue: Integer);
|
|
procedure CalculateCategoryMarkPositions;
|
|
procedure CalculateCategoryMarkValues; virtual;
|
|
|
|
procedure AddValueMark(const AValue: Extended);
|
|
procedure CalculateValueMarkPositions;
|
|
procedure CalculateValueMarkValues; virtual;
|
|
|
|
function CalculateCategoryMarkHeight: Integer; virtual;
|
|
function CalculateValueMarkHeight: Integer; virtual;
|
|
function CalculatePlotBounds: TRect; virtual;
|
|
procedure CalculatePlotOffsets(APlotAreaWidth: Integer; var AOffsets: TRect); virtual;
|
|
procedure CalculateValues; virtual; abstract;
|
|
function GetCategoryAxisBounds: TRect; virtual;
|
|
function GetCategoryAxisPosition: TcxGridChartAxisPosition; virtual;
|
|
function GetCategoryGridLineBounds(AIndex: Integer): TRect; virtual;
|
|
function GetCategoryMarkBounds(Index: Integer): TRect; virtual;
|
|
function GetCategoryTickMarkLabelsBounds: TRect; virtual;
|
|
function GetTickMarkLabelsBounds(APosition: TcxGridChartAxisPosition): TRect; virtual;
|
|
function GetValueAxisBounds: TRect; virtual;
|
|
function GetValueAxisPosition: TcxGridChartAxisPosition; virtual;
|
|
//function GetValueBounds(AValueIndex, ASeriesIndex: Integer): TRect; virtual; abstract;
|
|
function GetValueGridLineBounds(AIndex: Integer): TRect; virtual;
|
|
function GetValueMarkBounds(Index: Integer): TRect; virtual;
|
|
function GetValueTickMarkLabelsBounds: TRect; virtual;
|
|
|
|
function CustomDrawPlot(ACanvas: TcxCanvas): Boolean; virtual;
|
|
function DoCustomDrawPlot(ACanvas: TcxCanvas): Boolean; virtual;
|
|
function HasCustomDrawPlot: Boolean; virtual;
|
|
|
|
property CategoryMarkHeight: Integer read FCategoryMarkHeight;
|
|
property CategoryMarkValues[Index: Integer]: Integer read GetCategoryMarkValue;
|
|
property HasValuesOutOfRange: Boolean read FHasValuesOutOfRange;
|
|
property IsCategoriesInReverseOrder: Boolean read GetIsCategoriesInReverseOrder;
|
|
property IsCategoryAxisHorz: Boolean read GetIsCategoryAxisHorz;
|
|
property IsValueAxisVert: Boolean read GetIsValueAxisVert;
|
|
property MinValue: Extended read FMinValue;
|
|
property MaxValue: Extended read FMaxValue;
|
|
property MinVisualValue: Extended read FMinVisualValue;
|
|
property MaxVisualValue: Extended read FMaxVisualValue;
|
|
property SumOfValues[AValueIndex: Integer]: Variant read GetSumOfValues;
|
|
property UnitCount: Integer read GetUnitCount;
|
|
property ValueMarkHeight: Integer read FValueMarkHeight;
|
|
property ValueMarkValues[Index: Integer]: Extended read GetValueMarkValue;
|
|
property ValueStep: Extended read FValueStep;
|
|
property ZeroValue: Extended read GetZeroValue;
|
|
property ZeroValueOffset: Integer read GetZeroValueOffset;
|
|
public
|
|
PlotParams: TcxViewParams;
|
|
constructor Create(AGridViewInfo: TcxCustomGridViewInfo; ADiagram: TcxGridChartDiagram); override;
|
|
destructor Destroy; override;
|
|
procedure Calculate(const ABounds: TRect); override;
|
|
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; override;
|
|
|
|
property CategoryAxisColor: TColor read GetCategoryAxisColor;
|
|
property CategoryAxisBounds: TRect read GetCategoryAxisBounds;
|
|
property CategoryAxisPosition: TcxGridChartAxisPosition read GetCategoryAxisPosition;
|
|
property CategoryGridLineBounds[AIndex: Integer]: TRect read GetCategoryGridLineBounds;
|
|
property CategoryGridLineColor: TColor read GetCategoryGridLineColor;
|
|
property CategoryMarkBounds[Index: Integer]: TRect read GetCategoryMarkBounds;
|
|
property CategoryTickMarkLabelsViewInfo: TcxGridChartHistogramCategoryTickMarkLabelsViewInfo read FCategoryTickMarkLabelsViewInfo;
|
|
property CategoryMarkCount: Integer read GetCategoryMarkCount;
|
|
property CategoryMarkPositions[Index: Integer]: Integer read GetCategoryMarkPosition write SetCategoryMarkPosition;
|
|
property Diagram: TcxGridChartHistogram read GetDiagram;
|
|
property HasCategoryAxis: Boolean read GetHasCategoryAxis;
|
|
property HasCategoryGridLines: Boolean read GetHasCategoryGridLines;
|
|
property HasValueAxis: Boolean read GetHasValueAxis;
|
|
property HasValueGridLines: Boolean read GetHasValueGridLines;
|
|
property PlotBounds: TRect read GetPlotBounds;
|
|
property ValueAxisBounds: TRect read GetValueAxisBounds;
|
|
property ValueAxisColor: TColor read GetValueAxisColor;
|
|
property ValueAxisPosition: TcxGridChartAxisPosition read GetValueAxisPosition;
|
|
property ValueGridLineBounds[AIndex: Integer]: TRect read GetValueGridLineBounds;
|
|
property ValueGridLineColor: TColor read GetValueGridLineColor;
|
|
property ValueMarkBounds[Index: Integer]: TRect read GetValueMarkBounds;
|
|
property ValueTickMarkLabelsViewInfo: TcxGridChartHistogramValueTickMarkLabelsViewInfo read FValueTickMarkLabelsViewInfo;
|
|
property ValueMarkCount: Integer read GetValueMarkCount;
|
|
property ValueMarkPositions[Index: Integer]: Integer read GetValueMarkPosition write SetValueMarkPosition;
|
|
end;
|
|
|
|
// column diagram legend
|
|
|
|
TcxGridChartColumnDiagramLegendViewInfo = class(TcxGridChartHistogramLegendViewInfo)
|
|
protected
|
|
function GetItemsInReverseOrder: Boolean; override;
|
|
end;
|
|
|
|
// column diagram
|
|
|
|
TcxGridChartColumnDiagramValueViewInfo = class(TcxGridChartHistogramValueViewInfo)
|
|
private
|
|
function GetCaptionPosition: TcxGridChartColumnDiagramValueCaptionPosition;
|
|
function GetDiagramViewInfo: TcxGridChartColumnDiagramViewInfo;
|
|
protected
|
|
function CalculateCaptionBounds: TRect; override;
|
|
function GetBorderColor(AIndex: TcxBorder): TColor; override;
|
|
function GetBorders: TcxBorders; override;
|
|
function GetBorderWidth(AIndex: TcxBorder): Integer; override;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
function HasCaption: Boolean; override;
|
|
function HasCaptionVisualCompensation: Boolean; override;
|
|
public
|
|
property CaptionPosition: TcxGridChartColumnDiagramValueCaptionPosition read GetCaptionPosition;
|
|
property DiagramViewInfo: TcxGridChartColumnDiagramViewInfo read GetDiagramViewInfo;
|
|
end;
|
|
|
|
TcxGridChartColumnDiagramViewInfo = class(TcxGridChartHistogramViewInfo)
|
|
private
|
|
function GetDiagram: TcxGridChartColumnDiagram;
|
|
protected
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
|
|
class function GetValueViewInfoClass: TcxGridChartDiagramValueViewInfoClass; override;
|
|
function GetValueViewInfoIndex(ASeriesIndex, AVisibleIndex: Integer): Integer; override;
|
|
|
|
function GetCategoryTickMarkLabelOffsetUnits(AIndex: Integer): Integer; override;
|
|
function GetCategoryTickMarkOffsetUnits(AIndex: Integer; AValueAxisBetweenCategories: Boolean): Integer; override;
|
|
function GetUnitCount: Integer; override;
|
|
function GetValueGroupAreaSizeUnits: Integer; virtual;
|
|
function GetValueOffsetUnits(AVisibleValueIndex, ASeriesIndex: Integer): Integer; virtual;
|
|
function IsEdgeCategoryTickMarkLabels: Boolean; override;
|
|
|
|
procedure CalculateValues; override;
|
|
function GetValueBounds(AVisibleValueIndex, ASeriesIndex: Integer): TRect; virtual;
|
|
public
|
|
property Diagram: TcxGridChartColumnDiagram read GetDiagram;
|
|
end;
|
|
|
|
// line diagram legend
|
|
|
|
TcxGridChartLineDiagramLegendItemViewInfo = class(TcxGridChartLegendItemViewInfo)
|
|
private
|
|
function GetDiagram: TcxGridChartLineDiagram;
|
|
function GetLineStyle: TcxGridChartLineStyle;
|
|
function GetLineWidth: Integer;
|
|
function GetMarkerSize: Integer;
|
|
function GetMarkerStyle: TcxGridChartMarkerStyle;
|
|
protected
|
|
function CalculateHeight: Integer; override;
|
|
function CalculateLegendKeyWidth: Integer; override;
|
|
procedure CalculateMarkerPoints; virtual;
|
|
procedure DoCalculateParams; override;
|
|
function GetAlignmentVert: TcxAlignmentVert; override;
|
|
function GetDiagramValueViewInfoClass: TcxGridChartLineDiagramValueViewInfoClass;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
function GetLineColor: TColor; virtual;
|
|
function GetLineStart: TPoint; virtual;
|
|
function GetLineFinish: TPoint; virtual;
|
|
function GetMarkerBounds: TRect; virtual;
|
|
property MarkerSize: Integer read GetMarkerSize;
|
|
public
|
|
MarkerParams: TcxViewParams;
|
|
MarkerPoints: TPointArray;
|
|
procedure Calculate(ALeftBound, ATopBound: Integer; AWidth: Integer = -1;
|
|
AHeight: Integer = -1); override;
|
|
property Diagram: TcxGridChartLineDiagram read GetDiagram;
|
|
property LineColor: TColor read GetLineColor;
|
|
property LineStart: TPoint read GetLineStart;
|
|
property LineFinish: TPoint read GetLineFinish;
|
|
property LineStyle: TcxGridChartLineStyle read GetLineStyle;
|
|
property LineWidth: Integer read GetLineWidth;
|
|
property MarkerBounds: TRect read GetMarkerBounds;
|
|
property MarkerStyle: TcxGridChartMarkerStyle read GetMarkerStyle;
|
|
end;
|
|
|
|
TcxGridChartLineDiagramLegendViewInfo = class(TcxGridChartHistogramLegendViewInfo)
|
|
protected
|
|
function GetItemClass: TcxGridChartLegendItemViewInfoClass; override;
|
|
public
|
|
procedure GetItemLegendKeyMarkerParams(AIndex: Integer; out AParams: TcxViewParams); virtual;
|
|
end;
|
|
|
|
// line diagram
|
|
|
|
TcxGridChartLineDiagramValueViewInfo = class(TcxGridChartHistogramValueViewInfo)
|
|
private
|
|
FLineStartY: Integer;
|
|
FLineFinishY: Integer;
|
|
function GetCaptionPosition: TcxGridChartLineDiagramValueCaptionPosition;
|
|
function GetDiagram: TcxGridChartLineDiagram;
|
|
function GetDiagramViewInfo: TcxGridChartLineDiagramViewInfo;
|
|
function GetLineStyle: TcxGridChartLineStyle;
|
|
function GetLineWidth: Integer;
|
|
function GetMarkerStyle: TcxGridChartMarkerStyle;
|
|
protected
|
|
function CalculateCaptionBounds: TRect; override;
|
|
procedure CalculateMarkerParams(var AParams: TcxViewParams); virtual;
|
|
procedure CalculateMarkerPoints; virtual;
|
|
procedure DoCalculateParams; override;
|
|
function GetCellBoundsForHint: TRect; override;
|
|
function GetDesignSelectionBounds: TRect; override;
|
|
function GetHotSpotBounds: TRect; virtual;
|
|
function GetLineColor: TColor; virtual;
|
|
function GetLineHotZoneMinWidth: Integer; virtual;
|
|
function GetLineStart: TPoint; virtual;
|
|
function GetLineFinish: TPoint; virtual;
|
|
function GetMarkerBounds: TRect; virtual;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
class function GetPainterClassEx: TcxGridChartLineDiagramValuePainterClass; virtual;
|
|
function GetPosition: TPoint; virtual;
|
|
procedure MakeRealBounds(var ABounds: TRect);
|
|
function HasBackground: Boolean; override;
|
|
function HasCaption: Boolean; override;
|
|
|
|
property Diagram: TcxGridChartLineDiagram read GetDiagram;
|
|
property HotSpotBounds: TRect read GetHotSpotBounds;
|
|
property LineHotZoneMinWidth: Integer read GetLineHotZoneMinWidth;
|
|
public
|
|
MarkerParams: TcxViewParams;
|
|
MarkerPoints: TPointArray;
|
|
procedure Calculate(const ABounds: TRect; ALineStartY, ALineFinishY: Integer); virtual;
|
|
class procedure CalculateMarkerPointsEx(const ABounds: TRect;
|
|
AStyle: TcxGridChartMarkerStyle; var APoints: TPointArray); virtual;
|
|
function GetAreaBoundsForPainting: TRect; override;
|
|
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; override;
|
|
function GetRealBounds: TRect;
|
|
function HasPoint(const P: TPoint): Boolean; override;
|
|
|
|
property CaptionPosition: TcxGridChartLineDiagramValueCaptionPosition read GetCaptionPosition;
|
|
property DiagramViewInfo: TcxGridChartLineDiagramViewInfo read GetDiagramViewInfo;
|
|
property LineColor: TColor read GetLineColor;
|
|
property LineStart: TPoint read GetLineStart;
|
|
property LineFinish: TPoint read GetLineFinish;
|
|
property LineStartY: Integer read FLineStartY;
|
|
property LineFinishY: Integer read FLineFinishY;
|
|
property LineStyle: TcxGridChartLineStyle read GetLineStyle;
|
|
property LineWidth: Integer read GetLineWidth;
|
|
property MarkerBounds: TRect read GetMarkerBounds;
|
|
property MarkerStyle: TcxGridChartMarkerStyle read GetMarkerStyle;
|
|
property Position: TPoint read GetPosition;
|
|
end;
|
|
|
|
TcxGridChartLineDiagramViewInfo = class(TcxGridChartHistogramViewInfo)
|
|
private
|
|
function GetDiagram: TcxGridChartLineDiagram;
|
|
protected
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
|
|
class function GetValueViewInfoClass: TcxGridChartDiagramValueViewInfoClass; override;
|
|
function GetValueViewInfoIndex(ASeriesIndex, AVisibleIndex: Integer): Integer; override;
|
|
|
|
function GetCategoryTickMarkLabelOffsetUnits(AIndex: Integer): Integer; override;
|
|
function GetCategoryTickMarkOffsetUnits(AIndex: Integer; AValueAxisBetweenCategories: Boolean): Integer; override;
|
|
function GetUnitCount: Integer; override;
|
|
function GetValueOffsetUnits(AVisibleValueIndex, ASeriesIndex: Integer): Integer; virtual;
|
|
function IsEdgeCategoryTickMarkLabels: Boolean; override;
|
|
|
|
function GetValueY(AVisibleValueIndex, ASeriesIndex: Integer): Integer; virtual;
|
|
|
|
procedure CalculatePlotOffsets(APlotAreaWidth: Integer; var AOffsets: TRect); override;
|
|
procedure CalculateValues; override;
|
|
function GetValueBounds(AVisibleValueIndex, ASeriesIndex: Integer): TRect; virtual;
|
|
public
|
|
property Diagram: TcxGridChartLineDiagram read GetDiagram;
|
|
end;
|
|
|
|
// area diagram legend
|
|
|
|
TcxGridChartAreaDiagramLegendItemViewInfo = class(TcxGridChartLineDiagramLegendItemViewInfo)
|
|
protected
|
|
function CalculateHeight: Integer; override;
|
|
function CalculateLegendKeyHeight: Integer; override;
|
|
function CalculateLegendKeyWidth: Integer; override;
|
|
function GetLineColor: TColor; override;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
end;
|
|
|
|
TcxGridChartAreaDiagramLegendViewInfo = class(TcxGridChartLineDiagramLegendViewInfo)
|
|
protected
|
|
function GetItemClass: TcxGridChartLegendItemViewInfoClass; override;
|
|
function GetItemsInReverseOrder: Boolean; override;
|
|
//function ItemLegendKeyBorderIsValueBorder: Boolean; override;
|
|
end;
|
|
|
|
// area diagram
|
|
|
|
TcxGridChartAreaDiagramValueViewInfo = class(TcxGridChartLineDiagramValueViewInfo)
|
|
private
|
|
function GetDiagram: TcxGridChartAreaDiagram;
|
|
protected
|
|
procedure CalculateAreaPoints; virtual;
|
|
function CustomDrawBackground(ACanvas: TcxCanvas): Boolean; override;
|
|
function GetAreaColor: TColor; virtual;
|
|
function GetHotSpotBounds: TRect; override;
|
|
function GetLineColor: TColor; override;
|
|
function GetLineHotZoneMinWidth: Integer; override;
|
|
class function GetPainterClassEx: TcxGridChartLineDiagramValuePainterClass; override;
|
|
function GetZeroValueOffset: Integer; virtual;
|
|
function HasCustomDrawBackground: Boolean; override;
|
|
|
|
property Diagram: TcxGridChartAreaDiagram read GetDiagram;
|
|
property ZeroValueOffset: Integer read GetZeroValueOffset;
|
|
public
|
|
AreaPoints: TPointArray;
|
|
procedure Calculate(const ABounds: TRect; ALineStartY, ALineFinishY: Integer); override;
|
|
function CreateAreaRegion: TcxRegion; virtual;
|
|
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; override;
|
|
property AreaColor: TColor read GetAreaColor;
|
|
end;
|
|
|
|
TcxGridChartAreaDiagramViewInfo = class(TcxGridChartLineDiagramViewInfo)
|
|
protected
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
class function GetValueViewInfoClass: TcxGridChartDiagramValueViewInfoClass; override;
|
|
end;
|
|
|
|
// pie diagram legend
|
|
|
|
TcxGridChartPieDiagramLegendViewInfo = class(TcxGridChartLegendViewInfo)
|
|
private
|
|
function GetDiagram: TcxGridChartPieDiagram;
|
|
protected
|
|
function GetItemObjectIndex(AIndex: Integer): Integer; override;
|
|
function GetKind: TcxGridChartLegendKind; override;
|
|
public
|
|
property Diagram: TcxGridChartPieDiagram read GetDiagram;
|
|
end;
|
|
|
|
// pie diagram
|
|
|
|
TcxGridChartPieDiagramValueViewInfo = class(TcxGridChartDiagramValueViewInfo)
|
|
private
|
|
FStartAngle: Integer;
|
|
FFinishAngle: Integer;
|
|
function GetCaptionPosition: TcxGridChartPieDiagramValueCaptionPosition;
|
|
function GetCenter: TPoint;
|
|
function GetDiagramViewInfo: TcxGridChartPieDiagramViewInfo;
|
|
function GetRadius: Integer;
|
|
protected
|
|
function CalculateCaptionBounds: TRect; override;
|
|
function CalculateCaptionCenter(AAngle, ACaptionWidth, ACaptionHeight: Integer): TPoint; virtual;
|
|
procedure CalculateLeaderLinePoints(AAngle: Integer); virtual;
|
|
function GetIsDesignSelected: Boolean; override;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
function HasBackground: Boolean; override;
|
|
function HasCaption: Boolean; override;
|
|
procedure MakeCaptionVisible(var ACaptionBounds: TRect; AAngle: Integer); virtual;
|
|
public
|
|
LeaderLinePoints: TPointArray;
|
|
procedure Calculate(const R: TRect; AStartAngle, AFinishAngle: Integer); virtual;
|
|
function HasPoint(const P: TPoint): Boolean; override;
|
|
|
|
property CaptionPosition: TcxGridChartPieDiagramValueCaptionPosition read GetCaptionPosition;
|
|
property Center: TPoint read GetCenter;
|
|
property DiagramViewInfo: TcxGridChartPieDiagramViewInfo read GetDiagramViewInfo;
|
|
property Radius: Integer read GetRadius;
|
|
property StartAngle: Integer read FStartAngle;
|
|
property FinishAngle: Integer read FFinishAngle;
|
|
end;
|
|
|
|
TcxGridChartPieSeriesSiteCaptionViewInfoClass = class of TcxGridChartPieSeriesSiteCaptionViewInfo;
|
|
|
|
TcxGridChartPieSeriesSiteCaptionViewInfo = class(TcxCustomGridViewCellViewInfo)
|
|
private
|
|
FSiteViewInfo: TcxGridChartPieSeriesSiteViewInfo;
|
|
protected
|
|
function CalculateHeight: Integer; override;
|
|
function CustomDraw(ACanvas: TcxCanvas): Boolean; override;
|
|
function GetAlignmentHorz: TAlignment; override;
|
|
function GetBorderColor(AIndex: TcxBorder): TColor; override;
|
|
function GetBorders: TcxBorders; override;
|
|
function GetBorderWidth(AIndex: TcxBorder): Integer; override;
|
|
function GetHitTestClass: TcxCustomGridHitTestClass; override;
|
|
function GetText: string; override;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
function GetVisible: Boolean; override;
|
|
function HasCustomDraw: Boolean; override;
|
|
procedure InitHitTest(AHitTest: TcxCustomGridHitTest); override;
|
|
public
|
|
constructor Create(ASiteViewInfo: TcxGridChartPieSeriesSiteViewInfo); reintroduce; virtual;
|
|
function MouseDown(AHitTest: TcxCustomGridHitTest; AButton: TMouseButton;
|
|
AShift: TShiftState): Boolean; override;
|
|
property SiteViewInfo: TcxGridChartPieSeriesSiteViewInfo read FSiteViewInfo;
|
|
end;
|
|
|
|
TcxGridChartPieSeriesSiteViewInfoClass = class of TcxGridChartPieSeriesSiteViewInfo;
|
|
|
|
TcxGridChartPieSeriesSiteViewInfo = class(TcxCustomGridViewCellViewInfo)
|
|
private
|
|
FCaptionBounds: TRect;
|
|
FCaptionViewInfo: TcxGridChartPieSeriesSiteCaptionViewInfo;
|
|
FDiagramViewInfo: TcxGridChartPieDiagramViewInfo;
|
|
FPieAreaBounds: TRect;
|
|
FSeries: TcxGridChartSeries;
|
|
function GetDiagram: TcxGridChartPieDiagram;
|
|
protected
|
|
Angles: array of Integer;
|
|
procedure CalculateAngles; virtual;
|
|
procedure CalculateCaptionAndPieAreaBounds(var ACaptionBounds, APieAreaBounds: TRect); virtual;
|
|
function CalculateContentBounds: TRect; override;
|
|
function CustomDraw(ACanvas: TcxCanvas): Boolean; override;
|
|
function GetBorderColor(AIndex: TcxBorder): TColor; override;
|
|
function GetBorders: TcxBorders; override;
|
|
function GetBorderWidth(AIndex: TcxBorder): Integer; override;
|
|
function GetCaptionViewInfoClass: TcxGridChartPieSeriesSiteCaptionViewInfoClass; virtual;
|
|
function GetDesignSelectionBounds: TRect; override;
|
|
function GetHitTestClass: TcxCustomGridHitTestClass; override;
|
|
function GetIsDesignSelected: Boolean; override;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
function GetValueViewInfo(AVisibleValueIndex: Integer): TcxGridChartPieDiagramValueViewInfo;
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
function GetVisible: Boolean; override;
|
|
function HasCustomDraw: Boolean; override;
|
|
procedure InitHitTest(AHitTest: TcxCustomGridHitTest); override;
|
|
|
|
property CaptionBounds: TRect read FCaptionBounds;
|
|
property Diagram: TcxGridChartPieDiagram read GetDiagram;
|
|
public
|
|
constructor Create(ADiagramViewInfo: TcxGridChartPieDiagramViewInfo; ASeries: TcxGridChartSeries); reintroduce; virtual;
|
|
destructor Destroy; override;
|
|
procedure Calculate(const ABounds: TRect); override;
|
|
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; override;
|
|
function IsPieEmpty: Boolean; virtual;
|
|
function MouseDown(AHitTest: TcxCustomGridHitTest; AButton: TMouseButton;
|
|
AShift: TShiftState): Boolean; override;
|
|
procedure Paint(ACanvas: TcxCanvas = nil); override;
|
|
property CaptionViewInfo: TcxGridChartPieSeriesSiteCaptionViewInfo read FCaptionViewInfo;
|
|
property DiagramViewInfo: TcxGridChartPieDiagramViewInfo read FDiagramViewInfo;
|
|
property PieAreaBounds: TRect read FPieAreaBounds;
|
|
property Series: TcxGridChartSeries read FSeries;
|
|
end;
|
|
|
|
TcxGridChartPieDiagramViewInfo = class(TcxGridChartDiagramViewInfo)
|
|
private
|
|
FPieAreaValueCaptionCompensation: Integer;
|
|
FSeriesSiteViewInfos: TList;
|
|
function GetCaptionPosition: TcxGridChartPieDiagramValueCaptionPosition;
|
|
function GetDiagram: TcxGridChartPieDiagram;
|
|
function GetSeriesSiteViewInfo(Index: Integer): TcxGridChartPieSeriesSiteViewInfo;
|
|
function GetSeriesSiteViewInfoCount: Integer;
|
|
protected
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
function GetSeriesSiteViewInfoClass: TcxGridChartPieSeriesSiteViewInfoClass; virtual;
|
|
class function GetValueViewInfoClass: TcxGridChartDiagramValueViewInfoClass; override;
|
|
function GetValueViewInfoIndex(ASeriesIndex, AVisibleIndex: Integer): Integer; override;
|
|
|
|
function CalculatePieAreaValueCaptionCompensation: Integer; virtual;
|
|
function CalculateSeriesSiteViewInfoBounds(AIndex: Integer): TRect; virtual;
|
|
function CalculateValueCaptionMaxWidth: Integer;
|
|
function CalculateValueCaptionMaxHeight: Integer;
|
|
|
|
property CaptionPosition: TcxGridChartPieDiagramValueCaptionPosition read GetCaptionPosition;
|
|
property PieAreaValueCaptionCompensation: Integer read FPieAreaValueCaptionCompensation;
|
|
public
|
|
constructor Create(AGridViewInfo: TcxCustomGridViewInfo; ADiagram: TcxGridChartDiagram); override;
|
|
destructor Destroy; override;
|
|
procedure Calculate(const ABounds: TRect); override;
|
|
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; override;
|
|
property Diagram: TcxGridChartPieDiagram read GetDiagram;
|
|
property SeriesSiteViewInfoCount: Integer read GetSeriesSiteViewInfoCount;
|
|
property SeriesSiteViewInfos[Index: Integer]: TcxGridChartPieSeriesSiteViewInfo read GetSeriesSiteViewInfo;
|
|
end;
|
|
|
|
// toolbox
|
|
|
|
TcxGridChartToolBoxItemAlignment = TcxGridChartPartPosition; // cppLeft, cppRight only
|
|
|
|
TcxGridChartToolBoxItemViewInfoClass = class of TcxGridChartToolBoxItemViewInfo;
|
|
|
|
TcxGridChartToolBoxItemViewInfo = class(TcxCustomGridViewCellViewInfo)
|
|
private
|
|
FAlignment: TcxGridChartToolBoxItemAlignment;
|
|
FContainer: TcxGridChartToolBoxViewInfo;
|
|
function GetGridView: TcxGridChartView;
|
|
protected
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
public
|
|
constructor Create(AContainer: TcxGridChartToolBoxViewInfo;
|
|
AAlignment: TcxGridChartToolBoxItemAlignment); reintroduce; virtual;
|
|
property Alignment: TcxGridChartToolBoxItemAlignment read FAlignment write FAlignment;
|
|
property Container: TcxGridChartToolBoxViewInfo read FContainer;
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
end;
|
|
|
|
TcxGridChartToolBoxItemSeparatorViewInfoClass = class of TcxGridChartToolBoxItemSeparatorViewInfo;
|
|
|
|
TcxGridChartToolBoxItemSeparatorViewInfo = class(TcxGridChartToolBoxItemViewInfo)
|
|
protected
|
|
function CalculateHeight: Integer; override;
|
|
function CalculateWidth: Integer; override;
|
|
function GetHitTestClass: TcxCustomGridHitTestClass; override;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
function HasBackground: Boolean; override;
|
|
end;
|
|
|
|
TcxGridChartToolBoxDataLevelActiveValueViewInfoClass = class of TcxGridChartToolBoxDataLevelActiveValueViewInfo;
|
|
|
|
TcxGridChartToolBoxDataLevelActiveValueViewInfo = class(TcxCustomGridViewCellViewInfo,
|
|
IcxGridChartDataLevelActiveValuePopupOwner)
|
|
private
|
|
FCanShowDropDownWindow: Boolean;
|
|
FContainer: TcxGridChartToolBoxDataLevelInfoViewInfo;
|
|
function GetGridView: TcxGridChartView;
|
|
protected
|
|
{ IcxGridChartDataLevelActiveValuePopupOwner }
|
|
function GetDataGroup: TcxGridChartDataGroup;
|
|
|
|
function CalculateContentBounds: TRect; override;
|
|
function CalculateHeight: Integer; override;
|
|
function CalculateWidth: Integer; override;
|
|
function GetAlignmentVert: TcxAlignmentVert; override;
|
|
function GetBorderColor(AIndex: TcxBorder): TColor; override;
|
|
function GetBorders: TcxBorders; override;
|
|
function GetBorderWidth(AIndex: TcxBorder): Integer; override;
|
|
function GetHitTestClass: TcxCustomGridHitTestClass; override;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
function GetText: string; override;
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
procedure InitHitTest(AHitTest: TcxCustomGridHitTest); override;
|
|
|
|
function DropDownWindowExists: Boolean; override;
|
|
function GetDropDownWindow: TcxCustomGridPopup; override;
|
|
function GetDropDownWindowOwnerBounds: TRect; override;
|
|
public
|
|
constructor Create(AContainer: TcxGridChartToolBoxDataLevelInfoViewInfo); reintroduce; virtual;
|
|
property CanShowDropDownWindow: Boolean read FCanShowDropDownWindow;
|
|
property Container: TcxGridChartToolBoxDataLevelInfoViewInfo read FContainer;
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
end;
|
|
|
|
TcxGridChartToolBoxDataLevelInfoViewInfoClass = class of TcxGridChartToolBoxDataLevelInfoViewInfo;
|
|
|
|
TcxGridChartToolBoxDataLevelInfoViewInfo = class(TcxGridChartToolBoxItemViewInfo)
|
|
private
|
|
FActiveValueViewInfo: TcxGridChartToolBoxDataLevelActiveValueViewInfo;
|
|
FDataLevel: Integer;
|
|
function GetActive: Boolean;
|
|
function GetDataLevelObject: TcxGridChartDataGroup;
|
|
protected
|
|
function CalculateActiveValueViewInfoBounds: TRect; virtual;
|
|
function CalculateContentBounds: TRect; override;
|
|
function CalculateHeight: Integer; override;
|
|
function CalculateWidth: Integer; override;
|
|
function GetActiveValueViewInfoClass: TcxGridChartToolBoxDataLevelActiveValueViewInfoClass; virtual;
|
|
function GetAlignmentHorz: TAlignment; override;
|
|
function GetAlignmentVert: TcxAlignmentVert; override;
|
|
function GetBorderColor(AIndex: TcxBorder): TColor; override;
|
|
function GetBorders: TcxBorders; override;
|
|
function GetBorderWidth(AIndex: TcxBorder): Integer; override;
|
|
function GetDesignObject: TPersistent; virtual;
|
|
function GetHitTestClass: TcxCustomGridHitTestClass; override;
|
|
function GetIsDesignSelected: Boolean; override;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
function GetText: string; override;
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
function HasActiveValue: Boolean; virtual;
|
|
procedure InitHitTest(AHitTest: TcxCustomGridHitTest); override;
|
|
public
|
|
constructor Create(AContainer: TcxGridChartToolBoxViewInfo;
|
|
AAlignment: TcxGridChartToolBoxItemAlignment; ADataLevel: Integer); reintroduce; virtual;
|
|
destructor Destroy; override;
|
|
procedure Calculate(ALeftBound, ATopBound: Integer; AWidth: Integer = -1;
|
|
AHeight: Integer = -1); override;
|
|
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; override;
|
|
function MouseDown(AHitTest: TcxCustomGridHitTest; AButton: TMouseButton;
|
|
AShift: TShiftState): Boolean; override;
|
|
procedure Paint(ACanvas: TcxCanvas = nil); override;
|
|
property Active: Boolean read GetActive;
|
|
property ActiveValueViewInfo: TcxGridChartToolBoxDataLevelActiveValueViewInfo read FActiveValueViewInfo;
|
|
property DataLevel: Integer read FDataLevel;
|
|
property DataLevelObject: TcxGridChartDataGroup read GetDataLevelObject;
|
|
end;
|
|
|
|
TcxGridChartToolBoxCustomizeButtonViewInfoClass = class of TcxGridChartToolBoxCustomizeButtonViewInfo;
|
|
|
|
TcxGridChartToolBoxCustomizeButtonViewInfo = class(TcxGridChartToolBoxItemViewInfo)
|
|
private
|
|
function GetChecked: Boolean;
|
|
procedure SetChecked(Value: Boolean);
|
|
protected
|
|
function CalculateHeight: Integer; override;
|
|
function CalculateWidth: Integer; override;
|
|
function CaptureMouseOnPress: Boolean; override;
|
|
procedure Click; override;
|
|
function GetActualState: TcxGridCellState; override;
|
|
function GetBorders: TcxBorders; override;
|
|
function GetBorderWidth(AIndex: TcxBorder): Integer; override;
|
|
function GetHitTestClass: TcxCustomGridHitTestClass; override;
|
|
function GetHotTrack: Boolean; override;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
function GetText: string; override;
|
|
function HasBackground: Boolean; override;
|
|
property Checked: Boolean read GetChecked write SetChecked;
|
|
end;
|
|
|
|
TcxGridChartToolBoxDiagramSelectorViewInfoClass = class of TcxGridChartToolBoxDiagramSelectorViewInfo;
|
|
|
|
TcxGridChartToolBoxDiagramSelectorViewInfo = class(TcxGridChartToolBoxItemViewInfo)
|
|
private
|
|
FCanShowDropDownWindow: Boolean;
|
|
function GetDropDownWindowValue: TcxGridChartDiagramSelectorPopup;
|
|
protected
|
|
function CalculateHeight: Integer; override;
|
|
function CalculateWidth: Integer; override;
|
|
function GetAlignmentVert: TcxAlignmentVert; override;
|
|
function GetHitTestClass: TcxCustomGridHitTestClass; override;
|
|
function GetImageBounds: TRect; virtual;
|
|
function GetImageHeight: Integer; virtual;
|
|
function GetImageIndex: Integer; virtual;
|
|
function GetImageWidth: Integer; virtual;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
function GetText: string; override;
|
|
function GetTextAreaBounds: TRect; override;
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
function HasBackground: Boolean; override;
|
|
procedure InitHitTest(AHitTest: TcxCustomGridHitTest); override;
|
|
|
|
function CalculateCanShowDropDownWindow: Boolean; virtual;
|
|
function DropDownWindowExists: Boolean; override;
|
|
function GetDropDownWindow: TcxCustomGridPopup; override;
|
|
function GetDropDownWindowOwnerBounds: TRect; override;
|
|
property DropDownWindow: TcxGridChartDiagramSelectorPopup read GetDropDownWindowValue;
|
|
|
|
property ImageWidth: Integer read GetImageWidth;
|
|
property ImageHeight: Integer read GetImageHeight;
|
|
public
|
|
constructor Create(AContainer: TcxGridChartToolBoxViewInfo;
|
|
AAlignment: TcxGridChartToolBoxItemAlignment); override;
|
|
property CanShowDropDownWindow: Boolean read FCanShowDropDownWindow;
|
|
property ImageBounds: TRect read GetImageBounds;
|
|
property ImageIndex: Integer read GetImageIndex;
|
|
end;
|
|
|
|
TcxGridChartToolBoxViewInfoClass = class of TcxGridChartToolBoxViewInfo;
|
|
|
|
TcxGridChartToolBoxViewInfo = class(TcxCustomGridChartPartViewInfo)
|
|
private
|
|
FCustomizeButton: TcxGridChartToolBoxCustomizeButtonViewInfo;
|
|
FDataLevelInfos: TList;
|
|
FDiagramSelector: TcxGridChartToolBoxDiagramSelectorViewInfo;
|
|
FItems: TList;
|
|
function GetCount: Integer;
|
|
function GetDataLevelInfoConnectorCount: Integer;
|
|
function GetDataLevelInfo(AIndex: Integer): TcxGridChartToolBoxDataLevelInfoViewInfo;
|
|
function GetDataLevelInfoCount: Integer;
|
|
function GetItem(AIndex: Integer): TcxGridChartToolBoxItemViewInfo;
|
|
protected
|
|
function CalculateHeight: Integer; override;
|
|
function CalculateWidth: Integer; override;
|
|
function CalculateContentBounds: TRect; override;
|
|
procedure CalculateItems; virtual;
|
|
function GetAlignment: TcxGridChartPartAlignment; override;
|
|
function GetAlignmentVert: TcxAlignmentVert; override;
|
|
function GetBorders: TcxBorders; override;
|
|
function GetBorderColor(AIndex: TcxBorder): TColor; override;
|
|
function GetBorderWidth(AIndex: TcxBorder): Integer; override;
|
|
function GetDataGroupInsertionAreaBounds: TRect; virtual;
|
|
function GetDataLevelInfoConnector(AIndex: Integer): TRect; virtual;
|
|
function GetDataLevelInfoConnectorColor: TColor; virtual;
|
|
function GetFirstSeparator: TcxGridChartToolBoxItemViewInfo;
|
|
function GetHitTestClass: TcxCustomGridHitTestClass; override;
|
|
function GetItemsAreaBounds: TRect; virtual;
|
|
function GetOrientation: TcxGridChartPartOrientation; override;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
function GetPosition: TcxGridChartPartPosition; override;
|
|
function GetText: string; override;
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
function GetVisible: Boolean; override;
|
|
|
|
function AddItem(AItem: TcxGridChartToolBoxItemViewInfo): TcxGridChartToolBoxItemViewInfo;
|
|
procedure AddSeparator(AAlignment: TcxGridChartToolBoxItemAlignment);
|
|
procedure CreateItems; virtual;
|
|
function GetCustomizeButtonClass: TcxGridChartToolBoxCustomizeButtonViewInfoClass; virtual;
|
|
function GetDataLevelInfoClass: TcxGridChartToolBoxDataLevelInfoViewInfoClass; virtual;
|
|
function GetDiagramSelectorClass: TcxGridChartToolBoxDiagramSelectorViewInfoClass; virtual;
|
|
function GetItemSeparatorClass: TcxGridChartToolBoxItemSeparatorViewInfoClass; virtual;
|
|
function IsCustomizeButtonVisible: Boolean; virtual;
|
|
function IsDataLevelsInfoVisible: Boolean; virtual;
|
|
function IsDiagramSelectorVisible: Boolean; virtual;
|
|
function IsSeparator(AItem: TcxGridChartToolBoxItemViewInfo): Boolean;
|
|
|
|
property ItemsAreaBounds: TRect read GetItemsAreaBounds;
|
|
public
|
|
constructor Create(AGridViewInfo: TcxCustomGridViewInfo); override;
|
|
destructor Destroy; override;
|
|
procedure Calculate(ALeftBound, ATopBound: Integer; AWidth: Integer = -1;
|
|
AHeight: Integer = -1); override;
|
|
function GetDataGroupInsertionBounds(AIndex: Integer): TRect; virtual;
|
|
function GetDataGroupInsertionIndex(const P: TPoint): Integer; virtual;
|
|
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; override;
|
|
procedure InvalidateCustomizeButton;
|
|
property Count: Integer read GetCount;
|
|
property CustomizeButton: TcxGridChartToolBoxCustomizeButtonViewInfo read FCustomizeButton;
|
|
property DataLevelInfoConnectorColor: TColor read GetDataLevelInfoConnectorColor;
|
|
property DataLevelInfoConnectorCount: Integer read GetDataLevelInfoConnectorCount;
|
|
property DataLevelInfoConnectors[AIndex: Integer]: TRect read GetDataLevelInfoConnector;
|
|
property DataLevelInfoCount: Integer read GetDataLevelInfoCount;
|
|
property DataLevelInfos[AIndex: Integer]: TcxGridChartToolBoxDataLevelInfoViewInfo read GetDataLevelInfo;
|
|
property DiagramSelector: TcxGridChartToolBoxDiagramSelectorViewInfo read FDiagramSelector;
|
|
property Items[AIndex: Integer]: TcxGridChartToolBoxItemViewInfo read GetItem;
|
|
end;
|
|
|
|
// view
|
|
|
|
TcxGridChartTitleViewInfoClass = class of TcxGridChartTitleViewInfo;
|
|
|
|
TcxGridChartTitleViewInfo = class(TcxCustomGridChartTitleViewInfo)
|
|
protected
|
|
function GetHitTestClass: TcxCustomGridHitTestClass; override;
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
end;
|
|
|
|
TcxGridChartViewInfo = class(TcxCustomGridViewInfo)
|
|
private
|
|
FDiagramViewInfo: TcxGridChartDiagramViewInfo;
|
|
FIsImage: Boolean;
|
|
FLegendViewInfo: TcxGridChartLegendViewInfo;
|
|
FTitleViewInfo: TcxGridChartTitleViewInfo;
|
|
FToolBoxViewInfo: TcxGridChartToolBoxViewInfo;
|
|
function GetGridView: TcxGridChartView;
|
|
protected
|
|
procedure CreateViewInfos; override;
|
|
procedure DestroyViewInfos(AIsRecreating: Boolean); override;
|
|
|
|
function GetTitleViewInfoClass: TcxGridChartTitleViewInfoClass; virtual;
|
|
function GetToolBoxViewInfoClass: TcxGridChartToolBoxViewInfoClass; virtual;
|
|
|
|
procedure Calculate; override;
|
|
function CalculateClientBounds: TRect; override;
|
|
procedure CalculateHeight(const AMaxSize: TPoint; var AHeight: Integer;
|
|
var AFullyVisible: Boolean); override;
|
|
procedure CalculatePartBounds(APart: TcxCustomGridChartPartViewInfo;
|
|
var ABounds, APartBounds: TRect); virtual;
|
|
procedure CalculatePartsBounds(out ADiagramBounds, ALegendBounds, ATitleBounds,
|
|
AToolBoxBounds: TRect); virtual;
|
|
function DoGetHitTest(const P: TPoint): TcxCustomGridHitTest; override;
|
|
|
|
property IsImage: Boolean read FIsImage write FIsImage;
|
|
public
|
|
property DiagramViewInfo: TcxGridChartDiagramViewInfo read FDiagramViewInfo;
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
property LegendViewInfo: TcxGridChartLegendViewInfo read FLegendViewInfo;
|
|
property TitleViewInfo: TcxGridChartTitleViewInfo read FTitleViewInfo;
|
|
property ToolBoxViewInfo: TcxGridChartToolBoxViewInfo read FToolBoxViewInfo;
|
|
end;
|
|
|
|
{ view }
|
|
|
|
// custom title
|
|
|
|
TcxCustomGridChartTitle = class(TcxCustomGridOptions)
|
|
private
|
|
FAlignment: TcxGridChartPartAlignment;
|
|
FPosition: TcxGridChartPartPosition;
|
|
FText: string;
|
|
procedure SetAlignment(Value: TcxGridChartPartAlignment);
|
|
procedure SetPosition(Value: TcxGridChartPartPosition);
|
|
procedure SetText(Value: string);
|
|
protected
|
|
procedure GetStoredProperties(AProperties: TStrings); override;
|
|
procedure GetStoredPropertyValue(const AName: string; var AValue: Variant); override;
|
|
procedure SetStoredPropertyValue(const AName: string; const AValue: Variant); override;
|
|
|
|
function GetDefaultAlignment: TcxGridChartPartAlignment; virtual;
|
|
function GetDefaultOrientation: TcxGridChartPartOrientation; virtual;
|
|
function GetDefaultPosition: TcxGridChartPartPosition; virtual; abstract;
|
|
function GetDefaultText: string; virtual;
|
|
|
|
property Position: TcxGridChartPartPosition read FPosition write SetPosition default cppDefault;
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetAlignment: TcxGridChartPartAlignment;
|
|
function GetOrientation: TcxGridChartPartOrientation;
|
|
function GetPosition: TcxGridChartPartPosition;
|
|
function GetText: string;
|
|
published
|
|
property Alignment: TcxGridChartPartAlignment read FAlignment write SetAlignment default cpaDefault;
|
|
property Text: string read FText write SetText;
|
|
end;
|
|
|
|
// legend
|
|
|
|
TcxGridChartLegendBorder = (lbDefault, lbNone, lbSingle);
|
|
|
|
TcxGridChartLegendClass = class of TcxGridChartLegend;
|
|
|
|
TcxGridChartLegend = class(TcxCustomGridOptions)
|
|
private
|
|
FAlignment: TcxGridChartPartAlignment;
|
|
FBorder: TcxGridChartLegendBorder;
|
|
FKeyBorder: TcxGridChartLegendBorder;
|
|
FOrientation: TcxGridChartPartOrientation;
|
|
FParent: TcxGridChartLegend;
|
|
FPosition: TcxGridChartPartPosition;
|
|
procedure SetAlignment(Value: TcxGridChartPartAlignment);
|
|
procedure SetBorder(Value: TcxGridChartLegendBorder);
|
|
procedure SetKeyBorder(Value: TcxGridChartLegendBorder);
|
|
procedure SetOrientation(Value: TcxGridChartPartOrientation);
|
|
procedure SetPosition(Value: TcxGridChartPartPosition);
|
|
protected
|
|
procedure GetStoredProperties(AProperties: TStrings); override;
|
|
procedure GetStoredPropertyValue(const AName: string; var AValue: Variant); override;
|
|
procedure SetStoredPropertyValue(const AName: string; const AValue: Variant); override;
|
|
|
|
function GetDefaultAlignment: TcxGridChartPartAlignment; virtual;
|
|
function GetDefaultBorder: TcxGridChartLegendBorder; virtual;
|
|
function GetDefaultKeyBorder: TcxGridChartLegendBorder; virtual;
|
|
function GetDefaultOrientation(APosition: TcxGridChartPartPosition): TcxGridChartPartOrientation; virtual;
|
|
function GetDefaultPosition: TcxGridChartPartPosition; virtual;
|
|
property Parent: TcxGridChartLegend read FParent write FParent;
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetAlignment: TcxGridChartPartAlignment;
|
|
function GetBorder: TcxGridChartLegendBorder;
|
|
function GetKeyBorder: TcxGridChartLegendBorder;
|
|
function GetOrientation(APosition: TcxGridChartPartPosition = cppDefault): TcxGridChartPartOrientation;
|
|
function GetPosition: TcxGridChartPartPosition;
|
|
published
|
|
property Alignment: TcxGridChartPartAlignment read FAlignment write SetAlignment default cpaDefault;
|
|
property Border: TcxGridChartLegendBorder read FBorder write SetBorder default lbDefault;
|
|
property KeyBorder: TcxGridChartLegendBorder read FKeyBorder write SetKeyBorder default lbDefault;
|
|
property Orientation: TcxGridChartPartOrientation read FOrientation
|
|
write SetOrientation default cpoDefault;
|
|
property Position: TcxGridChartPartPosition read FPosition write SetPosition default cppDefault;
|
|
end;
|
|
|
|
// diagram
|
|
|
|
TcxGridDiagramChange = (dcProperty, dcLayout, dcSize);
|
|
|
|
TcxCustomGridChartDiagramOptions = class(TPersistent)
|
|
private
|
|
FDiagram: TcxGridChartDiagram;
|
|
function GetGridView: TcxGridChartView;
|
|
function GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
|
|
protected
|
|
procedure Changed(AChange: TcxGridDiagramChange = dcLayout); virtual;
|
|
property LookAndFeelPainter: TcxCustomLookAndFeelPainterClass read GetLookAndFeelPainter;
|
|
public
|
|
constructor Create(ADiagram: TcxGridChartDiagram); virtual;
|
|
procedure Assign(Source: TPersistent); override;
|
|
property Diagram: TcxGridChartDiagram read FDiagram;
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
end;
|
|
|
|
TcxGridChartDiagramStylesClass = class of TcxGridChartDiagramStyles;
|
|
|
|
TcxGridChartDiagramStyles = class(TcxCustomGridStyles)
|
|
private
|
|
function GetDiagram: TcxGridChartDiagram;
|
|
function GetGridViewValue: TcxGridChartView;
|
|
protected
|
|
procedure GetDefaultViewParams(Index: Integer; AData: TObject; out AParams: TcxViewParams); override;
|
|
function GetGridView: TcxCustomGridView; override;
|
|
function GetVaryColorsByCategory: Boolean; virtual; abstract;
|
|
public
|
|
constructor Create(AOwner: TPersistent); override;
|
|
procedure GetBackgroundParams(out AParams: TcxViewParams); virtual;
|
|
procedure GetValueParams(AVisibleSeriesIndex, AValueIndex: Integer;
|
|
out AParams: TcxViewParams); virtual;
|
|
procedure Assign(Source: TPersistent); override;
|
|
property Diagram: TcxGridChartDiagram read GetDiagram;
|
|
property GridView: TcxGridChartView read GetGridViewValue;
|
|
published
|
|
property Legend: TcxStyle index dsLegend read GetValue write SetValue;
|
|
property ValueCaptions: TcxStyle index dsValueCaptions read GetValue write SetValue;
|
|
property Values: TcxStyle index dsValues read GetValue write SetValue;
|
|
end;
|
|
|
|
TcxGridChartDiagramLegendCustomDrawEvent = procedure(Sender: TcxGridChartDiagram;
|
|
ACanvas: TcxCanvas; AViewInfo: TcxGridChartLegendViewInfo; var ADone: Boolean) of object;
|
|
TcxGridChartDiagramLegendItemCustomDrawEvent = procedure(Sender: TcxGridChartDiagram;
|
|
ACanvas: TcxCanvas; AViewInfo: TcxGridChartLegendItemViewInfo; var ADone: Boolean) of object;
|
|
TcxGridChartDiagramValueCustomDrawEvent = procedure(Sender: TcxGridChartDiagram;
|
|
ACanvas: TcxCanvas; AViewInfo: TcxGridChartDiagramValueViewInfo; var ADone: Boolean) of object;
|
|
|
|
TcxGridChartDiagramClass = class of TcxGridChartDiagram;
|
|
|
|
TcxGridChartDiagram = class(TPersistent)
|
|
private
|
|
FEnabled: Boolean;
|
|
FGridView: TcxGridChartView;
|
|
FLegend: TcxGridChartLegend;
|
|
FStyles: TcxGridChartDiagramStyles;
|
|
FOnCustomDrawLegend: TcxGridChartDiagramLegendCustomDrawEvent;
|
|
FOnCustomDrawLegendItem: TcxGridChartDiagramLegendItemCustomDrawEvent;
|
|
FOnCustomDrawValue: TcxGridChartDiagramValueCustomDrawEvent;
|
|
function GetActive: Boolean;
|
|
function GetID: string;
|
|
procedure SetActive(Value: Boolean);
|
|
procedure SetEnabled(Value: Boolean);
|
|
procedure SetLegend(Value: TcxGridChartLegend);
|
|
procedure SetStyles(Value: TcxGridChartDiagramStyles);
|
|
procedure SetOnCustomDrawLegend(Value: TcxGridChartDiagramLegendCustomDrawEvent);
|
|
procedure SetOnCustomDrawLegendItem(Value: TcxGridChartDiagramLegendItemCustomDrawEvent);
|
|
procedure SetOnCustomDrawValue(Value: TcxGridChartDiagramValueCustomDrawEvent);
|
|
protected
|
|
FSubClassEvents: TNotifyEvent;
|
|
function GetOwner: TPersistent; override;
|
|
|
|
procedure CreateSubObjects(AGridView: TcxGridChartView); virtual;
|
|
procedure DestroySubObjects; virtual;
|
|
procedure SetGridView(Value: TcxGridChartView);
|
|
|
|
function GetStylesClass: TcxGridChartDiagramStylesClass; virtual;
|
|
|
|
function GetLegendViewInfoClass: TcxGridChartLegendViewInfoClass; virtual; abstract;
|
|
function GetViewInfoClass: TcxGridChartDiagramViewInfoClass; virtual; abstract;
|
|
|
|
procedure Changed(AChange: TcxGridDiagramChange = dcLayout); virtual;
|
|
function GetDisplayText: string; virtual;
|
|
function GetImageIndex: Integer; virtual;
|
|
function HorizontalPaging: Boolean; virtual;
|
|
function PagingInOppositeDirection: Boolean; virtual;
|
|
function SupportsPaging: Boolean; virtual;
|
|
function SupportsValueHotTrack: Boolean; virtual;
|
|
|
|
procedure DoCustomDrawLegend(ACanvas: TcxCanvas; AViewInfo: TcxGridChartLegendViewInfo;
|
|
var ADone: Boolean); virtual;
|
|
procedure DoCustomDrawLegendItem(ACanvas: TcxCanvas; AViewInfo: TcxGridChartLegendItemViewInfo;
|
|
var ADone: Boolean); virtual;
|
|
procedure DoCustomDrawValue(ACanvas: TcxCanvas; AViewInfo: TcxGridChartDiagramValueViewInfo;
|
|
var ADone: Boolean); virtual;
|
|
function HasCustomDrawLegend: Boolean; virtual;
|
|
function HasCustomDrawLegendItem: Boolean; virtual;
|
|
function HasCustomDrawValue: Boolean; virtual;
|
|
|
|
property ImageIndex: Integer read GetImageIndex;
|
|
property Styles: TcxGridChartDiagramStyles read FStyles write SetStyles;
|
|
public
|
|
constructor Create(AGridView: TcxGridChartView); virtual;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetNamePath: string; override;
|
|
function GetValueCaption(ASeries: TcxGridChartSeries; AValueIndex: Integer): string; virtual;
|
|
function IsAvailable: Boolean; virtual;
|
|
property DisplayText: string read GetDisplayText;
|
|
property GridView: TcxGridChartView read FGridView;
|
|
property ID: string read GetID;
|
|
published
|
|
property Active: Boolean read GetActive write SetActive default False;
|
|
property Enabled: Boolean read FEnabled write SetEnabled default True;
|
|
property Legend: TcxGridChartLegend read FLegend write SetLegend;
|
|
property OnCustomDrawLegend: TcxGridChartDiagramLegendCustomDrawEvent read FOnCustomDrawLegend
|
|
write SetOnCustomDrawLegend;
|
|
property OnCustomDrawLegendItem: TcxGridChartDiagramLegendItemCustomDrawEvent
|
|
read FOnCustomDrawLegendItem write SetOnCustomDrawLegendItem;
|
|
property OnCustomDrawValue: TcxGridChartDiagramValueCustomDrawEvent read FOnCustomDrawValue
|
|
write SetOnCustomDrawValue;
|
|
end;
|
|
|
|
// histogram
|
|
|
|
TcxGridChartHistogramAxisTitleClass = class of TcxGridChartHistogramAxisTitle;
|
|
|
|
TcxGridChartHistogramAxisTitle = class(TcxCustomGridChartTitle)
|
|
private
|
|
FAxis: TcxGridChartHistogramAxis;
|
|
protected
|
|
function GetDefaultPosition: TcxGridChartPartPosition; override;
|
|
function GetDefaultText: string; override;
|
|
function GetGridViewValue: TcxCustomGridView; override;
|
|
public
|
|
constructor Create(AAxis: TcxGridChartHistogramAxis); reintroduce; virtual;
|
|
property Axis: TcxGridChartHistogramAxis read FAxis;
|
|
end;
|
|
|
|
TcxGridChartHistogramTickMarkKind = (tmkNone, tmkCross, tmkInside, tmkOutside);
|
|
|
|
TcxGridChartHistogramAxis = class(TcxCustomGridChartDiagramOptions)
|
|
private
|
|
FGridLines: Boolean;
|
|
FTickMarkKind: TcxGridChartHistogramTickMarkKind;
|
|
FTickMarkLabels: Boolean;
|
|
FTitle: TcxGridChartHistogramAxisTitle;
|
|
FVisible: Boolean;
|
|
function GetDiagram: TcxGridChartHistogram;
|
|
procedure SetGridLines(Value: Boolean);
|
|
procedure SetTickMarkKind(Value: TcxGridChartHistogramTickMarkKind);
|
|
procedure SetTickMarkLabels(Value: Boolean);
|
|
procedure SetTitle(Value: TcxGridChartHistogramAxisTitle);
|
|
procedure SetVisible(Value: Boolean);
|
|
protected
|
|
function GetTitleClass: TcxGridChartHistogramAxisTitleClass; virtual;
|
|
function GetTitleDefaultText: string; virtual;
|
|
public
|
|
constructor Create(ADiagram: TcxGridChartDiagram); override;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetPosition: TcxGridChartAxisPosition; virtual; abstract;
|
|
property Diagram: TcxGridChartHistogram read GetDiagram;
|
|
published
|
|
property GridLines: Boolean read FGridLines write SetGridLines default True;
|
|
property TickMarkKind: TcxGridChartHistogramTickMarkKind read FTickMarkKind
|
|
write SetTickMarkKind default tmkOutside;
|
|
property TickMarkLabels: Boolean read FTickMarkLabels write SetTickMarkLabels default True;
|
|
property Title: TcxGridChartHistogramAxisTitle read FTitle write SetTitle;
|
|
property Visible: Boolean read FVisible write SetVisible default True;
|
|
end;
|
|
|
|
TcxGridChartHistogramAxisCategoryClass = class of TcxGridChartHistogramAxisCategory;
|
|
|
|
TcxGridChartHistogramAxisCategory = class(TcxGridChartHistogramAxis)
|
|
private
|
|
FCategoriesInReverseOrder: Boolean;
|
|
FValueAxisAtMaxCategory: Boolean;
|
|
FValueAxisBetweenCategories: Boolean;
|
|
procedure SetCategoriesInReverseOrder(Value: Boolean);
|
|
procedure SetValueAxisAtMaxCategory(Value: Boolean);
|
|
procedure SetValueAxisBetweenCategories(Value: Boolean);
|
|
protected
|
|
function GetDefaultValueAxisBetweenCategories: Boolean; virtual;
|
|
function GetTitleDefaultText: string; override;
|
|
public
|
|
constructor Create(ADiagram: TcxGridChartDiagram); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetPosition: TcxGridChartAxisPosition; override;
|
|
published
|
|
property CategoriesInReverseOrder: Boolean read FCategoriesInReverseOrder
|
|
write SetCategoriesInReverseOrder default False;
|
|
property ValueAxisAtMaxCategory: Boolean read FValueAxisAtMaxCategory
|
|
write SetValueAxisAtMaxCategory default False;
|
|
property ValueAxisBetweenCategories: Boolean read FValueAxisBetweenCategories
|
|
write SetValueAxisBetweenCategories default True;
|
|
end;
|
|
|
|
TcxGridChartHistogramMinMaxValues = (mmvZeroBasedAuto, mmvAuto, mmvCustom);
|
|
|
|
TcxGridChartHistogramAxisValueClass = class of TcxGridChartHistogramAxisValue;
|
|
|
|
TcxGridChartHistogramAxisValue = class(TcxGridChartHistogramAxis)
|
|
private
|
|
FMaxValue: Extended;
|
|
FMinMaxValues: TcxGridChartHistogramMinMaxValues;
|
|
FMinValue: Extended;
|
|
FTickMarkLabelFormat: string;
|
|
procedure SetMaxValue(const Value: Extended);
|
|
procedure SetMinMaxValues(Value: TcxGridChartHistogramMinMaxValues);
|
|
procedure SetMinValue(const Value: Extended);
|
|
procedure SetTickMarkLabelFormat(const Value: string);
|
|
protected
|
|
function GetTitleDefaultText: string; override;
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetPosition: TcxGridChartAxisPosition; override;
|
|
function GetTickMarkLabel(const ATickMarkValue: Variant): string; virtual;
|
|
function GetTickMarkLabelFormat(AConsiderSeriesFormat: Boolean): string; virtual;
|
|
published
|
|
property MinMaxValues: TcxGridChartHistogramMinMaxValues read FMinMaxValues
|
|
write SetMinMaxValues default mmvZeroBasedAuto;
|
|
property MinValue: Extended read FMinValue write SetMinValue;
|
|
property MaxValue: Extended read FMaxValue write SetMaxValue;
|
|
property TickMarkLabelFormat: string read FTickMarkLabelFormat write SetTickMarkLabelFormat;
|
|
end;
|
|
|
|
TcxGridChartHistogramStyles = class(TcxGridChartDiagramStyles)
|
|
protected
|
|
procedure GetDefaultViewParams(Index: Integer; AData: TObject; out AParams: TcxViewParams); override;
|
|
function GetVaryColorsByCategory: Boolean; override;
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
published
|
|
property Axis: TcxStyle index dsAxis read GetValue write SetValue;
|
|
property AxisTitle: TcxStyle index dsAxisTitle read GetValue write SetValue;
|
|
property CategoryAxis: TcxStyle index dsCategoryAxis read GetValue write SetValue;
|
|
property CategoryAxisTitle: TcxStyle index dsCategoryAxisTitle read GetValue write SetValue;
|
|
property CategoryGridLines: TcxStyle index dsCategoryGridLines read GetValue write SetValue;
|
|
property GridLines: TcxStyle index dsGridLines read GetValue write SetValue;
|
|
property Plot: TcxStyle index dsPlot read GetValue write SetValue;
|
|
property ValueAxis: TcxStyle index dsValueAxis read GetValue write SetValue;
|
|
property ValueAxisTitle: TcxStyle index dsValueAxisTitle read GetValue write SetValue;
|
|
property ValueGridLines: TcxStyle index dsValueGridLines read GetValue write SetValue;
|
|
end;
|
|
|
|
TcxGridChartValuesStacking = (vsNone, vsNormal, vs100Percent);
|
|
|
|
TcxGridChartHistogramValuesClass = class of TcxGridChartHistogramValues;
|
|
|
|
TcxGridChartHistogramValues = class(TcxCustomGridChartDiagramOptions)
|
|
private
|
|
FStacking: TcxGridChartValuesStacking;
|
|
FVaryColorsByCategory: Boolean;
|
|
procedure SetStacking(Value: TcxGridChartValuesStacking);
|
|
procedure SetVaryColorsByCategory(Value: Boolean);
|
|
protected
|
|
property Stacking: TcxGridChartValuesStacking read FStacking write SetStacking default vsNone;
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetVaryColorsByCategory: Boolean; virtual;
|
|
published
|
|
property VaryColorsByCategory: Boolean read FVaryColorsByCategory write SetVaryColorsByCategory default False;
|
|
end;
|
|
|
|
TcxGridChartHistogramPlotCustomDrawEvent = procedure(Sender: TcxGridChartHistogram;
|
|
ACanvas: TcxCanvas; AViewInfo: TcxGridChartHistogramViewInfo;
|
|
const ABounds: TRect; var ADone: Boolean) of object;
|
|
|
|
TcxGridChartHistogram = class(TcxGridChartDiagram)
|
|
private
|
|
FAxisCategory: TcxGridChartHistogramAxisCategory;
|
|
FAxisValue: TcxGridChartHistogramAxisValue;
|
|
FValues: TcxGridChartHistogramValues;
|
|
FOnCustomDrawPlot: TcxGridChartHistogramPlotCustomDrawEvent;
|
|
function GetStyles: TcxGridChartHistogramStyles;
|
|
procedure SetAxisCategory(Value: TcxGridChartHistogramAxisCategory);
|
|
procedure SetAxisValue(Value: TcxGridChartHistogramAxisValue);
|
|
procedure SetStyles(Value: TcxGridChartHistogramStyles);
|
|
procedure SetValues(Value: TcxGridChartHistogramValues);
|
|
procedure SetOnCustomDrawPlot(Value: TcxGridChartHistogramPlotCustomDrawEvent);
|
|
protected
|
|
procedure CreateSubObjects(AGridView: TcxGridChartView); override;
|
|
procedure DestroySubObjects; override;
|
|
|
|
function GetAxisCategoryClass: TcxGridChartHistogramAxisCategoryClass; virtual;
|
|
function GetAxisValueClass: TcxGridChartHistogramAxisValueClass; virtual;
|
|
function GetStylesClass: TcxGridChartDiagramStylesClass; override;
|
|
function GetValuesClass: TcxGridChartHistogramValuesClass; virtual;
|
|
|
|
function GetLegendViewInfoClass: TcxGridChartLegendViewInfoClass; override;
|
|
|
|
function PagingInOppositeDirection: Boolean; override;
|
|
function SupportsPaging: Boolean; override;
|
|
|
|
procedure DoCustomDrawPlot(ACanvas: TcxCanvas; AViewInfo: TcxGridChartHistogramViewInfo;
|
|
const ABounds: TRect; var ADone: Boolean); virtual;
|
|
function HasCustomDrawPlot: Boolean; virtual;
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetCategoryAxisPosition: TcxGridChartAxisPosition; virtual;
|
|
function GetValueAxisPosition: TcxGridChartAxisPosition; virtual;
|
|
|
|
property AxisCategory: TcxGridChartHistogramAxisCategory read FAxisCategory write SetAxisCategory;
|
|
property AxisValue: TcxGridChartHistogramAxisValue read FAxisValue write SetAxisValue;
|
|
property Styles: TcxGridChartHistogramStyles read GetStyles write SetStyles;
|
|
property Values: TcxGridChartHistogramValues read FValues write SetValues;
|
|
property ValuesEvents: TNotifyEvent read FSubClassEvents write FSubClassEvents;
|
|
published
|
|
property OnCustomDrawPlot: TcxGridChartHistogramPlotCustomDrawEvent read FOnCustomDrawPlot
|
|
write SetOnCustomDrawPlot;
|
|
end;
|
|
|
|
// column diagram
|
|
|
|
TcxGridChartColumnDiagramValues = class(TcxGridChartHistogramValues)
|
|
private
|
|
FBorderWidth: Integer;
|
|
FCaptionPosition: TcxGridChartColumnDiagramValueCaptionPosition;
|
|
procedure SetBorderWidth(Value: Integer);
|
|
procedure SetCaptionPosition(Value: TcxGridChartColumnDiagramValueCaptionPosition);
|
|
public
|
|
constructor Create(ADiagram: TcxGridChartDiagram); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
published
|
|
property BorderWidth: Integer read FBorderWidth write SetBorderWidth default cxGridChartColumnDiagramDefaultBorderWidth;
|
|
property CaptionPosition: TcxGridChartColumnDiagramValueCaptionPosition read FCaptionPosition
|
|
write SetCaptionPosition default cdvcpNone;
|
|
end;
|
|
|
|
TcxGridChartColumnDiagramClass = class of TcxGridChartColumnDiagram;
|
|
|
|
TcxGridChartColumnDiagram = class(TcxGridChartHistogram)
|
|
private
|
|
function GetValues: TcxGridChartColumnDiagramValues;
|
|
procedure SetValues(Value: TcxGridChartColumnDiagramValues);
|
|
protected
|
|
function GetLegendViewInfoClass: TcxGridChartLegendViewInfoClass; override;
|
|
function GetValuesClass: TcxGridChartHistogramValuesClass; override;
|
|
function GetViewInfoClass: TcxGridChartDiagramViewInfoClass; override;
|
|
|
|
function GetDisplayText: string; override;
|
|
function GetImageIndex: Integer; override;
|
|
published
|
|
property AxisCategory;
|
|
property AxisValue;
|
|
property Styles;
|
|
property Values: TcxGridChartColumnDiagramValues read GetValues write SetValues;
|
|
end;
|
|
|
|
// bar diagram
|
|
|
|
TcxGridChartBarDiagramClass = class of TcxGridChartBarDiagram;
|
|
|
|
TcxGridChartBarDiagram = class(TcxGridChartColumnDiagram)
|
|
protected
|
|
function GetDisplayText: string; override;
|
|
function GetImageIndex: Integer; override;
|
|
|
|
function HorizontalPaging: Boolean; override;
|
|
function PagingInOppositeDirection: Boolean; override;
|
|
public
|
|
function GetCategoryAxisPosition: TcxGridChartAxisPosition; override;
|
|
function GetValueAxisPosition: TcxGridChartAxisPosition; override;
|
|
end;
|
|
|
|
// line diagram
|
|
|
|
TcxGridChartLineDiagramAxisCategory = class(TcxGridChartHistogramAxisCategory)
|
|
protected
|
|
function GetDefaultValueAxisBetweenCategories: Boolean; override;
|
|
published
|
|
property ValueAxisBetweenCategories default False;
|
|
end;
|
|
|
|
TcxGridChartLineDiagramStyles = class(TcxGridChartHistogramStyles)
|
|
protected
|
|
procedure GetDefaultViewParams(Index: Integer; AData: TObject; out AParams: TcxViewParams); override;
|
|
function ValueMarkerHasBorderByDefault: Boolean; virtual;
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure GetValueMarkerParams(AVisibleSeriesIndex, AValueIndex: Integer;
|
|
out AParams: TcxViewParams); virtual;
|
|
published
|
|
property ValueMarkers: TcxStyle index dsValueMarkers read GetValue write SetValue;
|
|
end;
|
|
|
|
TcxGridChartLineDiagramGetLineStyleEvent = procedure(Sender: TcxGridChartLineDiagram;
|
|
ASeries: TcxGridChartSeries; var AStyle: TcxGridChartLineStyle) of object;
|
|
TcxGridChartLineDiagramGetMarkerStyleEvent = procedure(Sender: TcxGridChartLineDiagram;
|
|
ASeries: TcxGridChartSeries; var AStyle: TcxGridChartMarkerStyle) of object;
|
|
|
|
TcxGridChartLineDiagramValues = class(TcxGridChartHistogramValues)
|
|
private
|
|
FCaptionPosition: TcxGridChartLineDiagramValueCaptionPosition;
|
|
FHotSpotSize: Integer;
|
|
FLineStyle: TcxGridChartLineStyle;
|
|
FLineWidth: Integer;
|
|
FMarkerSize: Integer;
|
|
FMarkerStyle: TcxGridChartMarkerStyle;
|
|
FOnGetLineStyle: TcxGridChartLineDiagramGetLineStyleEvent;
|
|
FOnGetMarkerStyle: TcxGridChartLineDiagramGetMarkerStyleEvent;
|
|
function GetDiagram: TcxGridChartLineDiagram;
|
|
procedure SetCaptionPosition(Value: TcxGridChartLineDiagramValueCaptionPosition);
|
|
procedure SetHotSpotSize(Value: Integer);
|
|
procedure SetLineStyle(Value: TcxGridChartLineStyle);
|
|
procedure SetLineWidth(Value: Integer);
|
|
procedure SetMarkerSize(Value: Integer);
|
|
procedure SetMarkerStyle(Value: TcxGridChartMarkerStyle);
|
|
procedure SetOnGetLineStyle(Value: TcxGridChartLineDiagramGetLineStyleEvent);
|
|
procedure SetOnGetMarkerStyle(Value: TcxGridChartLineDiagramGetMarkerStyleEvent);
|
|
protected
|
|
procedure DoGetLineStyle(ASeries: TcxGridChartSeries; var AStyle: TcxGridChartLineStyle); virtual;
|
|
procedure DoGetMarkerStyle(ASeries: TcxGridChartSeries; var AStyle: TcxGridChartMarkerStyle); virtual;
|
|
public
|
|
constructor Create(ADiagram: TcxGridChartDiagram); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetHotSpotSize: Integer; virtual;
|
|
function GetLineStyle(ASeries: TcxGridChartSeries): TcxGridChartLineStyle; virtual;
|
|
function GetMarkerStyle(ASeries: TcxGridChartSeries): TcxGridChartMarkerStyle; virtual;
|
|
property Diagram: TcxGridChartLineDiagram read GetDiagram;
|
|
published
|
|
property CaptionPosition: TcxGridChartLineDiagramValueCaptionPosition read FCaptionPosition
|
|
write SetCaptionPosition default ldvcpNone;
|
|
property HotSpotSize: Integer read FHotSpotSize write SetHotSpotSize default cxGridChartLineDiagramDefaultHotSpotSize;
|
|
property LineStyle: TcxGridChartLineStyle read FLineStyle write SetLineStyle default clsSolid;
|
|
property LineWidth: Integer read FLineWidth write SetLineWidth default cxGridChartLineDiagramDefaultLineWidth;
|
|
property MarkerSize: Integer read FMarkerSize write SetMarkerSize default cxGridChartLineDiagramDefaultMarkerSize;
|
|
property MarkerStyle: TcxGridChartMarkerStyle read FMarkerStyle write SetMarkerStyle default cmsNone;
|
|
property Stacking;
|
|
property OnGetLineStyle: TcxGridChartLineDiagramGetLineStyleEvent read FOnGetLineStyle write SetOnGetLineStyle;
|
|
property OnGetMarkerStyle: TcxGridChartLineDiagramGetMarkerStyleEvent read FOnGetMarkerStyle write SetOnGetMarkerStyle;
|
|
end;
|
|
|
|
TcxGridChartLineDiagramClass = class of TcxGridChartLineDiagram;
|
|
|
|
TcxGridChartLineDiagram = class(TcxGridChartHistogram)
|
|
private
|
|
function GetAxisCategory: TcxGridChartLineDiagramAxisCategory;
|
|
function GetStyles: TcxGridChartLineDiagramStyles;
|
|
function GetValues: TcxGridChartLineDiagramValues;
|
|
procedure SetAxisCategory(Value: TcxGridChartLineDiagramAxisCategory);
|
|
procedure SetStyles(Value: TcxGridChartLineDiagramStyles);
|
|
procedure SetValues(Value: TcxGridChartLineDiagramValues);
|
|
protected
|
|
function GetAxisCategoryClass: TcxGridChartHistogramAxisCategoryClass; override;
|
|
function GetLegendViewInfoClass: TcxGridChartLegendViewInfoClass; override;
|
|
function GetStylesClass: TcxGridChartDiagramStylesClass; override;
|
|
function GetValuesClass: TcxGridChartHistogramValuesClass; override;
|
|
function GetViewInfoClass: TcxGridChartDiagramViewInfoClass; override;
|
|
|
|
function GetDisplayText: string; override;
|
|
function GetImageIndex: Integer; override;
|
|
function SupportsValueHotTrack: Boolean; override;
|
|
published
|
|
property AxisCategory: TcxGridChartLineDiagramAxisCategory read GetAxisCategory write SetAxisCategory;
|
|
property AxisValue;
|
|
property Styles: TcxGridChartLineDiagramStyles read GetStyles write SetStyles;
|
|
property Values: TcxGridChartLineDiagramValues read GetValues write SetValues;
|
|
property ValuesEvents;
|
|
end;
|
|
|
|
// area diagram
|
|
|
|
TcxGridChartAreaDiagramStyles = class(TcxGridChartLineDiagramStyles)
|
|
protected
|
|
function ValueMarkerHasBorderByDefault: Boolean; override;
|
|
end;
|
|
|
|
TcxGridChartAreaDiagramValueAreaCustomDrawEvent = procedure(Sender: TcxGridChartAreaDiagram;
|
|
ACanvas: TcxCanvas; AViewInfo: TcxGridChartAreaDiagramValueViewInfo; var ADone: Boolean) of object;
|
|
|
|
TcxGridChartAreaDiagramClass = class of TcxGridChartAreaDiagram;
|
|
|
|
TcxGridChartAreaDiagram = class(TcxGridChartLineDiagram)
|
|
private
|
|
FOnCustomDrawValueArea: TcxGridChartAreaDiagramValueAreaCustomDrawEvent;
|
|
function GetStyles: TcxGridChartAreaDiagramStyles;
|
|
procedure SetStyles(Value: TcxGridChartAreaDiagramStyles);
|
|
procedure SetOnCustomDrawValueArea(Value: TcxGridChartAreaDiagramValueAreaCustomDrawEvent);
|
|
protected
|
|
function GetLegendViewInfoClass: TcxGridChartLegendViewInfoClass; override;
|
|
function GetStylesClass: TcxGridChartDiagramStylesClass; override;
|
|
function GetViewInfoClass: TcxGridChartDiagramViewInfoClass; override;
|
|
|
|
function GetDisplayText: string; override;
|
|
function GetImageIndex: Integer; override;
|
|
|
|
procedure DoCustomDrawValueArea(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxGridChartAreaDiagramValueViewInfo; var ADone: Boolean); virtual;
|
|
function HasCustomDrawValueArea: Boolean; virtual;
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
published
|
|
property Styles: TcxGridChartAreaDiagramStyles read GetStyles write SetStyles;
|
|
property OnCustomDrawValueArea: TcxGridChartAreaDiagramValueAreaCustomDrawEvent
|
|
read FOnCustomDrawValueArea write SetOnCustomDrawValueArea;
|
|
end;
|
|
|
|
// pie diagram
|
|
|
|
TcxGridChartPieDiagramStyles = class(TcxGridChartDiagramStyles)
|
|
protected
|
|
procedure GetDefaultViewParams(Index: Integer; AData: TObject; out AParams: TcxViewParams); override;
|
|
function GetVaryColorsByCategory: Boolean; override;
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
published
|
|
property SeriesSiteCaptions: TcxStyle index dsSeriesSiteCaptions read GetValue write SetValue;
|
|
property SeriesSites: TcxStyle index dsSeriesSites read GetValue write SetValue;
|
|
end;
|
|
|
|
TcxGridChartPieDiagramValueCaptionItem = (pdvciCategory, pdvciValue, pdvciPercentage);
|
|
TcxGridChartPieDiagramValueCaptionItems = set of TcxGridChartPieDiagramValueCaptionItem;
|
|
|
|
TcxGridChartPieDiagramValuesClass = class of TcxGridChartPieDiagramValues;
|
|
|
|
TcxGridChartPieDiagramValues = class(TcxCustomGridChartDiagramOptions)
|
|
private
|
|
FAngleOfFirstSlice: Integer;
|
|
FCaptionItems: TcxGridChartPieDiagramValueCaptionItems;
|
|
FCaptionItemSeparator: string;
|
|
FCaptionPosition: TcxGridChartPieDiagramValueCaptionPosition;
|
|
FPercentageCaptionFormat: string;
|
|
procedure SetAngleOfFirstSlice(Value: Integer);
|
|
procedure SetCaptionItems(Value: TcxGridChartPieDiagramValueCaptionItems);
|
|
procedure SetCaptionItemSeparator(const Value: string);
|
|
procedure SetCaptionPosition(Value: TcxGridChartPieDiagramValueCaptionPosition);
|
|
procedure SetPercentageCaptionFormat(const Value: string);
|
|
protected
|
|
function GetDefaultCaptionItemSeparator: string; virtual;
|
|
function GetDefaultPercentageCaptionFormat: string; virtual;
|
|
public
|
|
constructor Create(ADiagram: TcxGridChartDiagram); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetCaptionItemSeparator: string;
|
|
function GetCaptionPosition: TcxGridChartPieDiagramValueCaptionPosition; virtual;
|
|
function GetPercentageCaptionFormat: string;
|
|
published
|
|
property AngleOfFirstSlice: Integer read FAngleOfFirstSlice write SetAngleOfFirstSlice default 0;
|
|
property CaptionPosition: TcxGridChartPieDiagramValueCaptionPosition read FCaptionPosition
|
|
write SetCaptionPosition default pdvcpNone;
|
|
property CaptionItems: TcxGridChartPieDiagramValueCaptionItems read FCaptionItems
|
|
write SetCaptionItems default [pdvciValue];
|
|
property CaptionItemSeparator: string read FCaptionItemSeparator write SetCaptionItemSeparator;
|
|
property PercentageCaptionFormat: string read FPercentageCaptionFormat
|
|
write SetPercentageCaptionFormat;
|
|
end;
|
|
|
|
TcxGridChartPieDiagramSeriesSiteCaptionCustomDrawEvent = procedure(Sender: TcxGridChartPieDiagram;
|
|
ACanvas: TcxCanvas; AViewInfo: TcxGridChartPieSeriesSiteCaptionViewInfo; var ADone: Boolean) of object;
|
|
TcxGridChartPieDiagramSeriesSiteCustomDrawEvent = procedure(Sender: TcxGridChartPieDiagram;
|
|
ACanvas: TcxCanvas; AViewInfo: TcxGridChartPieSeriesSiteViewInfo; var ADone: Boolean) of object;
|
|
|
|
TcxGridChartPieDiagramClass = class of TcxGridChartPieDiagram;
|
|
|
|
TcxGridChartPieDiagram = class(TcxGridChartDiagram)
|
|
private
|
|
FSeriesCaptions: Boolean;
|
|
FSeriesColumnCount: Integer;
|
|
FSeriesSites: Boolean;
|
|
FValues: TcxGridChartPieDiagramValues;
|
|
FOnCustomDrawSeriesSite: TcxGridChartPieDiagramSeriesSiteCustomDrawEvent;
|
|
FOnCustomDrawSeriesSiteCaption: TcxGridChartPieDiagramSeriesSiteCaptionCustomDrawEvent;
|
|
function GetStyles: TcxGridChartPieDiagramStyles;
|
|
procedure SetSeriesCaptions(Value: Boolean);
|
|
procedure SetSeriesColumnCount(Value: Integer);
|
|
procedure SetSeriesSites(Value: Boolean);
|
|
procedure SetStyles(Value: TcxGridChartPieDiagramStyles);
|
|
procedure SetValues(Value: TcxGridChartPieDiagramValues);
|
|
procedure SetOnCustomDrawSeriesSite(Value: TcxGridChartPieDiagramSeriesSiteCustomDrawEvent);
|
|
procedure SetOnCustomDrawSeriesSiteCaption(Value: TcxGridChartPieDiagramSeriesSiteCaptionCustomDrawEvent);
|
|
protected
|
|
procedure CreateSubObjects(AGridView: TcxGridChartView); override;
|
|
procedure DestroySubObjects; override;
|
|
|
|
function GetStylesClass: TcxGridChartDiagramStylesClass; override;
|
|
function GetValuesClass: TcxGridChartPieDiagramValuesClass; virtual;
|
|
|
|
function GetLegendViewInfoClass: TcxGridChartLegendViewInfoClass; override;
|
|
function GetViewInfoClass: TcxGridChartDiagramViewInfoClass; override;
|
|
|
|
function GetDisplayText: string; override;
|
|
function GetImageIndex: Integer; override;
|
|
|
|
procedure DoCustomDrawSeriesSite(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxGridChartPieSeriesSiteViewInfo; var ADone: Boolean); virtual;
|
|
procedure DoCustomDrawSeriesSiteCaption(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxGridChartPieSeriesSiteCaptionViewInfo; var ADone: Boolean); virtual;
|
|
function HasCustomDrawSeriesSite: Boolean; virtual;
|
|
function HasCustomDrawSeriesSiteCaption: Boolean; virtual;
|
|
public
|
|
constructor Create(AGridView: TcxGridChartView); override;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetSeriesColumnCount: Integer; virtual;
|
|
function GetValueCaption(ASeries: TcxGridChartSeries; AValueIndex: Integer): string; override;
|
|
published
|
|
property SeriesCaptions: Boolean read FSeriesCaptions write SetSeriesCaptions default True;
|
|
property SeriesColumnCount: Integer read FSeriesColumnCount write SetSeriesColumnCount default 0;
|
|
property SeriesSites: Boolean read FSeriesSites write SetSeriesSites default False;
|
|
property Styles: TcxGridChartPieDiagramStyles read GetStyles write SetStyles;
|
|
property Values: TcxGridChartPieDiagramValues read FValues write SetValues;
|
|
property OnCustomDrawSeriesSite: TcxGridChartPieDiagramSeriesSiteCustomDrawEvent
|
|
read FOnCustomDrawSeriesSite write SetOnCustomDrawSeriesSite;
|
|
property OnCustomDrawSeriesSiteCaption: TcxGridChartPieDiagramSeriesSiteCaptionCustomDrawEvent
|
|
read FOnCustomDrawSeriesSiteCaption write SetOnCustomDrawSeriesSiteCaption;
|
|
end;
|
|
|
|
// chart item data binding
|
|
|
|
TcxGridChartItemDataBindingClass = class of TcxGridChartItemDataBinding;
|
|
|
|
TcxGridChartItemDataBinding = class(TcxInterfacedPersistent, IcxEditRepositoryItemListener)
|
|
private
|
|
FData: TObject;
|
|
FDataField: TcxCustomDataField;
|
|
FDefaultRepositoryItem: TcxEditRepositoryItem;
|
|
FDefaultValuesProvider: TcxCustomEditDefaultValuesProvider;
|
|
FDefaultValueTypeClass: TcxValueTypeClass;
|
|
FGridView: TcxGridChartView;
|
|
FID: Integer;
|
|
FIsValue: Boolean;
|
|
FSummaryItem: TcxDataSummaryItem;
|
|
function GetDataController: TcxCustomDataController;
|
|
function GetDataIndex: Integer;
|
|
function GetDataItem: TObject;
|
|
function GetDefaultProperties: TcxCustomEditProperties;
|
|
function GetDefaultValuesProvider: TcxCustomEditDefaultValuesProvider;
|
|
function GetGroupIndex: Integer;
|
|
function GetSortIndex: Integer;
|
|
function GetSortOrder: TcxDataSortOrder;
|
|
function GetSummaryIndex: Integer;
|
|
function GetSummaryKind: TcxSummaryKind;
|
|
function GetValueType: string;
|
|
function GetValueTypeClass: TcxValueTypeClass;
|
|
procedure SetData(Value: TObject);
|
|
procedure SetDataField(Value: TcxCustomDataField);
|
|
procedure SetGroupIndex(Value: Integer);
|
|
procedure SetSortIndex(Value: Integer);
|
|
procedure SetSortOrder(Value: TcxDataSortOrder);
|
|
procedure SetSummaryKind(Value: TcxSummaryKind);
|
|
procedure SetValueType(const Value: string);
|
|
procedure SetValueTypeClass(Value: TcxValueTypeClass);
|
|
protected
|
|
// IcxEditRepositoryItemListener
|
|
procedure ItemRemoved(Sender: TcxEditRepositoryItem);
|
|
procedure PropertiesChanged(Sender: TcxEditRepositoryItem);
|
|
|
|
procedure CreateSummaryItem(var ASummaryItem: TcxDataSummaryItem); virtual;
|
|
function GetDefaultDisplayText: string; virtual;
|
|
function GetDefaultValuesProviderClass: TcxCustomEditDefaultValuesProviderClass; virtual;
|
|
function GetDefaultValueTypeClass: TcxValueTypeClass; virtual;
|
|
function GetSummaryItem: TcxDataSummaryItem; virtual;
|
|
procedure InitDefaultValuesProvider(ADefaultValuesProvider: TcxCustomEditDefaultValuesProvider); virtual;
|
|
function IsValueTypeInteger: Boolean;
|
|
function IsValueTypeStored: Boolean; virtual;
|
|
procedure UpdateSummaryItemValue;
|
|
procedure ValueTypeClassChanged; virtual;
|
|
|
|
function GetDefaultRepositoryItem: TcxEditRepositoryItem; virtual;
|
|
procedure UpdateDefaultRepositoryItemValue;
|
|
|
|
property DataField: TcxCustomDataField read FDataField write SetDataField;
|
|
property DefaultProperties: TcxCustomEditProperties read GetDefaultProperties;
|
|
property DefaultRepositoryItem: TcxEditRepositoryItem read FDefaultRepositoryItem;
|
|
property DefaultValuesProvider: TcxCustomEditDefaultValuesProvider read GetDefaultValuesProvider;
|
|
property DataItem: TObject read GetDataItem;
|
|
property GroupIndex: Integer read GetGroupIndex write SetGroupIndex;
|
|
property ID: Integer read FID write FID;
|
|
property IsValue: Boolean read FIsValue;
|
|
property SortIndex: Integer read GetSortIndex write SetSortIndex;
|
|
property SortOrder: TcxDataSortOrder read GetSortOrder write SetSortOrder;
|
|
property SummaryKind: TcxSummaryKind read GetSummaryKind write SetSummaryKind;
|
|
public
|
|
constructor Create(AGridView: TcxGridChartView; AIsValue: Boolean;
|
|
ADefaultValueTypeClass: TcxValueTypeClass); reintroduce; virtual;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetValueDisplayText(const AValue: Variant): string; virtual;
|
|
function IsValueTypeClassValid(AValueTypeClass: TcxValueTypeClass): Boolean; virtual;
|
|
property Data: TObject read FData write SetData;
|
|
property DataIndex: Integer read GetDataIndex;
|
|
property DataController: TcxCustomDataController read GetDataController;
|
|
property GridView: TcxGridChartView read FGridView;
|
|
property SummaryIndex: Integer read GetSummaryIndex;
|
|
property SummaryItem: TcxDataSummaryItem read FSummaryItem;
|
|
property ValueTypeClass: TcxValueTypeClass read GetValueTypeClass write SetValueTypeClass;
|
|
published
|
|
property ValueType: string read GetValueType write SetValueType stored IsValueTypeStored;
|
|
end;
|
|
|
|
TcxGridChartGetValueDisplayTextEvent = procedure(Sender: TObject;
|
|
const AValue: Variant; var ADisplayText: string) of object;
|
|
TcxGridChartItemGetStoredPropertiesEvent = procedure(Sender: TcxGridChartItem;
|
|
AProperties: TStrings) of object;
|
|
TcxGridChartItemGetStoredPropertyValueEvent = procedure(Sender: TcxGridChartItem;
|
|
const AName: string; var AValue: Variant) of object;
|
|
TcxGridChartItemSetStoredPropertyValueEvent = procedure(Sender: TcxGridChartItem;
|
|
const AName: string; const AValue: Variant) of object;
|
|
|
|
TcxGridChartItem = class(TcxComponent, IcxStoredObject, IcxGridChartItem)
|
|
private
|
|
FDataBinding: TcxGridChartItemDataBinding;
|
|
FDisplayText: string;
|
|
FGridView: TcxGridChartView;
|
|
FLastDataBindingDefaultDisplayText: string;
|
|
FOrder: Integer;
|
|
FVisible: Boolean;
|
|
FVisibleForCustomization: Boolean;
|
|
FVisibleIndex: Integer;
|
|
FOnGetStoredProperties: TcxGridChartItemGetStoredPropertiesEvent;
|
|
FOnGetStoredPropertyValue: TcxGridChartItemGetStoredPropertyValueEvent;
|
|
FOnGetValueDisplayText: TcxGridChartGetValueDisplayTextEvent;
|
|
FOnSetStoredPropertyValue: TcxGridChartItemSetStoredPropertyValueEvent;
|
|
function GetID: Integer;
|
|
function GetIndex: Integer;
|
|
function GetSortOrder: TcxDataSortOrder;
|
|
function GetTag: TcxTag;
|
|
function GetVisibleDisplayText(AIndex: Integer): string;
|
|
procedure SetDataBinding(Value: TcxGridChartItemDataBinding);
|
|
procedure SetDisplayText(const Value: string);
|
|
procedure SetIndex(Value: Integer);
|
|
procedure SetOnGetStoredProperties(Value: TcxGridChartItemGetStoredPropertiesEvent);
|
|
procedure SetOnGetStoredPropertyValue(Value: TcxGridChartItemGetStoredPropertyValueEvent);
|
|
procedure SetOnGetValueDisplayText(Value: TcxGridChartGetValueDisplayTextEvent);
|
|
procedure SetOnSetStoredPropertyValue(Value: TcxGridChartItemSetStoredPropertyValueEvent);
|
|
procedure SetSortOrder(Value: TcxDataSortOrder);
|
|
procedure SetTag(Value: TcxTag);
|
|
procedure SetVisible(Value: Boolean);
|
|
procedure SetVisibleForCustomization(Value: Boolean);
|
|
function IsTagStored: Boolean;
|
|
protected
|
|
FSubObjectEvents: TNotifyEvent;
|
|
|
|
// IcxStoredObject
|
|
function GetObjectName: string; virtual;
|
|
function IcxStoredObject.GetProperties = GetStoredProperties;
|
|
function GetStoredProperties(AProperties: TStrings): Boolean; virtual;
|
|
procedure GetPropertyValue(const AName: string; var AValue: Variant); virtual;
|
|
procedure SetPropertyValue(const AName: string; const AValue: Variant); virtual;
|
|
procedure SetRestoredIndex(AValue: Integer); virtual; abstract;
|
|
// IcxGridChartItem
|
|
procedure DataChanged; virtual;
|
|
function GetDataBinding: TcxGridChartItemDataBinding;
|
|
procedure ValueTypeClassChanged;
|
|
|
|
procedure SetParentComponent(AParent: TComponent); override;
|
|
|
|
procedure Changed(AChange: TcxGridViewChangeKind = vcLayout); virtual;
|
|
procedure DisplayTextChanged; virtual;
|
|
procedure DoGetValueDisplayText(const AValue: Variant; var ADisplayText: string); virtual;
|
|
function GetDefaultDisplayText: string; virtual;
|
|
function GetDefaultValueTypeClass: TcxValueTypeClass; virtual; abstract;
|
|
procedure SetGridView(Value: TcxGridChartView);
|
|
procedure SetName(const NewName: TComponentName); override;
|
|
|
|
function GetValue(AIndex: Integer): Variant; virtual; abstract;
|
|
function GetValueCount: Integer; virtual; abstract;
|
|
function GetVisibleValue(AIndex: Integer): Variant; virtual; abstract;
|
|
function GetVisibleValueCount: Integer; virtual; abstract;
|
|
procedure SetValue(AIndex: Integer; const Value: Variant); virtual; abstract;
|
|
procedure SetValueCount(Value: Integer); virtual; abstract;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetParentComponent: TComponent; override;
|
|
function HasParent: Boolean; override;
|
|
|
|
function GetDisplayText: string;
|
|
function GetValueDisplayText(const AValue: Variant): string;
|
|
class function IsValue: Boolean; virtual; // abstract; - because of CLR, BCB
|
|
|
|
property GridView: TcxGridChartView read FGridView;
|
|
property ID: Integer read GetID;
|
|
property Index: Integer read GetIndex write SetIndex;
|
|
property Order: Integer read FOrder;
|
|
property ValueCount: Integer read GetValueCount write SetValueCount;
|
|
property Values[AIndex: Integer]: Variant read GetValue write SetValue; default;
|
|
property VisibleDisplayTexts[AIndex: Integer]: string read GetVisibleDisplayText;
|
|
property VisibleIndex: Integer read FVisibleIndex;
|
|
property VisibleValueCount: Integer read GetVisibleValueCount;
|
|
property VisibleValues[AIndex: Integer]: Variant read GetVisibleValue;
|
|
published
|
|
property DataBinding: TcxGridChartItemDataBinding read FDataBinding
|
|
write SetDataBinding;
|
|
property DisplayText: string read FDisplayText write SetDisplayText;
|
|
property SortOrder: TcxDataSortOrder read GetSortOrder write SetSortOrder default soNone;
|
|
property Tag: TcxTag read GetTag write SetTag stored IsTagStored;
|
|
property Visible: Boolean read FVisible write SetVisible default True;
|
|
property VisibleForCustomization: Boolean read FVisibleForCustomization
|
|
write SetVisibleForCustomization default True;
|
|
property OnGetStoredProperties: TcxGridChartItemGetStoredPropertiesEvent read FOnGetStoredProperties write SetOnGetStoredProperties;
|
|
property OnGetStoredPropertyValue: TcxGridChartItemGetStoredPropertyValueEvent read FOnGetStoredPropertyValue write SetOnGetStoredPropertyValue;
|
|
property OnGetValueDisplayText: TcxGridChartGetValueDisplayTextEvent read FOnGetValueDisplayText write SetOnGetValueDisplayText;
|
|
property OnSetStoredPropertyValue: TcxGridChartItemSetStoredPropertyValueEvent read FOnSetStoredPropertyValue write SetOnSetStoredPropertyValue;
|
|
end;
|
|
|
|
// categories
|
|
|
|
TcxGridChartCategoriesClass = class of TcxGridChartCategories;
|
|
|
|
TcxGridChartCategories = class(TcxCustomGridOptions, IcxGridChartItem)
|
|
private
|
|
FDataBinding: TcxGridChartItemDataBinding;
|
|
FDisplayText: string;
|
|
FOnGetValueDisplayText: TcxGridChartGetValueDisplayTextEvent;
|
|
function GetGridView: TcxGridChartView;
|
|
function GetID: Integer;
|
|
function GetSortOrder: TcxDataSortOrder;
|
|
function GetValue(Index: Integer): Variant;
|
|
function GetValueCount: Integer;
|
|
function GetVisibleDisplayText(Index: Integer): string;
|
|
function GetVisibleValue(Index: Integer): Variant;
|
|
function GetVisibleValueCount: Integer;
|
|
procedure SetDataBinding(Value: TcxGridChartItemDataBinding);
|
|
procedure SetDisplayText(const Value: string);
|
|
procedure SetOnGetValueDisplayText(Value: TcxGridChartGetValueDisplayTextEvent);
|
|
procedure SetSortOrder(Value: TcxDataSortOrder);
|
|
procedure SetValue(Index: Integer; const Value: Variant);
|
|
procedure SetValueCount(Value: Integer);
|
|
protected
|
|
// IcxGridChartItem
|
|
procedure DataChanged; virtual;
|
|
function GetDataBinding: TcxGridChartItemDataBinding;
|
|
procedure ValueTypeClassChanged;
|
|
|
|
procedure DoGetValueDisplayText(const AValue: Variant; var ADisplayText: string); virtual;
|
|
function GetDefaultDisplayText: string; virtual;
|
|
function GetDefaultValueTypeClass: TcxValueTypeClass; virtual;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); override;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetDisplayText: string;
|
|
function GetNamePath: string; override;
|
|
function GetValueDisplayText(const AValue: Variant): string;
|
|
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
property ID: Integer read GetID;
|
|
property ValueCount: Integer read GetValueCount write SetValueCount;
|
|
property Values[Index: Integer]: Variant read GetValue write SetValue; default;
|
|
property VisibleDisplayTexts[Index: Integer]: string read GetVisibleDisplayText;
|
|
property VisibleValueCount: Integer read GetVisibleValueCount;
|
|
property VisibleValues[Index: Integer]: Variant read GetVisibleValue;
|
|
published
|
|
property DataBinding: TcxGridChartItemDataBinding read FDataBinding
|
|
write SetDataBinding;
|
|
property DisplayText: string read FDisplayText write SetDisplayText;
|
|
property SortOrder: TcxDataSortOrder read GetSortOrder write SetSortOrder default soNone;
|
|
property OnGetValueDisplayText: TcxGridChartGetValueDisplayTextEvent read FOnGetValueDisplayText
|
|
write SetOnGetValueDisplayText;
|
|
end;
|
|
|
|
// data groups
|
|
|
|
TcxGridChartDataGroupClass = class of TcxGridChartDataGroup;
|
|
|
|
TcxGridChartDataGroup = class(TcxGridChartItem)
|
|
private
|
|
FActiveValue: Variant;
|
|
function GetActive: Boolean;
|
|
function GetActiveValueDisplayText: string;
|
|
function GetDataLevel: Integer;
|
|
function GetGroupIndex: Integer;
|
|
procedure SetActive(Value: Boolean);
|
|
procedure SetActiveValue(const Value: Variant);
|
|
procedure SetDataLevel(Value: Integer);
|
|
procedure SetGroupIndex(Value: Integer);
|
|
protected
|
|
// IcxStoredObject
|
|
function GetStoredProperties(AProperties: TStrings): Boolean; override;
|
|
procedure GetPropertyValue(const AName: string; var AValue: Variant); override;
|
|
procedure SetPropertyValue(const AName: string; const AValue: Variant); override;
|
|
procedure SetRestoredIndex(AValue: Integer); override;
|
|
|
|
procedure CheckActiveValue;
|
|
function GetDefaultValueTypeClass: TcxValueTypeClass; override;
|
|
|
|
function GetValue(AIndex: Integer): Variant; override;
|
|
function GetValueCount: Integer; override;
|
|
function GetVisibleValue(AIndex: Integer): Variant; override;
|
|
function GetVisibleValueCount: Integer; override;
|
|
procedure SetValue(AIndex: Integer; const Value: Variant); override;
|
|
procedure SetValueCount(Value: Integer); override;
|
|
|
|
function CanMove: Boolean; virtual;
|
|
|
|
property GroupIndex: Integer read GetGroupIndex write SetGroupIndex;
|
|
public
|
|
function HasActiveValue: Boolean;
|
|
class function IsValue: Boolean; override;
|
|
property Active: Boolean read GetActive write SetActive;
|
|
property ActiveValue: Variant read FActiveValue write SetActiveValue;
|
|
property ActiveValueDisplayText: string read GetActiveValueDisplayText;
|
|
property DataLevel: Integer read GetDataLevel write SetDataLevel;
|
|
published
|
|
property SortOrder default soAscending;
|
|
end;
|
|
|
|
// series
|
|
|
|
TcxGridChartSeriesGetValueStyleEvent = procedure(Sender: TcxGridChartSeries;
|
|
AValueIndex: Integer; var AStyle: TcxStyle) of object;
|
|
|
|
TcxGridChartSeriesStylesClass = class of TcxGridChartSeriesStyles;
|
|
|
|
TcxGridChartSeriesStyles = class(TcxCustomGridStyles)
|
|
private
|
|
FOnGetValueStyle: TcxGridChartSeriesGetValueStyleEvent;
|
|
function GetSeries: TcxGridChartSeries;
|
|
procedure SetOnGetValueStyle(Value: TcxGridChartSeriesGetValueStyleEvent);
|
|
protected
|
|
procedure GetDefaultViewParams(Index: Integer; AData: TObject; out AParams: TcxViewParams); override;
|
|
function GetGridView: TcxCustomGridView; override;
|
|
public
|
|
constructor Create(AOwner: TPersistent); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure GetValueParams(AValueIndex: Integer; AVaryColorsByCategory: Boolean;
|
|
out AParams: TcxViewParams); virtual;
|
|
property Series: TcxGridChartSeries read GetSeries;
|
|
published
|
|
property Values: TcxStyle index ssValues read GetValue write SetValue;
|
|
property OnGetValueStyle: TcxGridChartSeriesGetValueStyleEvent read FOnGetValueStyle
|
|
write SetOnGetValueStyle;
|
|
end;
|
|
|
|
TcxGridChartSeriesValueCustomDrawEvent = procedure(Sender: TcxGridChartSeries;
|
|
ACanvas: TcxCanvas; AViewInfo: TcxGridChartDiagramValueViewInfo; var ADone: Boolean) of object;
|
|
TcxGridChartValueClickEvent = procedure(Sender: TcxGridChartView; ASeries: TcxGridChartSeries;
|
|
AValueIndex: Integer; var AHandled: Boolean) of object;
|
|
|
|
TcxGridChartSeriesClass = class of TcxGridChartSeries;
|
|
|
|
TcxGridChartSeries = class(TcxGridChartItem)
|
|
private
|
|
FStyles: TcxGridChartSeriesStyles;
|
|
FValueCaptionFormat: string;
|
|
FOnCustomDrawValue: TcxGridChartSeriesValueCustomDrawEvent;
|
|
FOnValueClick: TcxGridChartValueClickEvent;
|
|
function GetGroupSummaryKind: TcxSummaryKind;
|
|
function GetSumOfValues: Variant;
|
|
procedure SetGroupSummaryKind(Value: TcxSummaryKind);
|
|
procedure SetStyles(Value: TcxGridChartSeriesStyles);
|
|
procedure SetValueCaptionFormat(const Value: string);
|
|
procedure SetOnCustomDrawValue(Value: TcxGridChartSeriesValueCustomDrawEvent);
|
|
procedure SetOnValueClick(Value: TcxGridChartValueClickEvent);
|
|
protected
|
|
// IcxStoredObject
|
|
function GetStoredProperties(AProperties: TStrings): Boolean; override;
|
|
procedure GetPropertyValue(const AName: string; var AValue: Variant); override;
|
|
procedure SetPropertyValue(const AName: string; const AValue: Variant); override;
|
|
procedure SetRestoredIndex(AValue: Integer); override;
|
|
|
|
procedure DoGetValueDisplayText(const AValue: Variant; var ADisplayText: string); override;
|
|
function GetDefaultValueTypeClass: TcxValueTypeClass; override;
|
|
function GetStylesClass: TcxGridChartSeriesStylesClass; virtual;
|
|
function IsGroupSummaryKindValid(AValue: TcxSummaryKind): Boolean; virtual;
|
|
|
|
function GetValue(AIndex: Integer): Variant; override;
|
|
function GetValueCount: Integer; override;
|
|
function GetVisibleValue(AIndex: Integer): Variant; override;
|
|
function GetVisibleValueCount: Integer; override;
|
|
procedure SetValue(AIndex: Integer; const Value: Variant); override;
|
|
procedure SetValueCount(Value: Integer); override;
|
|
|
|
procedure DoCustomDrawValue(ACanvas: TcxCanvas; AViewInfo: TcxGridChartDiagramValueViewInfo;
|
|
var ADone: Boolean); virtual;
|
|
function DoValueClick(AValueIndex: Integer): Boolean; virtual;
|
|
function HasCustomDrawValue: Boolean; virtual;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
function AddValue(const AValue: Variant): Integer;
|
|
class function IsValue: Boolean; override;
|
|
|
|
property SumOfValues: Variant read GetSumOfValues;
|
|
published
|
|
property GroupSummaryKind: TcxSummaryKind read GetGroupSummaryKind write SetGroupSummaryKind
|
|
default cxGridChartItemDefaultSummaryKind;
|
|
property Styles: TcxGridChartSeriesStyles read FStyles write SetStyles;
|
|
property ValueCaptionFormat: string read FValueCaptionFormat write SetValueCaptionFormat;
|
|
|
|
property StylesEvents: TNotifyEvent read FSubObjectEvents write FSubObjectEvents;
|
|
|
|
property OnCustomDrawValue: TcxGridChartSeriesValueCustomDrawEvent read FOnCustomDrawValue
|
|
write SetOnCustomDrawValue;
|
|
property OnValueClick: TcxGridChartValueClickEvent read FOnValueClick write SetOnValueClick;
|
|
end;
|
|
|
|
// view title
|
|
|
|
TcxGridChartTitleClass = class of TcxGridChartTitle;
|
|
|
|
TcxGridChartTitle = class(TcxCustomGridChartTitle)
|
|
protected
|
|
function GetDefaultPosition: TcxGridChartPartPosition; override;
|
|
published
|
|
property Position;
|
|
end;
|
|
|
|
// view
|
|
|
|
TcxGridChartDataLevelsInfoVisible = (dlivNever, dlivNonEmpty, dlivAlways);
|
|
TcxGridChartToolBoxBorder = (tbNone, tbSingle);
|
|
TcxGridChartToolBoxPosition = (tpTop, tpBottom);
|
|
TcxGridChartToolBoxVisible = (tvNever, tvNonEmpty, tvAlways);
|
|
|
|
TcxGridChartToolBoxClass = class of TcxGridChartToolBox;
|
|
|
|
TcxGridChartToolBox = class(TcxCustomGridOptions)
|
|
private
|
|
FBorder: TcxGridChartToolBoxBorder;
|
|
FCustomizeButton: Boolean;
|
|
FDataLevelActiveValueDropDownCount: Integer;
|
|
FDataLevelActiveValueDropDownWidth: Integer;
|
|
FDataLevelsInfoVisible: TcxGridChartDataLevelsInfoVisible;
|
|
FDiagramSelector: Boolean;
|
|
FPosition: TcxGridChartToolBoxPosition;
|
|
FVisible: TcxGridChartToolBoxVisible;
|
|
function GetGridView: TcxGridChartView;
|
|
procedure SetBorder(Value: TcxGridChartToolBoxBorder);
|
|
procedure SetCustomizeButton(Value: Boolean);
|
|
procedure SetDataLevelActiveValueDropDownCount(Value: Integer);
|
|
procedure SetDataLevelActiveValueDropDownWidth(Value: Integer);
|
|
procedure SetDataLevelsInfoVisible(Value: TcxGridChartDataLevelsInfoVisible);
|
|
procedure SetDiagramSelector(Value: Boolean);
|
|
procedure SetPosition(Value: TcxGridChartToolBoxPosition);
|
|
procedure SetVisible(Value: TcxGridChartToolBoxVisible);
|
|
protected
|
|
procedure GetStoredProperties(AProperties: TStrings); override;
|
|
procedure GetStoredPropertyValue(const AName: string; var AValue: Variant); override;
|
|
procedure SetStoredPropertyValue(const AName: string; const AValue: Variant); override;
|
|
|
|
function IsDataLevelsInfoNonEmpty: Boolean; virtual;
|
|
function IsNonEmpty: Boolean; virtual;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetDataLevelsInfoVisible: Boolean;
|
|
function GetVisible: Boolean;
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
published
|
|
property Border: TcxGridChartToolBoxBorder read FBorder write SetBorder default tbSingle;
|
|
property CustomizeButton: Boolean read FCustomizeButton write SetCustomizeButton default False;
|
|
property DataLevelActiveValueDropDownCount: Integer read FDataLevelActiveValueDropDownCount
|
|
write SetDataLevelActiveValueDropDownCount default cxGridChartDefaultDataLevelActiveValueDropDownCount;
|
|
property DataLevelActiveValueDropDownWidth: Integer read FDataLevelActiveValueDropDownWidth
|
|
write SetDataLevelActiveValueDropDownWidth default 0;
|
|
property DataLevelsInfoVisible: TcxGridChartDataLevelsInfoVisible read FDataLevelsInfoVisible
|
|
write SetDataLevelsInfoVisible default dlivNonEmpty;
|
|
property DiagramSelector: Boolean read FDiagramSelector write SetDiagramSelector default False;
|
|
property Position: TcxGridChartToolBoxPosition read FPosition write SetPosition default tpTop;
|
|
property Visible: TcxGridChartToolBoxVisible read FVisible write SetVisible default tvNonEmpty;
|
|
end;
|
|
|
|
TcxGridChartValueHotTrack = (vhDefault, vhNever, vhAlways);
|
|
|
|
TcxGridChartOptionsBehavior = class(TcxCustomGridOptionsBehavior)
|
|
private
|
|
FValueHints: Boolean;
|
|
FValueHotTrack: TcxGridChartValueHotTrack;
|
|
function GetGridView: TcxGridChartView;
|
|
procedure SetValueHints(Value: Boolean);
|
|
procedure SetValueHotTrack(Value: TcxGridChartValueHotTrack);
|
|
protected
|
|
procedure GetStoredProperties(AProperties: TStrings); override;
|
|
procedure GetStoredPropertyValue(const AName: string; var AValue: Variant); override;
|
|
procedure SetStoredPropertyValue(const AName: string; const AValue: Variant); override;
|
|
|
|
function GetDefaultValueHotTrack(AValueIndex: Integer): Boolean; virtual;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetValueHotTrack(AValueIndex: Integer): Boolean; virtual;
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
published
|
|
property ValueHints: Boolean read FValueHints write SetValueHints default True;
|
|
property ValueHotTrack: TcxGridChartValueHotTrack read FValueHotTrack write SetValueHotTrack default vhDefault;
|
|
end;
|
|
|
|
TcxGridChartDataDrillUpMethod = (ddumNone, ddumValueMouseRightButtonClick, ddumMouseRightButtonClick);
|
|
|
|
TcxGridChartOptionsCustomizeClass = class of TcxGridChartOptionsCustomize;
|
|
|
|
TcxGridChartOptionsCustomize = class(TcxCustomGridOptions)
|
|
private
|
|
FDataDrillDown: Boolean;
|
|
FDataDrillUpMethod: TcxGridChartDataDrillUpMethod;
|
|
FDataGroupHiding: Boolean;
|
|
FDataGroupMoving: Boolean;
|
|
FOptionsCustomization: Boolean;
|
|
FSeriesCustomization: Boolean;
|
|
procedure SetDataDrillDown(Value: Boolean);
|
|
procedure SetDataDrillUpMethod(Value: TcxGridChartDataDrillUpMethod);
|
|
procedure SetDataGroupHiding(Value: Boolean);
|
|
procedure SetDataGroupMoving(Value: Boolean);
|
|
procedure SetOptionsCustomization(Value: Boolean);
|
|
procedure SetSeriesCustomization(Value: Boolean);
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
published
|
|
property DataDrillDown: Boolean read FDataDrillDown write SetDataDrillDown default True;
|
|
property DataDrillUpMethod: TcxGridChartDataDrillUpMethod read FDataDrillUpMethod
|
|
write SetDataDrillUpMethod default ddumMouseRightButtonClick;
|
|
property DataGroupHiding: Boolean read FDataGroupHiding write SetDataGroupHiding default False;
|
|
property DataGroupMoving: Boolean read FDataGroupMoving write SetDataGroupMoving default True;
|
|
property OptionsCustomization: Boolean read FOptionsCustomization write SetOptionsCustomization default True;
|
|
property SeriesCustomization: Boolean read FSeriesCustomization write SetSeriesCustomization default True;
|
|
end;
|
|
|
|
TcxGridChartOptionsViewClass = class of TcxGridChartOptionsView;
|
|
|
|
TcxGridChartOptionsView = class(TcxCustomGridOptionsView)
|
|
private
|
|
FCategoriesPerPage: Integer;
|
|
function GetGridView: TcxGridChartView;
|
|
procedure SetCategoriesPerPage(Value: Integer);
|
|
public
|
|
//constructor Create(AGridView: TcxCustomGridView); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
property GridView: TcxGridChartView read GetGridView;
|
|
published
|
|
property CategoriesPerPage: Integer read FCategoriesPerPage write SetCategoriesPerPage default 0;
|
|
end;
|
|
|
|
TcxGridChartViewStyles = class(TcxCustomGridViewStyles)
|
|
private
|
|
function GetGridViewValue: TcxGridChartView;
|
|
protected
|
|
procedure GetDefaultViewParams(Index: Integer; AData: TObject; out AParams: TcxViewParams); override;
|
|
public
|
|
constructor Create(AOwner: TPersistent); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure GetDataLevelInfoParams(ADataLevel: Integer; out AParams: TcxViewParams); virtual;
|
|
property GridView: TcxGridChartView read GetGridViewValue;
|
|
published
|
|
property ActiveDataLevelInfo: TcxStyle index vsActiveDataLevelInfo read GetValue write SetValue;
|
|
property DataLevelActiveValueInfo: TcxStyle index vsDataLevelActiveValueInfo read GetValue write SetValue;
|
|
property DataLevelsInfo: TcxStyle index vsDataLevelsInfo read GetValue write SetValue;
|
|
property DiagramSelector: TcxStyle index vsDiagramSelector read GetValue write SetValue;
|
|
property Legend: TcxStyle index vsLegend read GetValue write SetValue;
|
|
property Title: TcxStyle index vsTitle read GetValue write SetValue;
|
|
property ToolBox: TcxStyle index vsToolBox read GetValue write SetValue;
|
|
end;
|
|
|
|
TcxGridOpenChartItemList = class(TcxOpenList)
|
|
private
|
|
function GetItem(Index: Integer): TcxGridChartItem;
|
|
procedure SetItem(Index: Integer; Value: TcxGridChartItem);
|
|
public
|
|
property Items[Index: Integer]: TcxGridChartItem read GetItem write SetItem; default;
|
|
end;
|
|
|
|
TcxGridChartDataGroupEvent = procedure(Sender: TcxGridChartView; ADataGroup: TcxGridChartDataGroup) of object;
|
|
TcxGridChartDiagramEvent = procedure(Sender: TcxGridChartView; ADiagram: TcxGridChartDiagram) of object;
|
|
TcxGridChartGetValueHintEvent = procedure(Sender: TcxGridChartView;
|
|
ASeries: TcxGridChartSeries; AValueIndex: Integer; var AHint: string) of object;
|
|
TcxGridChartLegendCustomDrawEvent = procedure(Sender: TcxGridChartView;
|
|
ACanvas: TcxCanvas; AViewInfo: TcxGridChartLegendViewInfo; var ADone: Boolean) of object;
|
|
TcxGridChartLegendItemCustomDrawEvent = procedure(Sender: TcxGridChartView;
|
|
ACanvas: TcxCanvas; AViewInfo: TcxGridChartLegendItemViewInfo; var ADone: Boolean) of object;
|
|
TcxGridChartSeriesEvent = procedure(Sender: TcxGridChartView; ASeries: TcxGridChartSeries) of object;
|
|
|
|
(*
|
|
|
|
User can customize:
|
|
ToolBox:
|
|
ActiveDiagram
|
|
ActiveDataLevel
|
|
DataGroups:
|
|
ActiveValue
|
|
Index
|
|
Visible
|
|
CustomizationForm:
|
|
Series:
|
|
Index
|
|
Visible
|
|
SortOrder
|
|
DataGroups:
|
|
Visible
|
|
Options:
|
|
Legend:
|
|
Position
|
|
Alignment
|
|
Orientation
|
|
Border
|
|
KeyBorder
|
|
Title:
|
|
Position
|
|
Alignment
|
|
ToolBox:
|
|
Position
|
|
Border
|
|
DiagramSelector
|
|
Other:
|
|
ValueHints
|
|
DataDrilling:
|
|
ActiveDataLevel
|
|
DataGroups:
|
|
ActiveValue
|
|
|
|
Store/Restore:
|
|
View:
|
|
ActiveDiagram
|
|
ActiveDataLevel
|
|
Options:
|
|
Legend:
|
|
Position
|
|
Alignment
|
|
Orientation
|
|
Border
|
|
KeyBorder
|
|
Title:
|
|
Position
|
|
Alignment
|
|
ToolBox:
|
|
Position
|
|
Border
|
|
DiagramSelector
|
|
Other:
|
|
ValueHints
|
|
DataGroup:
|
|
ActiveValue
|
|
Index
|
|
Visible
|
|
Series:
|
|
Index
|
|
Visible
|
|
SortOrder
|
|
|
|
*)
|
|
|
|
TcxGridChartView = class(TcxCustomGridView)
|
|
private
|
|
FActiveDataLevel: Integer;
|
|
FActiveDiagram: TcxGridChartDiagram;
|
|
FAvailableDiagrams: TList;
|
|
FCategories: TcxGridChartCategories;
|
|
FDataGroupActiveValuesUpdateNeeded: Boolean;
|
|
FDataGroups: TList;
|
|
FDiagramArea: TcxGridChartAreaDiagram;
|
|
FDiagramBar: TcxGridChartBarDiagram;
|
|
FDiagramColumn: TcxGridChartColumnDiagram;
|
|
FDiagramLine: TcxGridChartLineDiagram;
|
|
FDiagramPie: TcxGridChartPieDiagram;
|
|
FDiagrams: TList;
|
|
FIDs: TList;
|
|
FLegend: TcxGridChartLegend;
|
|
FOptionsCustomize: TcxGridChartOptionsCustomize;
|
|
FRestoredActiveDataLevel: Integer;
|
|
FRestoringDataGroups: TcxGridOpenChartItemList;
|
|
FRestoringSeries: TcxGridOpenChartItemList;
|
|
FSeries: TList;
|
|
FTitle: TcxGridChartTitle;
|
|
FToolBox: TcxGridChartToolBox;
|
|
FVisibleDataGroups: TList;
|
|
FVisibleSeries: TList;
|
|
FOnActiveDataLevelChanged: TNotifyEvent;
|
|
FOnActiveDiagramChanged: TcxGridChartDiagramEvent;
|
|
FOnCustomDrawLegend: TcxGridChartLegendCustomDrawEvent;
|
|
FOnCustomDrawLegendItem: TcxGridChartLegendItemCustomDrawEvent;
|
|
FOnDataGroupPosChanged: TcxGridChartDataGroupEvent;
|
|
FOnFirstVisibleCategoryIndexChanged: TNotifyEvent;
|
|
FOnGetValueHint: TcxGridChartGetValueHintEvent;
|
|
FOnSeriesPosChanged: TcxGridChartSeriesEvent;
|
|
FOnValueClick: TcxGridChartValueClickEvent;
|
|
FSubClassEvents: TNotifyEvent;
|
|
|
|
function GetActiveDataGroup: TcxGridChartDataGroup;
|
|
function GetAvailableDiagram(Index: Integer): TcxGridChartDiagram;
|
|
function GetAvailableDiagramCount: Integer;
|
|
function GetController: TcxGridChartController;
|
|
function GetDataController: TcxGridChartDataController;
|
|
function GetDataGroup(Index: Integer): TcxGridChartDataGroup;
|
|
function GetDataGroupCount: Integer;
|
|
function GetDiagram(Index: Integer): TcxGridChartDiagram;
|
|
function GetDiagramCount: Integer;
|
|
function GetItem(Index: Integer): IcxGridChartItem;
|
|
function GetItemCount: Integer;
|
|
function GetOptionsBehavior: TcxGridChartOptionsBehavior;
|
|
function GetOptionsView: TcxGridChartOptionsView;
|
|
function GetSeries(Index: Integer): TcxGridChartSeries;
|
|
function GetSeriesCount: Integer;
|
|
function GetSortedSeries: TcxGridChartSeries;
|
|
function GetStyles: TcxGridChartViewStyles;
|
|
function GetViewData: TcxGridChartViewData;
|
|
function GetViewInfo: TcxGridChartViewInfo;
|
|
function GetVisibleDataGroup(Index: Integer): TcxGridChartDataGroup;
|
|
function GetVisibleDataGroupCount: Integer;
|
|
function GetVisibleSeries(Index: Integer): TcxGridChartSeries;
|
|
function GetVisibleSeriesCount: Integer;
|
|
procedure SetActiveDataGroup(Value: TcxGridChartDataGroup);
|
|
procedure SetActiveDataLevel(Value: Integer);
|
|
procedure SetActiveDiagram(Value: TcxGridChartDiagram);
|
|
procedure SetCategories(Value: TcxGridChartCategories);
|
|
procedure SetDataController(Value: TcxGridChartDataController);
|
|
procedure SetDataGroup(Index: Integer; Value: TcxGridChartDataGroup);
|
|
procedure SetDiagramArea(Value: TcxGridChartAreaDiagram);
|
|
procedure SetDiagramBar(Value: TcxGridChartBarDiagram);
|
|
procedure SetDiagramColumn(Value: TcxGridChartColumnDiagram);
|
|
procedure SetDiagramLine(Value: TcxGridChartLineDiagram);
|
|
procedure SetDiagramPie(Value: TcxGridChartPieDiagram);
|
|
procedure SetLegend(Value: TcxGridChartLegend);
|
|
procedure SetOptionsBehavior(Value: TcxGridChartOptionsBehavior);
|
|
procedure SetOptionsCustomize(Value: TcxGridChartOptionsCustomize);
|
|
procedure SetOptionsView(Value: TcxGridChartOptionsView);
|
|
procedure SetSeries(Index: Integer; Value: TcxGridChartSeries);
|
|
procedure SetSortedSeries(Value: TcxGridChartSeries);
|
|
procedure SetStyles(Value: TcxGridChartViewStyles);
|
|
procedure SetTitle(Value: TcxGridChartTitle);
|
|
procedure SetToolBox(Value: TcxGridChartToolBox);
|
|
procedure SetOnActiveDataLevelChanged(Value: TNotifyEvent);
|
|
procedure SetOnActiveDiagramChanged(Value: TcxGridChartDiagramEvent);
|
|
procedure SetOnCustomDrawLegend(Value: TcxGridChartLegendCustomDrawEvent);
|
|
procedure SetOnCustomDrawLegendItem(Value: TcxGridChartLegendItemCustomDrawEvent);
|
|
procedure SetOnDataGroupPosChanged(Value: TcxGridChartDataGroupEvent);
|
|
procedure SetOnFirstVisibleCategoryIndexChanged(Value: TNotifyEvent);
|
|
procedure SetOnGetValueHint(Value: TcxGridChartGetValueHintEvent);
|
|
procedure SetOnSeriesPosChanged(Value: TcxGridChartSeriesEvent);
|
|
procedure SetOnValueClick(Value: TcxGridChartValueClickEvent);
|
|
|
|
protected
|
|
// IcxStoredObject
|
|
function GetProperties(AProperties: TStrings): Boolean; override;
|
|
procedure GetPropertyValue(const AName: string; var AValue: Variant); override;
|
|
procedure SetPropertyValue(const AName: string; const AValue: Variant); override;
|
|
// IcxStoredParent
|
|
function CreateStoredObject(const AObjectName, AClassName: string): TObject; override;
|
|
procedure GetStoredChildren(AChildren: TStringList); override;
|
|
// IcxGridViewLayoutEditorSupport - for design-time layout editor
|
|
procedure AssignLayout(ALayoutView: TcxCustomGridView); override;
|
|
function GetLayoutCustomizationFormButtonCaption: string; override;
|
|
function HasLayoutCustomizationForm: Boolean; override;
|
|
|
|
procedure CreateHandlers; override;
|
|
procedure DestroyHandlers; override;
|
|
procedure CreateOptions; override;
|
|
procedure DestroyOptions; override;
|
|
|
|
procedure ActiveDataLevelChanged(APrevActiveDataLevel: Integer); virtual;
|
|
procedure ActiveDiagramChanged(ADiagram: TcxGridChartDiagram); virtual;
|
|
procedure BeforeAssign(ASource: TcxCustomGridView); override;
|
|
procedure AfterAssign(ASource: TcxCustomGridView); override;
|
|
procedure DoAssign(ASource: TcxCustomGridView); override;
|
|
procedure BeforeRestoring; override;
|
|
procedure AfterRestoring; override;
|
|
procedure DataControllerUnlocked; virtual;
|
|
procedure GetChildren(Proc: TGetChildProc; Root: TComponent); override;
|
|
procedure GetFakeComponentLinks(AList: TList); override;
|
|
procedure RestoringComplete; override;
|
|
procedure SetChildOrder(Child: TComponent; Order: Integer); override;
|
|
procedure SetName(const NewName: TComponentName); override;
|
|
procedure UpdateControl(AInfo: TcxUpdateControlInfo); override;
|
|
|
|
function GetControllerClass: TcxCustomGridControllerClass; override;
|
|
function GetDataControllerClass: TcxCustomDataControllerClass; override;
|
|
function GetItemDataBindingClass: TcxGridChartItemDataBindingClass; virtual;
|
|
function GetPainterClass: TcxCustomGridPainterClass; override;
|
|
function GetViewDataClass: TcxCustomGridViewDataClass; override;
|
|
function GetViewInfoClass: TcxCustomGridViewInfoClass; override;
|
|
|
|
function GetLegendClass: TcxGridChartLegendClass; virtual;
|
|
function GetOptionsBehaviorClass: TcxCustomGridOptionsBehaviorClass; override;
|
|
function GetOptionsCustomizeClass: TcxGridChartOptionsCustomizeClass; virtual;
|
|
function GetOptionsViewClass: TcxCustomGridOptionsViewClass; override;
|
|
function GetStylesClass: TcxCustomGridViewStylesClass; override;
|
|
function GetTitleClass: TcxGridChartTitleClass; virtual;
|
|
function GetToolBoxClass: TcxGridChartToolBoxClass; virtual;
|
|
|
|
function GetAreaDiagramClass: TcxGridChartAreaDiagramClass; virtual;
|
|
function GetBarDiagramClass: TcxGridChartBarDiagramClass; virtual;
|
|
function GetCategoriesClass: TcxGridChartCategoriesClass; virtual;
|
|
function GetColumnDiagramClass: TcxGridChartColumnDiagramClass; virtual;
|
|
function GetLineDiagramClass: TcxGridChartLineDiagramClass; virtual;
|
|
function GetPieDiagramClass: TcxGridChartPieDiagramClass; virtual;
|
|
|
|
function GetCategoriesNamePath: string; virtual;
|
|
|
|
procedure AddDiagram(ADiagram: TcxGridChartDiagram);
|
|
procedure RemoveDiagram(ADiagram: TcxGridChartDiagram);
|
|
procedure ClearDiagrams;
|
|
function CreateDiagram(ADiagramClass: TcxGridChartDiagramClass): TcxGridChartDiagram;
|
|
procedure CreateDiagrams; virtual;
|
|
procedure DiagramRemoved(ADiagram: TcxGridChartDiagram); virtual;
|
|
function GetDiagramNamePath(ADiagram: TcxGridChartDiagram): string; virtual;
|
|
function GetFirstAvailableDiagram: TcxGridChartDiagram;
|
|
procedure RefreshAvailableDiagramList;
|
|
|
|
function GetNextID: Integer;
|
|
procedure ReleaseID(AID: Integer);
|
|
|
|
procedure DataSortingChanged(AItem: TObject); virtual;
|
|
procedure DataSortingChanging(AItem: TObject); virtual;
|
|
procedure UpdateDataController(AItem: TObject; ADataBinding: TcxGridChartItemDataBinding;
|
|
AAdd: Boolean);
|
|
procedure UpdateSummaryItemValues;
|
|
|
|
function GetItemList(AItemClass: TcxGridChartItemClass): TList; overload; virtual;
|
|
function GetItemList(AItem: TcxGridChartItem): TList; overload;
|
|
function GetVisibleItemList(AItem: TcxGridChartItem): TList; virtual;
|
|
procedure AddItem(AItem: TcxGridChartItem);
|
|
procedure RemoveItem(AItem: TcxGridChartItem);
|
|
function GetItemIndex(AItem: TcxGridChartItem): Integer;
|
|
procedure SetItemIndex(AItem: TcxGridChartItem; AIndex: Integer);
|
|
procedure DataGroupVisibilityChanged(ADataGroup: TcxGridChartDataGroup); virtual;
|
|
procedure ItemDisplayTextChanged(AItem: TcxGridChartItem); virtual;
|
|
procedure ItemIndexChanged(AItem: TcxGridChartItem); virtual;
|
|
procedure ItemPosChanged(AItem: TcxGridChartItem); virtual;
|
|
procedure ItemVisibilityChanged(AItem: TcxGridChartItem); virtual;
|
|
procedure ItemVisibilityForCustomizationChanged(AItem: TcxGridChartItem); virtual;
|
|
procedure SeriesVisibilityChanged(ASeries: TcxGridChartSeries); virtual;
|
|
procedure RefreshVisibleItemsList(AItems, AVisibleItems: TList);
|
|
procedure UpdateItemsOrder(AItemClass: TcxGridChartItemClass);
|
|
|
|
procedure ClearItems(AItemClass: TcxGridChartItemClass);
|
|
function CreateItem(AItemClass: TcxGridChartItemClass): TcxGridChartItem;
|
|
function FindItemByID(AItemClass: TcxGridChartItemClass; AID: Integer): TcxGridChartItem;
|
|
function FindItemByName(AItemClass: TcxGridChartItemClass; const AName: string): TcxGridChartItem;
|
|
function FindItemByTag(AItemClass: TcxGridChartItemClass; ATag: TcxTag): TcxGridChartItem;
|
|
|
|
function GetAvailableDataLevel(ALevel: Integer): Integer;
|
|
function GetDataLevelCount: Integer; virtual;
|
|
function GetDataLevelObject(Index: Integer): TcxGridChartDataGroup; virtual;
|
|
function GetDataObjectLevel(AObject: TcxGridChartDataGroup): Integer; virtual;
|
|
procedure SetDataObjectLevel(AObject: TcxGridChartDataGroup; ALevel: Integer); virtual;
|
|
function GetIsDataGrouped: Boolean; virtual;
|
|
procedure UpdateDataGroupActiveValues;
|
|
procedure UpdateDataLevels;
|
|
procedure UpdateDataSortingBySummary;
|
|
|
|
procedure CalculateImageWidth(var AWidth: Integer); virtual;
|
|
procedure CalculateImageHeight(var AHeight: Integer); virtual;
|
|
|
|
procedure DoActiveDataLevelChanged; virtual;
|
|
procedure DoActiveDiagramChanged(ADiagram: TcxGridChartDiagram); virtual;
|
|
procedure DoCustomDrawLegend(ACanvas: TcxCanvas; AViewInfo: TcxGridChartLegendViewInfo;
|
|
var ADone: Boolean); virtual;
|
|
procedure DoCustomDrawLegendItem(ACanvas: TcxCanvas; AViewInfo: TcxGridChartLegendItemViewInfo;
|
|
var ADone: Boolean); virtual;
|
|
procedure DoDataGroupPosChanged(ADataGroup: TcxGridChartDataGroup); virtual;
|
|
procedure DoFirstVisibleCategoryIndexChanged; virtual;
|
|
procedure DoGetValueHint(ASeries: TcxGridChartSeries; AValueIndex: Integer;
|
|
var AHint: string); virtual;
|
|
procedure DoSeriesPosChanged(ASeries: TcxGridChartSeries); virtual;
|
|
function DoValueClick(ASeries: TcxGridChartSeries; AValueIndex: Integer): Boolean; virtual;
|
|
function HasCustomDrawLegend: Boolean; virtual;
|
|
function HasCustomDrawLegendItem: Boolean; virtual;
|
|
|
|
property DataGroupActiveValuesUpdateNeeded: Boolean read FDataGroupActiveValuesUpdateNeeded;
|
|
property ItemCount: Integer read GetItemCount;
|
|
property Items[Index: Integer]: IcxGridChartItem read GetItem;
|
|
property RestoringDataGroups: TcxGridOpenChartItemList read FRestoringDataGroups;
|
|
property RestoringSeries: TcxGridOpenChartItemList read FRestoringSeries;
|
|
public
|
|
// base
|
|
function CreateImage(AGraphicClass: TGraphicClass; AWidth: Integer = 0; AHeight: Integer = 0): TGraphic;
|
|
property Controller: TcxGridChartController read GetController;
|
|
property ViewData: TcxGridChartViewData read GetViewData;
|
|
property ViewInfo: TcxGridChartViewInfo read GetViewInfo;
|
|
|
|
// diagrams
|
|
function FindDiagramByDisplayText(const ADisplayText: string): TcxGridChartDiagram;
|
|
function FindDiagramByID(const AID: string): TcxGridChartDiagram;
|
|
property AvailableDiagramCount: Integer read GetAvailableDiagramCount;
|
|
property AvailableDiagrams[Index: Integer]: TcxGridChartDiagram read GetAvailableDiagram;
|
|
property DiagramCount: Integer read GetDiagramCount;
|
|
property Diagrams[Index: Integer]: TcxGridChartDiagram read GetDiagram;
|
|
|
|
// series
|
|
procedure ClearSeries;
|
|
function CreateSeries: TcxGridChartSeries;
|
|
function FindSeriesByID(AID: Integer): TcxGridChartSeries;
|
|
function FindSeriesByName(const AName: string): TcxGridChartSeries;
|
|
function FindSeriesByTag(ATag: TcxTag): TcxGridChartSeries;
|
|
function GetSeriesClass: TcxGridChartSeriesClass; virtual;
|
|
|
|
property Series[Index: Integer]: TcxGridChartSeries read GetSeries write SetSeries;
|
|
property SeriesCount: Integer read GetSeriesCount;
|
|
property SortedSeries: TcxGridChartSeries read GetSortedSeries write SetSortedSeries;
|
|
property VisibleSeries[Index: Integer]: TcxGridChartSeries read GetVisibleSeries;
|
|
property VisibleSeriesCount: Integer read GetVisibleSeriesCount;
|
|
|
|
// data groups
|
|
procedure ClearDataGroups;
|
|
function CreateDataGroup: TcxGridChartDataGroup;
|
|
function FindDataGroupByID(AID: Integer): TcxGridChartDataGroup;
|
|
function FindDataGroupByName(const AName: string): TcxGridChartDataGroup;
|
|
function FindDataGroupByTag(ATag: TcxTag): TcxGridChartDataGroup;
|
|
function GetDataGroupClass: TcxGridChartDataGroupClass; virtual;
|
|
|
|
function CanActivateDataLevel(ALevel: Integer): Boolean;
|
|
|
|
property ActiveDataGroup: TcxGridChartDataGroup read GetActiveDataGroup write SetActiveDataGroup;
|
|
property ActiveDataLevel: Integer read FActiveDataLevel write SetActiveDataLevel;
|
|
property DataLevelCount: Integer read GetDataLevelCount;
|
|
property DataLevelObjects[Index: Integer]: TcxGridChartDataGroup read GetDataLevelObject;
|
|
property DataGroupCount: Integer read GetDataGroupCount;
|
|
property DataGroups[Index: Integer]: TcxGridChartDataGroup read GetDataGroup write SetDataGroup;
|
|
property IsDataGrouped: Boolean read GetIsDataGrouped;
|
|
property VisibleDataGroupCount: Integer read GetVisibleDataGroupCount;
|
|
property VisibleDataGroups[Index: Integer]: TcxGridChartDataGroup read GetVisibleDataGroup;
|
|
published
|
|
property ActiveDiagram: TcxGridChartDiagram read FActiveDiagram write SetActiveDiagram stored False;
|
|
property Categories: TcxGridChartCategories read FCategories write SetCategories
|
|
;
|
|
property DataController: TcxGridChartDataController read GetDataController write SetDataController;
|
|
property DiagramArea: TcxGridChartAreaDiagram read FDiagramArea write SetDiagramArea;
|
|
property DiagramBar: TcxGridChartBarDiagram read FDiagramBar write SetDiagramBar;
|
|
property DiagramColumn: TcxGridChartColumnDiagram read FDiagramColumn write SetDiagramColumn;
|
|
property DiagramLine: TcxGridChartLineDiagram read FDiagramLine write SetDiagramLine;
|
|
property DiagramPie: TcxGridChartPieDiagram read FDiagramPie write SetDiagramPie;
|
|
property Legend: TcxGridChartLegend read FLegend write SetLegend;
|
|
property OptionsBehavior: TcxGridChartOptionsBehavior read GetOptionsBehavior write SetOptionsBehavior;
|
|
property OptionsCustomize: TcxGridChartOptionsCustomize read FOptionsCustomize write SetOptionsCustomize;
|
|
property OptionsView: TcxGridChartOptionsView read GetOptionsView write SetOptionsView;
|
|
property Styles: TcxGridChartViewStyles read GetStyles write SetStyles;
|
|
property Title: TcxGridChartTitle read FTitle write SetTitle;
|
|
property ToolBox: TcxGridChartToolBox read FToolBox write SetToolBox;
|
|
|
|
property CategoriesEvents: TNotifyEvent read FSubClassEvents write FSubClassEvents;
|
|
property DiagramAreaEvents: TNotifyEvent read FSubClassEvents write FSubClassEvents;
|
|
property DiagramBarEvents: TNotifyEvent read FSubClassEvents write FSubClassEvents;
|
|
property DiagramColumnEvents: TNotifyEvent read FSubClassEvents write FSubClassEvents;
|
|
property DiagramLineEvents: TNotifyEvent read FSubClassEvents write FSubClassEvents;
|
|
property DiagramPieEvents: TNotifyEvent read FSubClassEvents write FSubClassEvents;
|
|
|
|
property OnActiveDataLevelChanged: TNotifyEvent read FOnActiveDataLevelChanged write SetOnActiveDataLevelChanged;
|
|
property OnActiveDiagramChanged: TcxGridChartDiagramEvent read FOnActiveDiagramChanged write SetOnActiveDiagramChanged;
|
|
property OnCustomDrawLegend: TcxGridChartLegendCustomDrawEvent read FOnCustomDrawLegend write SetOnCustomDrawLegend;
|
|
property OnCustomDrawLegendItem: TcxGridChartLegendItemCustomDrawEvent read FOnCustomDrawLegendItem write SetOnCustomDrawLegendItem;
|
|
property OnCustomization;
|
|
property OnDataGroupPosChanged: TcxGridChartDataGroupEvent read FOnDataGroupPosChanged write SetOnDataGroupPosChanged;
|
|
property OnFirstVisibleCategoryIndexChanged: TNotifyEvent read FOnFirstVisibleCategoryIndexChanged write SetOnFirstVisibleCategoryIndexChanged;
|
|
property OnGetValueHint: TcxGridChartGetValueHintEvent read FOnGetValueHint write SetOnGetValueHint;
|
|
property OnInitStoredObject;
|
|
property OnSeriesPosChanged: TcxGridChartSeriesEvent read FOnSeriesPosChanged write SetOnSeriesPosChanged;
|
|
property OnValueClick: TcxGridChartValueClickEvent read FOnValueClick write SetOnValueClick;
|
|
end;
|
|
|
|
var
|
|
cxGridChartDiagramImages: TImageList;
|
|
|
|
procedure cxGridChartDiagramImages_Add(const AResourceName: string);
|
|
|
|
function IsValueTypeClassValid(AValueTypeClass: TcxValueTypeClass): Boolean;
|
|
|
|
implementation
|
|
|
|
{$R cxGridChartView.res}
|
|
|
|
uses
|
|
{$IFDEF DELPHI6}
|
|
Types, StrUtils,
|
|
{$IFNDEF NONDB}
|
|
FMTBcd,
|
|
{$ENDIF}
|
|
{$ENDIF}
|
|
SysUtils, Math, ImgList,
|
|
cxEditDataRegisteredRepositoryItems, cxGrid, cxGridLevel, cxGridStrs, cxListBox,
|
|
cxTextEdit, cxLibraryConsts;
|
|
|
|
const
|
|
ChartPartOffset = 10;
|
|
|
|
MarkWidth = 1;
|
|
CategoryGridLineWidth = 1;
|
|
ValueGridLineWidth = 1;
|
|
ValueAxisWidth = CategoryGridLineWidth;
|
|
CategoryAxisWidth = ValueGridLineWidth;
|
|
|
|
TickMarkLabelsOffset = 10;
|
|
|
|
ColumnDiagramValueOffsetUnits = 3;
|
|
ColumnDiagramValueSizeUnits = 4;
|
|
|
|
LineDiagramCaptionOffset = 2;
|
|
LineDiagramValueSizeUnits = 2;
|
|
LineDiagramLineHotZoneMinWidth = 5;
|
|
|
|
AreaDiagramLegendKeyOffset = 2;
|
|
AreaDiagramLegendKeySpace = 3;
|
|
|
|
PieMinSize = 100;
|
|
PieSeriesSiteOffset = 10;
|
|
PieAreaOffset = 20;
|
|
PieValueCaptionOffset = 4;
|
|
PieLeaderLineSegment1 = 12;
|
|
PieLeaderLineSegment2 = 9;
|
|
|
|
ToolBoxItemOffset = 5;
|
|
ToolBoxItemSeparatorWidth = 1;
|
|
ToolBoxDataLevelInfoConnectorWidth = 1;
|
|
ToolBoxDiagramImageOffset = 2;
|
|
|
|
DefaultItemDisplayText = '<no display text>';
|
|
|
|
ValueHintOffset = 27;
|
|
|
|
procedure cxGridChartDiagramImages_Add(const AResourceName: string);
|
|
var
|
|
B: TBitmap;
|
|
begin
|
|
B := TBitmap.Create;
|
|
try
|
|
B.LoadFromResourceName(HInstance, AResourceName);
|
|
cxGridChartDiagramImages.AddMasked(B, B.TransparentColor);
|
|
finally
|
|
B.Free;
|
|
end;
|
|
end;
|
|
|
|
function GetDefaultValueColor(AIndex: Integer): TColor;
|
|
const
|
|
ColorCount = 24;
|
|
Colors: array[0..ColorCount - 1] of TColor =
|
|
($60C1FF, $B4835C, $7C58A5, $657C6C, $6379E6, $9AA05B, $605DCF, $6A8846,
|
|
$61A3F5, $58999E, $5A8CFF, $AD977A, $808E54, $95C9B9, $6763A5, $AC8C4D,
|
|
$80E4FB, $956349, $4D50C0, $67B48B, $D6A584, $73D8DD, $89674D, $9CB5A5);
|
|
begin
|
|
Result := Colors[AIndex mod ColorCount];
|
|
end;
|
|
|
|
function GetHotColor(AColor: TColor): TColor;
|
|
const
|
|
Alpha = 80;
|
|
//Delta = 25;
|
|
var
|
|
R, G, B: Byte;
|
|
begin
|
|
Result := ColorToRGB(AColor);
|
|
R := GetRValue(Result);
|
|
G := GetGValue(Result);
|
|
B := GetBValue(Result);
|
|
{ // MS Money style - does not give good results on light colors (clRed, clLime, ...)
|
|
Result := RGB(
|
|
Min(R + Delta, 255),
|
|
Min(G + Delta, 255),
|
|
Min(B + Delta, 255)
|
|
);}
|
|
// alpha blending with white color
|
|
Result := RGB(
|
|
MulDiv(R, Alpha, 100) + MulDiv(255, 100 - Alpha, 100),
|
|
MulDiv(G, Alpha, 100) + MulDiv(255, 100 - Alpha, 100),
|
|
MulDiv(B, Alpha, 100) + MulDiv(255, 100 - Alpha, 100)
|
|
);
|
|
end;
|
|
|
|
procedure PositionRect(out R: TRect; var AClientR: TRect; AWidth, AHeight, AOffset: Integer;
|
|
APosition: TcxGridChartPartPosition);
|
|
begin
|
|
R := AClientR;
|
|
case APosition of
|
|
cppLeft:
|
|
begin
|
|
R.Right := R.Left + AWidth;
|
|
AClientR.Left := R.Right + AOffset;
|
|
end;
|
|
cppTop:
|
|
begin
|
|
R.Bottom := R.Top + AHeight;
|
|
AClientR.Top := R.Bottom + AOffset;
|
|
end;
|
|
cppRight:
|
|
begin
|
|
R.Left := R.Right - AWidth;
|
|
AClientR.Right := R.Left - AOffset;
|
|
end;
|
|
cppBottom:
|
|
begin
|
|
R.Top := R.Bottom - AHeight;
|
|
AClientR.Bottom := R.Top - AOffset;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure AlignRect(var R: TRect; AWidth, AHeight: Integer; AIsHorizontal: Boolean;
|
|
AAlignment: TcxGridChartPartAlignment);
|
|
var
|
|
AOriginalR: TRect;
|
|
begin
|
|
AOriginalR := R;
|
|
case AAlignment of
|
|
cpaStart:
|
|
if AIsHorizontal then
|
|
R.Right := R.Left + AWidth
|
|
else
|
|
R.Bottom := R.Top + AHeight;
|
|
cpaCenter:
|
|
if AIsHorizontal then
|
|
begin
|
|
R.Left := (R.Left + R.Right - AWidth) div 2;
|
|
R.Right := R.Left + AWidth;
|
|
end
|
|
else
|
|
begin
|
|
R.Top := (R.Top + R.Bottom - AHeight) div 2;
|
|
R.Bottom := R.Top + AHeight;
|
|
end;
|
|
cpaEnd:
|
|
if AIsHorizontal then
|
|
R.Left := R.Right - AWidth
|
|
else
|
|
R.Top := R.Bottom - AHeight;
|
|
end;
|
|
// IntersectRect(R, R, AOriginalR);
|
|
end;
|
|
|
|
procedure CheckRectBounds(var R: TRect);
|
|
begin
|
|
with R do
|
|
begin
|
|
if Left > Right then
|
|
SwapIntegers(Left, Right);
|
|
if Top > Bottom then
|
|
SwapIntegers(Top, Bottom);
|
|
end;
|
|
end;
|
|
|
|
procedure GetCenteredRect(const ACenter: TPoint; AWidth, AHeight: Integer; out R: TRect);
|
|
begin
|
|
R.Left := ACenter.X - AWidth div 2;
|
|
R.Right := R.Left + AWidth;
|
|
R.Top := ACenter.Y - AHeight div 2;
|
|
R.Bottom := R.Top + AHeight;
|
|
end;
|
|
|
|
{$IFNDEF DELPHI6}
|
|
|
|
type
|
|
TValueSign = -1..1;
|
|
|
|
function Sign(const AValue: Double): TValueSign;
|
|
const
|
|
NegativeValue = Low(TValueSign);
|
|
ZeroValue = 0;
|
|
PositiveValue = High(TValueSign);
|
|
begin
|
|
if (PInt64(@AValue)^ and $7FFFFFFFFFFFFFFF) = $0000000000000000 then
|
|
Result := ZeroValue
|
|
else
|
|
if (PInt64(@AValue)^ and $8000000000000000) = $8000000000000000 then
|
|
Result := NegativeValue
|
|
else
|
|
Result := PositiveValue;
|
|
end;
|
|
|
|
{$ENDIF}
|
|
|
|
const
|
|
ErrorValue = 1e-15;
|
|
|
|
function Fraction(const AValue: Extended): Extended;
|
|
begin
|
|
Result := Frac(AValue);
|
|
if Result <> 0 then // to fix the bug in standard implementation
|
|
begin
|
|
Result := Frac(AValue + Sign(AValue) * ErrorValue);
|
|
if Abs(Result) < ErrorValue then
|
|
Result := 0
|
|
else
|
|
begin
|
|
Result := Frac(AValue - Sign(AValue) * ErrorValue);
|
|
if 1 - Abs(Result) < ErrorValue then
|
|
Result := 0;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function Ceiling(const X: Extended): Integer;
|
|
begin
|
|
Result := Integer(Trunc(X));
|
|
if Fraction(X) > 0 then Inc(Result);
|
|
end;
|
|
|
|
procedure CheckZero(var AValue: Extended);
|
|
begin
|
|
if Abs(AValue) < ErrorValue then AValue := 0;
|
|
end;
|
|
|
|
function IsPositive(const AValue: Extended): Boolean;
|
|
begin
|
|
Result := AValue >= 0;
|
|
end;
|
|
|
|
function IsValueTypeValid(AValueType: {$IFDEF DELPHI6}TVarType{$ELSE}Integer{$ENDIF};
|
|
AOnlyIntegerTypes: Boolean): Boolean;
|
|
const
|
|
ValidIntegerValueTypes = [varSmallint, varInteger, varByte
|
|
{$IFDEF DELPHI6}, varShortInt, varWord, varLongWord, varInt64{$ENDIF}];
|
|
ValidFloatValueTypes = [varSingle, varDouble, varCurrency];
|
|
begin
|
|
Result := (AValueType in ValidIntegerValueTypes) or not AOnlyIntegerTypes and
|
|
((AValueType in ValidFloatValueTypes){$IFDEF DELPHI6}{$IFNDEF NONDB} or (AValueType = VarFMTBcd){$ENDIF}{$ENDIF});
|
|
end;
|
|
|
|
function IsValueTypeClassValid(AValueTypeClass: TcxValueTypeClass): Boolean;
|
|
begin
|
|
Result := IsValueTypeValid(AValueTypeClass.GetVarType, False);
|
|
end;
|
|
|
|
function IsValueValid(const AValue: Variant): Boolean;
|
|
begin
|
|
Result := IsValueTypeValid(VarType(AValue), False);
|
|
end;
|
|
|
|
function GetPointOnCircle(const ACenter: TPoint; ARadius, AAngle: Integer): TPoint;
|
|
var
|
|
ASin, ACos: Extended;
|
|
begin
|
|
SinCos(DegToRad(AAngle - 90), ASin, ACos);
|
|
Result.X := ACenter.X + Round(ARadius * ACos);
|
|
Result.Y := ACenter.Y + Round(ARadius * ASin);
|
|
end;
|
|
|
|
function LineHasPoint(const ALineStart, ALineFinish: TPoint; ALineWidth: Integer;
|
|
const P: TPoint; AHotZoneMinWidth: Integer): Boolean;
|
|
var
|
|
ALineIntersectionY, AHotZoneSizeY: Integer;
|
|
begin
|
|
Result := (ALineStart.X <= P.X) and (P.X < ALineFinish.X);
|
|
if Result then
|
|
begin
|
|
ALineIntersectionY := ALineStart.Y + MulDiv(ALineFinish.Y - ALineStart.Y,
|
|
P.X - ALineStart.X, ALineFinish.X - ALineStart.X);
|
|
AHotZoneSizeY := Abs(Round(Max(AHotZoneMinWidth, ALineWidth div 2) *
|
|
Sqrt(1 + Sqr((ALineFinish.Y - ALineStart.Y) / (ALineFinish.X - ALineStart.X)))));
|
|
Result :=
|
|
(ALineIntersectionY - AHotZoneSizeY <= P.Y) and
|
|
(P.Y <= ALineIntersectionY + AHotZoneSizeY);
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartTitleHitTest }
|
|
|
|
class function TcxGridChartTitleHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htChartTitle;
|
|
end;
|
|
|
|
{ TcxGridChartLegendHitTest }
|
|
|
|
class function TcxGridChartLegendHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htLegend;
|
|
end;
|
|
|
|
{ TcxGridChartLegendItemHitTest }
|
|
|
|
class function TcxGridChartLegendItemHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htLegendItem;
|
|
end;
|
|
|
|
{ TcxGridChartToolBoxHitTest }
|
|
|
|
class function TcxGridChartToolBoxHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htChartToolBox;
|
|
end;
|
|
|
|
{ TcxGridChartDataLevelInfoHitTest }
|
|
|
|
procedure TcxGridChartDataLevelInfoHitTest.SetDataLevel(Value: Integer);
|
|
begin
|
|
FDataLevel := Value;
|
|
if FDataLevel = -1 then
|
|
FDataLevelObject := nil
|
|
else
|
|
FDataLevelObject := TcxGridChartView(GridView).DataLevelObjects[FDataLevel];
|
|
end;
|
|
|
|
procedure TcxGridChartDataLevelInfoHitTest.SetDataLevelObject(Value: TcxGridChartDataGroup);
|
|
begin
|
|
FDataLevelObject := Value;
|
|
if FDataLevelObject = nil then
|
|
FDataLevel := -1
|
|
else
|
|
FDataLevel := FDataLevelObject.DataLevel;
|
|
end;
|
|
|
|
class function TcxGridChartDataLevelInfoHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htDataLevelInfo;
|
|
end;
|
|
|
|
function TcxGridChartDataLevelInfoHitTest.DragAndDropObjectClass: TcxCustomGridDragAndDropObjectClass;
|
|
begin
|
|
if (DataLevelObject <> nil) and DataLevelObject.CanMove then
|
|
Result := TcxGridChartView(GridView).Controller.GetDataLevelInfoDragAndDropObjectClass
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
{ TcxGridChartDataLevelActiveValueInfoHitTest }
|
|
|
|
class function TcxGridChartDataLevelActiveValueInfoHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htDataLevelActiveValueInfo;
|
|
end;
|
|
|
|
function TcxGridChartDataLevelActiveValueInfoHitTest.Cursor: TCursor;
|
|
begin
|
|
if CanDropDown then
|
|
Result := crcxHandPoint
|
|
else
|
|
Result := inherited Cursor;
|
|
end;
|
|
|
|
function TcxGridChartDataLevelActiveValueInfoHitTest.DragAndDropObjectClass: TcxCustomGridDragAndDropObjectClass;
|
|
begin
|
|
if CanDropDown then
|
|
Result := nil
|
|
else
|
|
Result := inherited DragAndDropObjectClass;
|
|
end;
|
|
|
|
{ TcxGridChartCustomizeButtonHitTest }
|
|
|
|
class function TcxGridChartCustomizeButtonHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htChartCustomizeButton;
|
|
end;
|
|
|
|
{ TcxGridChartDiagramSelectorHitTest }
|
|
|
|
class function TcxGridChartDiagramSelectorHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htDiagramSelector;
|
|
end;
|
|
|
|
function TcxGridChartDiagramSelectorHitTest.Cursor: TCursor;
|
|
begin
|
|
if CanDropDown then
|
|
Result := crcxHandPoint
|
|
else
|
|
Result := inherited Cursor;
|
|
end;
|
|
|
|
{ TcxGridChartValueHitTest }
|
|
|
|
class function TcxGridChartValueHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htChartValue;
|
|
end;
|
|
|
|
function TcxGridChartValueHitTest.Cursor: TCursor;
|
|
begin
|
|
if CanDrillDown then
|
|
Result := crcxGridMagnifier
|
|
else
|
|
Result := inherited Cursor;
|
|
end;
|
|
|
|
{ TcxGridChartHistogramPlotHitTest }
|
|
|
|
class function TcxGridChartHistogramPlotHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htPlot;
|
|
end;
|
|
|
|
{ TcxGridChartHistogramCategoryAxisTitleHitTest }
|
|
|
|
class function TcxGridChartHistogramCategoryAxisTitleHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htCategoryAxisTitle;
|
|
end;
|
|
|
|
{ TcxGridChartHistogramValueAxisTitleHitTest }
|
|
|
|
class function TcxGridChartHistogramValueAxisTitleHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htValueAxisTitle;
|
|
end;
|
|
|
|
{ TcxGridChartValueLineHitTest }
|
|
|
|
class function TcxGridChartValueLineHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htChartValueLine;
|
|
end;
|
|
|
|
{ TcxGridChartValueAreaHitTest }
|
|
|
|
class function TcxGridChartValueAreaHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htChartValueArea;
|
|
end;
|
|
|
|
{ TcxGridChartPieSeriesSiteHitTest }
|
|
|
|
class function TcxGridChartPieSeriesSiteHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htSeriesSite;
|
|
end;
|
|
|
|
{ TcxGridChartPieSeriesSiteCaptionHitTest }
|
|
|
|
class function TcxGridChartPieSeriesSiteCaptionHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htSeriesSiteCaption;
|
|
end;
|
|
|
|
{ TcxCustomGridChartMovingObject }
|
|
|
|
function TcxCustomGridChartMovingObject.GetController: TcxGridChartController;
|
|
begin
|
|
Result := TcxGridChartController(inherited Controller);
|
|
end;
|
|
|
|
function TcxCustomGridChartMovingObject.GetCustomizationForm: TcxGridChartCustomizationForm;
|
|
begin
|
|
Result := TcxGridChartCustomizationForm(inherited CustomizationForm);
|
|
end;
|
|
|
|
function TcxCustomGridChartMovingObject.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
function TcxCustomGridChartMovingObject.GetViewInfo: TcxGridChartViewInfo;
|
|
begin
|
|
Result := TcxGridChartViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
{ TcxGridChartDataGroupMovingObject }
|
|
|
|
constructor TcxGridChartDataGroupMovingObject.Create(AControl: TcxControl);
|
|
begin
|
|
inherited;
|
|
FDestDataLevel := -1;
|
|
end;
|
|
|
|
function TcxGridChartDataGroupMovingObject.GetSourceItem: TcxGridChartDataGroup;
|
|
begin
|
|
Result := TcxGridChartDataGroup(inherited SourceItem);
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroupMovingObject.SetDestDataLevel(Value: Integer);
|
|
begin
|
|
if FDestDataLevel <> Value then
|
|
begin
|
|
Dirty := True;
|
|
FDestDataLevel := Value;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroupMovingObject.SetSourceItem(Value: TcxGridChartDataGroup);
|
|
begin
|
|
inherited SourceItem := Value;
|
|
end;
|
|
|
|
function TcxGridChartDataGroupMovingObject.CanRemove: Boolean;
|
|
begin
|
|
Result := SourceItem.Visible and SourceItem.VisibleForCustomization and
|
|
(GridView.OptionsCustomize.DataGroupHiding or Controller.Customization);
|
|
end;
|
|
|
|
function TcxGridChartDataGroupMovingObject.GetArrowAreaBounds(APlace: TcxGridArrowPlace): TRect;
|
|
begin
|
|
Result := ViewInfo.ToolBoxViewInfo.GetDataGroupInsertionBounds(DestDataLevel);
|
|
end;
|
|
|
|
function TcxGridChartDataGroupMovingObject.GetCustomizationFormListBox: TcxCustomGridItemsListBox;
|
|
begin
|
|
Result := CustomizationForm.DataGroupsListBox;
|
|
end;
|
|
|
|
function TcxGridChartDataGroupMovingObject.GetSourceItemViewInfo: TcxCustomGridCellViewInfo;
|
|
begin
|
|
if SourceItemContainerKind = ckToolBox then
|
|
Result := ViewInfo.ToolBoxViewInfo.DataLevelInfos[SourceItem.DataLevel]
|
|
else
|
|
Result := inherited GetSourceItemViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartDataGroupMovingObject.IsSourceCustomizationForm: Boolean;
|
|
begin
|
|
Result := SourceItemContainerKind = ckCustomizationForm;
|
|
end;
|
|
|
|
function TcxGridChartDataGroupMovingObject.IsValidDestination: Boolean;
|
|
begin
|
|
Result := (DestDataLevel <> -1) and (not SourceItem.Visible or
|
|
(DestDataLevel < SourceItem.DataLevel) or (DestDataLevel > SourceItem.DataLevel + 1));
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroupMovingObject.BeginDragAndDrop;
|
|
begin
|
|
if CustomizationForm <> nil then
|
|
CustomizationForm.PrepareForDataGroupDragAndDrop;
|
|
Controller.FMovingDataGroup := SourceItem;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroupMovingObject.DragAndDrop(const P: TPoint; var Accepted: Boolean);
|
|
begin
|
|
DestDataLevel := ViewInfo.ToolBoxViewInfo.GetDataGroupInsertionIndex(P);
|
|
Accepted := (ViewInfo.GetHitTest(P).HitTestCode = htCustomizationForm) or
|
|
(DestDataLevel <> -1);
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroupMovingObject.EndDragAndDrop(Accepted: Boolean);
|
|
|
|
function GetNewDataLevel: Integer;
|
|
begin
|
|
Result := DestDataLevel;
|
|
if SourceItem.Visible and (SourceItem.DataLevel < Result) then
|
|
Dec(Result);
|
|
end;
|
|
|
|
var
|
|
ADataGroupPositionChanged: Boolean;
|
|
begin
|
|
inherited;
|
|
Controller.FMovingDataGroup := nil;
|
|
if not Accepted then Exit;
|
|
ADataGroupPositionChanged := False;
|
|
if DestDataLevel = -1 then
|
|
if CanRemove then
|
|
begin
|
|
SourceItem.Visible := False;
|
|
ADataGroupPositionChanged := True;
|
|
end
|
|
else
|
|
else
|
|
if IsValidDestination then
|
|
begin
|
|
SourceItem.DataLevel := GetNewDataLevel;
|
|
ADataGroupPositionChanged := True;
|
|
end;
|
|
if ADataGroupPositionChanged then
|
|
GridView.DoDataGroupPosChanged(SourceItem);
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroupMovingObject.Init(const P: TPoint; AParams: TcxCustomGridHitTest);
|
|
begin
|
|
inherited;
|
|
with AParams as TcxGridChartDataLevelInfoHitTest do
|
|
begin
|
|
SourceItem := DataLevelObject;
|
|
SourceItemContainerKind := DataLevelObjectContainerKind;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartSeriesInnerCheckListBox }
|
|
|
|
function TcxGridChartSeriesInnerCheckListBox.GetMetrics: TcxCheckListBoxMetrics;
|
|
begin
|
|
Result := inherited GetMetrics;
|
|
Inc(Result.CheckFrameWidth, cxTextOffset);
|
|
Inc(Result.ContentOffset, cxTextOffset);
|
|
Inc(Result.ImageFrameWidth, 1);
|
|
Result.TextAreaOffset := 0;
|
|
Inc(Result.TextOffset, 1);
|
|
end;
|
|
|
|
function TcxGridChartSeriesInnerCheckListBox.GetSeriesImageSize: Integer;
|
|
begin
|
|
Result := GetStandardItemHeight - 2 * (Metrics.ImageFrameWidth + 1);
|
|
end;
|
|
|
|
{ TcxGridChartSeriesCheckListBox }
|
|
|
|
constructor TcxGridChartSeriesCheckListBox.Create(AOwner: TComponent;
|
|
AGridView: TcxGridChartView);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FGridView := AGridView;
|
|
DragCursor := crcxGridDrag;
|
|
DragMode := dmAutomatic;
|
|
ImageLayout := ilAfterChecks;
|
|
Style.LookAndFeel.MasterLookAndFeel := GridView.LookAndFeel;
|
|
Style.HotTrack := False;
|
|
OnClickCheck := CheckClicked;
|
|
FSeriesImages := TImageList.Create(nil);
|
|
EditValueFormat := cvfIndices;
|
|
end;
|
|
|
|
destructor TcxGridChartSeriesCheckListBox.Destroy;
|
|
begin
|
|
FreeAndNil(FSeriesImages);
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartSeriesCheckListBox.GetSeries(AIndex: Integer): TcxGridChartSeries;
|
|
begin
|
|
Result := TcxGridChartSeries(Items[AIndex].ItemObject);
|
|
end;
|
|
|
|
procedure TcxGridChartSeriesCheckListBox.CheckClicked(Sender: TObject; AIndex: Integer;
|
|
APrevState, ANewState: TcxCheckBoxState);
|
|
begin
|
|
LockRefreshItems := True;
|
|
try
|
|
Series[AIndex].Visible := ANewState = cbsChecked;
|
|
finally
|
|
LockRefreshItems := False;
|
|
end;
|
|
GridView.DoSeriesPosChanged(Series[AIndex]);
|
|
end;
|
|
|
|
procedure TcxGridChartSeriesCheckListBox.CreateWnd;
|
|
begin
|
|
inherited;
|
|
RefreshItems;
|
|
end;
|
|
|
|
procedure TcxGridChartSeriesCheckListBox.DragOver(Source: TObject; X, Y: Integer;
|
|
State: TDragState; var Accept: Boolean);
|
|
var
|
|
AItemIndex: Integer;
|
|
begin
|
|
inherited;
|
|
AItemIndex := ItemAtPos(Point(X, Y), True);
|
|
Accept := AItemIndex <> -1;
|
|
if Accept and (Series[AItemIndex] <> FDraggingSeries) then
|
|
begin
|
|
FDraggingSeries.Index := Series[AItemIndex].Index;
|
|
ItemIndex := AItemIndex;
|
|
GridView.DoSeriesPosChanged(FDraggingSeries);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartSeriesCheckListBox.DrawSeriesImage(ACanvas: TcxCanvas;
|
|
const R: TRect; ASeries: TcxGridChartSeries);
|
|
var
|
|
AParams: TcxViewParams;
|
|
begin
|
|
ASeries.Styles.GetValueParams(-1, False, AParams);
|
|
ACanvas.FillRect(R, AParams, cxBordersAll, clWindowText);
|
|
end;
|
|
|
|
function TcxGridChartSeriesCheckListBox.GetInnerCheckListBoxClass: TcxCustomInnerCheckListBoxClass;
|
|
begin
|
|
Result := TcxGridChartSeriesInnerCheckListBox;
|
|
end;
|
|
|
|
procedure TcxGridChartSeriesCheckListBox.LookAndFeelChanged(Sender: TcxLookAndFeel;
|
|
AChangedValues: TcxLookAndFeelValues);
|
|
begin
|
|
inherited;
|
|
RefreshImages;
|
|
end;
|
|
|
|
procedure TcxGridChartSeriesCheckListBox.RefreshImages;
|
|
begin
|
|
if SeriesImages = nil then Exit;
|
|
Images := nil;
|
|
RefreshSeriesImages;
|
|
Images := SeriesImages;
|
|
end;
|
|
|
|
procedure TcxGridChartSeriesCheckListBox.RefreshSeriesImages;
|
|
var
|
|
AImage: TBitmap;
|
|
AImageCanvas: TcxCanvas;
|
|
I: Integer;
|
|
begin
|
|
SeriesImages.Clear;
|
|
SeriesImages.Masked := False;
|
|
SeriesImages.Width := TcxGridChartSeriesInnerCheckListBox(InnerCheckListBox).GetSeriesImageSize;
|
|
SeriesImages.Height := SeriesImages.Width;
|
|
|
|
AImage := TBitmap.Create;
|
|
AImageCanvas := TcxCanvas.Create(AImage.Canvas);
|
|
try
|
|
AImage.Width := SeriesImages.Width;
|
|
AImage.Height := SeriesImages.Height;
|
|
for I := 0 to Items.Count - 1 do
|
|
begin
|
|
DrawSeriesImage(AImageCanvas, Rect(0, 0, AImage.Width, AImage.Height), Series[I]);
|
|
SeriesImages.Add(AImage, nil);
|
|
end;
|
|
finally
|
|
AImageCanvas.Free;
|
|
AImage.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartSeriesCheckListBox.RefreshItems;
|
|
var
|
|
I: Integer;
|
|
ASeries: TcxGridChartSeries;
|
|
begin
|
|
if LockRefreshItems then
|
|
Exit;
|
|
with Items do
|
|
begin
|
|
BeginUpdate;
|
|
try
|
|
Clear;
|
|
for I := 0 to GridView.SeriesCount - 1 do
|
|
begin
|
|
ASeries := GridView.Series[I];
|
|
if ASeries.VisibleForCustomization then
|
|
with Add do
|
|
begin
|
|
ItemObject := ASeries;
|
|
Text := ASeries.GetDisplayText;
|
|
Checked := ASeries.Visible;
|
|
ImageIndex := Index;
|
|
end;
|
|
end;
|
|
RefreshImages;
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartSeriesCheckListBox.StartDrag(DragObject: TDragObject): Boolean;
|
|
var
|
|
AItemIndex: Integer;
|
|
begin
|
|
Result := inherited StartDrag(DragObject);
|
|
if Result then
|
|
begin
|
|
AItemIndex := ItemAtPos(ScreenToClient(GetMouseCursorPos), True);
|
|
Result := AItemIndex <> -1;
|
|
if Result then
|
|
FDraggingSeries := Series[AItemIndex];
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartSortBySeriesComboBox }
|
|
|
|
constructor TcxGridChartSortBySeriesComboBox.Create(AOwner: TComponent;
|
|
AGridView: TcxGridChartView);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FGridView := AGridView;
|
|
Properties.DropDownListStyle := lsFixedList;
|
|
FDirectionButton := Properties.Buttons.Add;
|
|
FDirectionButton.Kind := bkGlyph;
|
|
Properties.OnDrawItem := DrawItem;
|
|
Properties.OnMeasureItem := MeasureItem;
|
|
Style.LookAndFeel.MasterLookAndFeel := GridView.LookAndFeel;
|
|
Style.HotTrack := False;
|
|
RefreshItems;
|
|
end;
|
|
|
|
procedure TcxGridChartSortBySeriesComboBox.Click;
|
|
begin
|
|
GridView.SortedSeries := TcxGridChartSeries(ItemObject);
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartSortBySeriesComboBox.DirectionButtonClick;
|
|
begin
|
|
with GridView.SortedSeries do
|
|
if SortOrder = soAscending then
|
|
SortOrder := soDescending
|
|
else
|
|
SortOrder := soAscending;
|
|
end;
|
|
|
|
procedure TcxGridChartSortBySeriesComboBox.DoButtonClick(AButtonVisibleIndex: Integer);
|
|
begin
|
|
if AButtonVisibleIndex = DirectionButton.Index then
|
|
DirectionButtonClick;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartSortBySeriesComboBox.DrawItem(AControl: TcxCustomComboBox;
|
|
ACanvas: TcxCanvas; AIndex: Integer; const ARect: TRect; AState: TOwnerDrawState);
|
|
|
|
function GetKeyBounds: TRect;
|
|
const
|
|
KeyOffset = 1;
|
|
var
|
|
AKeySize: Integer;
|
|
begin
|
|
Result := ARect;
|
|
AKeySize := ACanvas.TextHeight('Qq') - 2 * KeyOffset;
|
|
with Result do
|
|
begin
|
|
InflateRect(Result, -(cxTextOffset + KeyOffset), -(Bottom - Top - AKeySize) div 2);
|
|
Right := Left + AKeySize;
|
|
end;
|
|
end;
|
|
|
|
var
|
|
ASeries: TcxGridChartSeries;
|
|
AParams: TcxViewParams;
|
|
ABrushColor: TColor;
|
|
ATextRect: TRect;
|
|
begin
|
|
ASeries := TcxGridChartSeries(Properties.Items.Objects[AIndex]);
|
|
if ASeries <> nil then
|
|
begin
|
|
ASeries.Styles.GetValueParams(-1, False, AParams);
|
|
ABrushColor := ACanvas.Brush.Color;
|
|
ACanvas.FillRect(GetKeyBounds, AParams, cxBordersAll, clWindowText, 1, True);
|
|
ACanvas.Brush.Color := ABrushColor;
|
|
end;
|
|
|
|
ACanvas.FillRect(ARect);
|
|
|
|
ATextRect := ARect;
|
|
ATextRect.Left := GetKeyBounds.Right + 2 * cxTextOffset;
|
|
ACanvas.DrawText(Properties.Items[AIndex], ATextRect,
|
|
cxSingleLine or cxAlignVCenter or cxShowEndEllipsis);
|
|
end;
|
|
|
|
procedure TcxGridChartSortBySeriesComboBox.MeasureItem(AControl: TcxCustomComboBox;
|
|
AIndex: Integer; ACanvas: TcxCanvas; var AHeight: Integer);
|
|
begin
|
|
Inc(AHeight, 2 * cxTextOffset);
|
|
end;
|
|
|
|
procedure TcxGridChartSortBySeriesComboBox.RefreshDirectionButton;
|
|
const
|
|
GlyphWidth = 13;
|
|
GlyphHeight = 13;
|
|
LineSize = 1;
|
|
LineOffset = 1;
|
|
LineChange = LineSize + LineOffset;
|
|
var
|
|
ASortOrder: TcxDataSortOrder;
|
|
R: TRect;
|
|
I: Integer;
|
|
begin
|
|
if GridView.SortedSeries = nil then
|
|
ASortOrder := soNone
|
|
else
|
|
ASortOrder := GridView.SortedSeries.SortOrder;
|
|
DirectionButton.Visible := ASortOrder <> soNone;
|
|
if not DirectionButton.Visible then Exit;
|
|
|
|
with DirectionButton.Glyph do
|
|
begin
|
|
Width := GlyphWidth;
|
|
Height := GlyphHeight;
|
|
|
|
Canvas.Brush.Color := clRed;
|
|
Canvas.FillRect(Rect(0, 0, GlyphWidth, GlyphHeight));
|
|
|
|
R := Rect(0, LineOffset, 0, LineOffset + LineSize);
|
|
if ASortOrder = soAscending then
|
|
R.Right := LineOffset + LineChange
|
|
else
|
|
R.Right := GlyphWidth;
|
|
Canvas.Brush.Color := clBtnText;
|
|
for I := 0 to GlyphHeight div LineChange - 1 do
|
|
begin
|
|
Canvas.FillRect(R);
|
|
if ASortOrder = soAscending then
|
|
Inc(R.Right, LineChange)
|
|
else
|
|
Dec(R.Right, LineChange);
|
|
OffsetRect(R, 0, LineChange);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartSortBySeriesComboBox.RefreshItems;
|
|
var
|
|
I: Integer;
|
|
ASeries: TcxGridChartSeries;
|
|
begin
|
|
with Properties.Items do
|
|
begin
|
|
BeginUpdate;
|
|
try
|
|
Clear;
|
|
Add(cxGetResourceString(@scxGridChartCustomizationFormNoSortedSeries));
|
|
for I := 0 to GridView.SeriesCount - 1 do
|
|
begin
|
|
ASeries := GridView.Series[I];
|
|
if ASeries.VisibleForCustomization then
|
|
AddObject(ASeries.GetDisplayText, ASeries);
|
|
end;
|
|
ItemObject := GridView.SortedSeries;
|
|
RefreshDirectionButton;
|
|
Properties.DropDownRows := Count;
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartDataGroupsListBox }
|
|
|
|
function TcxGridChartDataGroupsListBox.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
function TcxGridChartDataGroupsListBox.CalculateItemHeight: Integer;
|
|
begin
|
|
Result :=
|
|
2 * (LookAndFeelPainter.ChartToolBoxDataLevelInfoBorderSize + cxTextOffset) +
|
|
Canvas.TextHeight('Qq');
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroupsListBox.DoRefreshItems;
|
|
var
|
|
I: Integer;
|
|
AItem: TcxGridChartDataGroup;
|
|
begin
|
|
inherited;
|
|
with Items do
|
|
begin
|
|
BeginUpdate;
|
|
try
|
|
Clear;
|
|
for I := 0 to GridView.DataGroupCount - 1 do
|
|
begin
|
|
AItem := GridView.DataGroups[I];
|
|
if AItem.VisibleForCustomization and not AItem.Visible then
|
|
AddObject(AItem.GetDisplayText, AItem);
|
|
end;
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartDataGroupsListBox.GetDragAndDropParams: TcxCustomGridHitTest;
|
|
begin
|
|
Result := TcxGridChartDataLevelInfoHitTest.Instance(Point(-1, -1));
|
|
with TcxGridChartDataLevelInfoHitTest(Result) do
|
|
begin
|
|
GridView := Self.GridView;
|
|
DataLevelObject := TcxGridChartDataGroup(DragAndDropItem);
|
|
DataLevelObjectContainerKind := ckCustomizationForm;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroupsListBox.PaintItem(ACanvas: TcxCanvas; R: TRect;
|
|
AIndex: Integer; AFocused: Boolean);
|
|
var
|
|
ABorderSize: Integer;
|
|
AParams: TcxViewParams;
|
|
begin
|
|
ABorderSize := LookAndFeelPainter.ChartToolBoxDataLevelInfoBorderSize;
|
|
if AFocused then
|
|
GridView.Styles.GetViewParams(vsActiveDataLevelInfo, nil, nil, AParams)
|
|
else
|
|
GridView.Styles.GetViewParams(vsDataLevelsInfo, nil, nil, AParams);
|
|
with ACanvas do
|
|
begin
|
|
FillRect(R, AParams, cxBordersAll,
|
|
LookAndFeelPainter.DefaultChartToolBoxDataLevelInfoBorderColor,
|
|
ABorderSize);
|
|
InflateRect(R, -(ABorderSize + cxTextOffset), -(ABorderSize + cxTextOffset));
|
|
Brush.Style := bsClear;
|
|
Font.Color := AParams.TextColor;
|
|
DrawText(Items[AIndex], R, cxSingleLine or cxShowEndEllipsis);
|
|
Brush.Style := bsSolid;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartOptionsTreeView }
|
|
|
|
constructor TcxGridChartOptionsTreeView.Create(AOwner: TComponent; AGridView: TcxGridChartView);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FGridView := AGridView;
|
|
Style.LookAndFeel.MasterLookAndFeel := GridView.LookAndFeel;
|
|
Style.HotTrack := False;
|
|
end;
|
|
|
|
function GetChartPartPositionItemCaption(ATypeItem: Integer): string;
|
|
begin
|
|
Result := '';
|
|
case TcxGridChartPartPosition(ATypeItem) of
|
|
cppDefault:
|
|
Result := cxGetResourceString(@scxGridChartPositionDefault);
|
|
cppNone:
|
|
Result := cxGetResourceString(@scxGridChartPositionNone);
|
|
cppLeft:
|
|
Result := cxGetResourceString(@scxGridChartPositionLeft);
|
|
cppTop:
|
|
Result := cxGetResourceString(@scxGridChartPositionTop);
|
|
cppRight:
|
|
Result := cxGetResourceString(@scxGridChartPositionRight);
|
|
cppBottom:
|
|
Result := cxGetResourceString(@scxGridChartPositionBottom);
|
|
end;
|
|
end;
|
|
|
|
function GetChartPartAlignmentItemCaption(ATypeItem: Integer): string;
|
|
begin
|
|
Result := '';
|
|
case TcxGridChartPartAlignment(ATypeItem) of
|
|
cpaDefault:
|
|
Result := cxGetResourceString(@scxGridChartAlignmentDefault);
|
|
cpaStart:
|
|
Result := cxGetResourceString(@scxGridChartAlignmentStart);
|
|
cpaCenter:
|
|
Result := cxGetResourceString(@scxGridChartAlignmentCenter);
|
|
cpaEnd:
|
|
Result := cxGetResourceString(@scxGridChartAlignmentEnd);
|
|
end;
|
|
end;
|
|
|
|
function GetChartPartOrientationItemCaption(ATypeItem: Integer): string;
|
|
begin
|
|
Result := '';
|
|
case TcxGridChartPartOrientation(ATypeItem) of
|
|
cpoDefault:
|
|
Result := cxGetResourceString(@scxGridChartOrientationDefault);
|
|
cpoHorizontal:
|
|
Result := cxGetResourceString(@scxGridChartOrientationHorizontal);
|
|
cpoVertical:
|
|
Result := cxGetResourceString(@scxGridChartOrientationVertical);
|
|
end;
|
|
end;
|
|
|
|
function GetChartToolBoxPositionItemCaption(ATypeItem: Integer): string;
|
|
begin
|
|
Result := '';
|
|
case TcxGridChartToolBoxPosition(ATypeItem) of
|
|
tpTop:
|
|
Result := cxGetResourceString(@scxGridChartPositionTop);
|
|
tpBottom:
|
|
Result := cxGetResourceString(@scxGridChartPositionBottom);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartOptionsTreeView.AddItems;
|
|
begin
|
|
// Legend
|
|
LegendID := AddCategory(-1, -1, cxGetResourceString(@scxGridChartLegend));
|
|
LegendPositionID := AddCategory(LegendID, -1, cxGetResourceString(@scxGridChartPosition));
|
|
AddRadioButtons(LegendPositionID, TypeInfo(TcxGridChartPartPosition), @GetChartPartPositionItemCaption);
|
|
LegendAlignmentID := AddCategory(LegendID, -1, cxGetResourceString(@scxGridChartAlignment));
|
|
AddRadioButtons(LegendAlignmentID, TypeInfo(TcxGridChartPartAlignment), @GetChartPartAlignmentItemCaption);
|
|
LegendOrientationID := AddCategory(LegendID, -1, cxGetResourceString(@scxGridChartOrientation));
|
|
AddRadioButtons(LegendOrientationID, TypeInfo(TcxGridChartPartOrientation), @GetChartPartOrientationItemCaption);
|
|
LegendBorderID := AddCheckBox(LegendID, -1, cxGetResourceString(@scxGridChartBorder));
|
|
LegendKeyBorderID := AddCheckBox(LegendID, -1, cxGetResourceString(@scxGridChartLegendKeyBorder));
|
|
// Title
|
|
TitleID := AddCategory(-1, -1, cxGetResourceString(@scxGridChartTitle));
|
|
TitlePositionID := AddCategory(TitleID, -1, cxGetResourceString(@scxGridChartPosition));
|
|
AddRadioButtons(TitlePositionID, TypeInfo(TcxGridChartPartPosition), @GetChartPartPositionItemCaption);
|
|
TitleAlignmentID := AddCategory(TitleID, -1, cxGetResourceString(@scxGridChartAlignment));
|
|
AddRadioButtons(TitleAlignmentID, TypeInfo(TcxGridChartPartAlignment), @GetChartPartAlignmentItemCaption);
|
|
// ToolBox
|
|
ToolBoxID := AddCategory(-1, -1, cxGetResourceString(@scxGridChartToolBox));
|
|
ToolBoxPositionID := AddCategory(ToolBoxID, -1, cxGetResourceString(@scxGridChartPosition));
|
|
AddRadioButtons(ToolBoxPositionID, TypeInfo(TcxGridChartToolBoxPosition), @GetChartToolBoxPositionItemCaption);
|
|
ToolBoxBorderID := AddCheckBox(ToolBoxID, -1, cxGetResourceString(@scxGridChartBorder));
|
|
ToolBoxDiagramSelectorID := AddCheckBox(ToolBoxID, -1, cxGetResourceString(@scxGridChartDiagramSelector));
|
|
// Other
|
|
OtherID := AddCategory(-1, -1, cxGetResourceString(@scxGridChartOther));
|
|
OtherValueHintsID := AddCheckBox(OtherID, -1, cxGetResourceString(@scxGridChartValueHints));
|
|
end;
|
|
|
|
function TcxGridChartOptionsTreeView.IsItemChecked(AParentID, AID: Integer): Boolean;
|
|
begin
|
|
Result := False;
|
|
// Legend
|
|
if AParentID = LegendAlignmentID then
|
|
Result := Ord(GridView.ActiveDiagram.Legend.Alignment) = AID;
|
|
if AID = LegendBorderID then
|
|
Result := GridView.ActiveDiagram.Legend.GetBorder = lbSingle;
|
|
if AID = LegendKeyBorderID then
|
|
Result := GridView.ActiveDiagram.Legend.GetKeyBorder = lbSingle;
|
|
if AParentID = LegendOrientationID then
|
|
Result := Ord(GridView.ActiveDiagram.Legend.Orientation) = AID;
|
|
if AParentID = LegendPositionID then
|
|
Result := Ord(GridView.ActiveDiagram.Legend.Position) = AID;
|
|
// Title
|
|
if AParentID = TitleAlignmentID then
|
|
Result := Ord(GridView.Title.Alignment) = AID;
|
|
if AParentID = TitlePositionID then
|
|
Result := Ord(GridView.Title.Position) = AID;
|
|
// ToolBox
|
|
if AID = ToolBoxBorderID then
|
|
Result := GridView.ToolBox.Border = tbSingle;
|
|
if AID = ToolBoxDiagramSelectorID then
|
|
Result := GridView.ToolBox.DiagramSelector;
|
|
if AParentID = ToolBoxPositionID then
|
|
Result := Ord(GridView.ToolBox.Position) = AID;
|
|
// Other
|
|
if AID = OtherValueHintsID then
|
|
Result := GridView.OptionsBehavior.ValueHints;
|
|
end;
|
|
|
|
procedure TcxGridChartOptionsTreeView.ItemClicked(AParentID, AID: Integer);
|
|
begin
|
|
// Legend
|
|
if AParentID = LegendAlignmentID then
|
|
GridView.ActiveDiagram.Legend.Alignment := TcxGridChartPartAlignment(AID);
|
|
if AID = LegendBorderID then
|
|
with GridView.ActiveDiagram.Legend do
|
|
if GetBorder = lbNone then
|
|
Border := lbSingle
|
|
else
|
|
Border := lbNone;
|
|
if AID = LegendKeyBorderID then
|
|
with GridView.ActiveDiagram.Legend do
|
|
if GetKeyBorder = lbNone then
|
|
KeyBorder := lbSingle
|
|
else
|
|
KeyBorder := lbNone;
|
|
if AParentID = LegendOrientationID then
|
|
GridView.ActiveDiagram.Legend.Orientation := TcxGridChartPartOrientation(AID);
|
|
if AParentID = LegendPositionID then
|
|
GridView.ActiveDiagram.Legend.Position := TcxGridChartPartPosition(AID);
|
|
// Title
|
|
if AParentID = TitleAlignmentID then
|
|
GridView.Title.Alignment := TcxGridChartPartAlignment(AID);
|
|
if AParentID = TitlePositionID then
|
|
GridView.Title.Position := TcxGridChartPartPosition(AID);
|
|
// ToolBox
|
|
if AID = ToolBoxBorderID then
|
|
with GridView.ToolBox do
|
|
if Border = tbNone then
|
|
Border := tbSingle
|
|
else
|
|
Border := tbNone;
|
|
if AID = ToolBoxDiagramSelectorID then
|
|
with GridView.ToolBox do
|
|
DiagramSelector := not DiagramSelector;
|
|
if AParentID = ToolBoxPositionID then
|
|
GridView.ToolBox.Position := TcxGridChartToolBoxPosition(AID);
|
|
// Other
|
|
if AID = OtherValueHintsID then
|
|
with GridView.OptionsBehavior do
|
|
ValueHints := not ValueHints;
|
|
end;
|
|
|
|
{ TcxGridChartCustomizationForm }
|
|
|
|
function TcxGridChartCustomizationForm.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
function TcxGridChartCustomizationForm.CanChangeSortedSeries: Boolean;
|
|
begin
|
|
Result := (GridView.SortedSeries = nil) or GridView.SortedSeries.VisibleForCustomization;
|
|
end;
|
|
|
|
procedure TcxGridChartCustomizationForm.CreateControls;
|
|
begin
|
|
inherited;
|
|
// Series
|
|
FSeriesCheckListBox := GetSeriesCheckListBoxClass.Create(Self, GridView);
|
|
with FSeriesCheckListBox do
|
|
begin
|
|
Align := alClient;
|
|
Parent := FSeriesPage;
|
|
end;
|
|
FSortBySeriesLabel := TcxLabel.Create(Self);
|
|
with FSortBySeriesLabel do
|
|
begin
|
|
Align := alBottom;
|
|
Caption := cxGetResourceString(@scxGridChartCustomizationFormSortBySeries);
|
|
Style.LookAndFeel.MasterLookAndFeel := GridView.LookAndFeel;
|
|
Transparent := True;
|
|
Visible := CanChangeSortedSeries;
|
|
Parent := FSeriesPage;
|
|
end;
|
|
FSortBySeriesComboBox := GetSortBySeriesComboBoxClass.Create(Self, GridView);
|
|
with FSortBySeriesComboBox do
|
|
begin
|
|
Align := alBottom;
|
|
Visible := CanChangeSortedSeries;
|
|
Parent := FSeriesPage;
|
|
end;
|
|
// Data Groups
|
|
FDataGroupsListBox := GetDataGroupsListBoxClass.Create(Self);
|
|
with FDataGroupsListBox do
|
|
begin
|
|
Align := alClient;
|
|
Parent := FDataGroupsPage;
|
|
RefreshItems;
|
|
end;
|
|
// Options
|
|
FOptionsTreeView := GetOptionsTreeViewClass.Create(Self, GridView);
|
|
with FOptionsTreeView do
|
|
begin
|
|
Align := alClient;
|
|
Parent := FOptionsPage;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartCustomizationForm.GetDataGroupsListBoxClass: TcxGridChartDataGroupsListBoxClass;
|
|
begin
|
|
Result := TcxGridChartDataGroupsListBox;
|
|
end;
|
|
|
|
function TcxGridChartCustomizationForm.GetDataGroupsPageVisible: Boolean;
|
|
begin
|
|
Result := GridView.OptionsCustomize.DataGroupMoving and
|
|
(GridView.ToolBox.DataLevelsInfoVisible <> dlivNever);
|
|
end;
|
|
|
|
function TcxGridChartCustomizationForm.GetOptionsPageVisible: Boolean;
|
|
begin
|
|
Result := GridView.OptionsCustomize.OptionsCustomization;
|
|
end;
|
|
|
|
function TcxGridChartCustomizationForm.GetOptionsTreeViewClass: TcxGridChartOptionsTreeViewClass;
|
|
begin
|
|
Result := TcxGridChartOptionsTreeView;
|
|
end;
|
|
|
|
function TcxGridChartCustomizationForm.GetSeriesCheckListBoxClass: TcxGridChartSeriesCheckListBoxClass;
|
|
begin
|
|
Result := TcxGridChartSeriesCheckListBox;
|
|
end;
|
|
|
|
function TcxGridChartCustomizationForm.GetSeriesPageVisible: Boolean;
|
|
begin
|
|
Result := GridView.OptionsCustomize.SeriesCustomization;
|
|
end;
|
|
|
|
function TcxGridChartCustomizationForm.GetSortBySeriesComboBoxClass: TcxGridChartSortBySeriesComboBoxClass;
|
|
begin
|
|
Result := TcxGridChartSortBySeriesComboBox;
|
|
end;
|
|
|
|
procedure TcxGridChartCustomizationForm.GridViewChanged;
|
|
begin
|
|
inherited;
|
|
OptionsTreeView.RefreshItemValues;
|
|
end;
|
|
|
|
procedure TcxGridChartCustomizationForm.InitPageControl;
|
|
begin
|
|
inherited;
|
|
FSeriesPage := CreatePage(
|
|
cxGetResourceString(@scxGridChartCustomizationFormSeriesPageCaption),
|
|
GetSeriesPageVisible);
|
|
FDataGroupsPage := CreatePage(
|
|
cxGetResourceString(@scxGridChartCustomizationFormDataGroupsPageCaption),
|
|
GetDataGroupsPageVisible);
|
|
FOptionsPage := CreatePage(
|
|
cxGetResourceString(@scxGridChartCustomizationFormOptionsPageCaption),
|
|
GetOptionsPageVisible);
|
|
end;
|
|
|
|
procedure TcxGridChartCustomizationForm.PrepareForDataGroupDragAndDrop;
|
|
begin
|
|
ActivatePage(DataGroupsPage);
|
|
end;
|
|
|
|
procedure TcxGridChartCustomizationForm.RefreshData;
|
|
begin
|
|
inherited;
|
|
SeriesCheckListBox.RefreshItems;
|
|
SortBySeriesComboBox.RefreshItems;
|
|
DataGroupsListBox.RefreshItems;
|
|
end;
|
|
|
|
{ TcxGridChartDataLevelActiveValuePopup }
|
|
|
|
constructor TcxGridChartDataLevelActiveValuePopup.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited;
|
|
FListBox := TcxGridPopupListBox.Create(Self);
|
|
FListBox.OnAction := ListBoxAction;
|
|
end;
|
|
|
|
function TcxGridChartDataLevelActiveValuePopup.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
procedure TcxGridChartDataLevelActiveValuePopup.ListBoxAction(Sender: TcxGridPopupListBox;
|
|
AItemIndex: Integer);
|
|
begin
|
|
SetDataGroupActiveValue(AItemIndex);
|
|
end;
|
|
|
|
procedure TcxGridChartDataLevelActiveValuePopup.AddValueItems(AStrings: TStrings;
|
|
out AValues: TVariantArray);
|
|
begin
|
|
GridView.ViewData.GetVisibleGroupValues(FDataGroup, AStrings, AValues);
|
|
end;
|
|
|
|
procedure TcxGridChartDataLevelActiveValuePopup.AdjustListBoxSize;
|
|
begin
|
|
FListBox.VisibleItemCount := GridView.ToolBox.DataLevelActiveValueDropDownCount;
|
|
FListBox.VisibleWidth := GridView.ToolBox.DataLevelActiveValueDropDownWidth;
|
|
FListBox.AdjustBounds;
|
|
end;
|
|
|
|
procedure TcxGridChartDataLevelActiveValuePopup.InitPopup;
|
|
begin
|
|
FDataGroup := (Owner as IcxGridChartDataLevelActiveValuePopupOwner).GetDataGroup;
|
|
inherited;
|
|
AddValueItems(FListBox.Items, Values);
|
|
AdjustListBoxSize;
|
|
FListBox.ItemIndex := VarIndex(Values, FDataGroup.ActiveValue);
|
|
end;
|
|
|
|
procedure TcxGridChartDataLevelActiveValuePopup.SetDataGroupActiveValue(AItemIndex: Integer);
|
|
begin
|
|
GridView.BeginUpdate;
|
|
try
|
|
FDataGroup.ActiveValue := Values[AItemIndex];
|
|
if FDataGroup.DataLevel >= GridView.ActiveDataLevel then
|
|
GridView.ActiveDataLevel := FDataGroup.DataLevel + 1;
|
|
finally
|
|
GridView.EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartDiagramSelectorPopupListBox }
|
|
|
|
function TcxGridChartDiagramSelectorPopupListBox.CalculateItemHeight: Integer;
|
|
begin
|
|
Result := Max(inherited CalculateItemHeight,
|
|
cxGridChartDiagramImages.Height + 2 * cxTextOffset);
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramSelectorPopupListBox.DrawItemContent(ACanvas: TcxCanvas;
|
|
AIndex: Integer; ARect: TRect; AState: TOwnerDrawState);
|
|
begin
|
|
inherited;
|
|
cxGridChartDiagramImages.Draw(ACanvas.Canvas,
|
|
ARect.Left + TcxGridChartDiagramSelectorPopup(Popup).ImageOffset,
|
|
(ARect.Top + ARect.Bottom - cxGridChartDiagramImages.Height) div 2,
|
|
TcxGridChartDiagram(Items.Objects[AIndex]).ImageIndex);
|
|
end;
|
|
|
|
{ TcxGridChartDiagramSelectorPopup }
|
|
|
|
constructor TcxGridChartDiagramSelectorPopup.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited;
|
|
FListBox := TcxGridChartDiagramSelectorPopupListBox.Create(Self);
|
|
FListBox.OnAction := ListBoxAction;
|
|
end;
|
|
|
|
function TcxGridChartDiagramSelectorPopup.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramSelectorPopup.ListBoxAction(Sender: TcxGridPopupListBox;
|
|
AItemIndex: Integer);
|
|
begin
|
|
SelectDiagram(AItemIndex);
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramSelectorPopup.AddDiagramItems(AStrings: TStrings);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
AStrings.BeginUpdate;
|
|
try
|
|
AStrings.Clear;
|
|
for I := 0 to GridView.AvailableDiagramCount - 1 do
|
|
AStrings.AddObject(GridView.AvailableDiagrams[I].DisplayText,
|
|
GridView.AvailableDiagrams[I]);
|
|
finally
|
|
AStrings.EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartDiagramSelectorPopup.GetImageOffset: Integer;
|
|
begin
|
|
Result := cxTextOffset;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramSelectorPopup.InitPopup;
|
|
begin
|
|
inherited;
|
|
FListBox.ItemTextOffsetLeft := ImageOffset + cxGridChartDiagramImages.Width +
|
|
ToolBoxDiagramImageOffset + cxTextOffset;
|
|
FListBox.ItemTextOffsetVert := cxTextOffset;
|
|
AddDiagramItems(FListBox.Items);
|
|
FListBox.AdjustBounds;
|
|
FListBox.ItemObject := GridView.ActiveDiagram;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramSelectorPopup.SelectDiagram(AItemIndex: Integer);
|
|
var
|
|
ADiagram: TcxGridChartDiagram;
|
|
begin
|
|
ADiagram := TcxGridChartDiagram(FListBox.Items.Objects[AItemIndex]);
|
|
ADiagram.Active := True;
|
|
if GridView.IsDesigning then
|
|
begin
|
|
GridView.Controller.DesignController.SelectObject(ADiagram, True);
|
|
GridView.Controller.DesignerModified;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartController }
|
|
|
|
constructor TcxGridChartController.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited;
|
|
DataLevelsChanged;
|
|
end;
|
|
|
|
destructor TcxGridChartController.Destroy;
|
|
begin
|
|
FDataLevelActiveValuePopup.Free;
|
|
FDiagramSelectorPopup.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartController.GetCustomizationForm: TcxGridChartCustomizationForm;
|
|
begin
|
|
Result := TcxGridChartCustomizationForm(inherited CustomizationForm);
|
|
end;
|
|
|
|
function TcxGridChartController.GetDataLevelActiveValuePopup: TcxGridChartDataLevelActiveValuePopup;
|
|
begin
|
|
if FDataLevelActiveValuePopup = nil then
|
|
FDataLevelActiveValuePopup := GetDataLevelActiveValuePopupClass.Create(GridView);
|
|
Result := FDataLevelActiveValuePopup;
|
|
end;
|
|
|
|
function TcxGridChartController.GetDiagramSelectorPopup: TcxGridChartDiagramSelectorPopup;
|
|
begin
|
|
if FDiagramSelectorPopup = nil then
|
|
FDiagramSelectorPopup := GetDiagramSelectorPopupClass.Create(GridView);
|
|
Result := FDiagramSelectorPopup;
|
|
end;
|
|
|
|
function TcxGridChartController.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
function TcxGridChartController.GetIsDataGroupMoving: Boolean;
|
|
begin
|
|
Result := FMovingDataGroup <> nil;
|
|
end;
|
|
|
|
function TcxGridChartController.GetViewInfo: TcxGridChartViewInfo;
|
|
begin
|
|
Result := TcxGridChartViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
function TcxGridChartController.GetVisibleCategoryCountValue: Integer;
|
|
begin
|
|
Result := GetVisibleCategoryCount(False);
|
|
end;
|
|
|
|
procedure TcxGridChartController.SetFirstVisibleCategoryIndex(Value: Integer);
|
|
begin
|
|
if GridView.IsUpdateLocked then
|
|
Value := 0
|
|
else
|
|
begin
|
|
Value := Max(Value, 0);
|
|
Value := Min(Value, GridView.ViewData.VisibleCategoryCount - VisibleCategoryCount);
|
|
end;
|
|
if FFirstVisibleCategoryIndex <> Value then
|
|
begin
|
|
FFirstVisibleCategoryIndex := Value;
|
|
GridView.LayoutChanged;
|
|
FirstVisibleCategoryIndexChanged;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartController.ActiveDataLevelChanged(APrevActiveDataLevel, AActiveDataLevel: Integer);
|
|
begin
|
|
if (0 <= APrevActiveDataLevel) and (APrevActiveDataLevel < GridView.DataLevelCount) then
|
|
FFirstVisibleCategoryIndexes[APrevActiveDataLevel] := FFirstVisibleCategoryIndex;
|
|
if AActiveDataLevel <> -1 then
|
|
if ActiveDiagramSupportsPaging then
|
|
FirstVisibleCategoryIndex := FFirstVisibleCategoryIndexes[AActiveDataLevel]
|
|
else
|
|
FFirstVisibleCategoryIndex := FFirstVisibleCategoryIndexes[AActiveDataLevel];
|
|
end;
|
|
|
|
procedure TcxGridChartController.ActiveDiagramChanged(ADiagram: TcxGridChartDiagram);
|
|
begin
|
|
FirstVisibleCategoryIndexChanged;
|
|
end;
|
|
|
|
procedure TcxGridChartController.CheckCoordinates;
|
|
begin
|
|
inherited;
|
|
if ActiveDiagramSupportsPaging then
|
|
FirstVisibleCategoryIndex := FirstVisibleCategoryIndex;
|
|
end;
|
|
|
|
procedure TcxGridChartController.DataLevelsChanged;
|
|
begin
|
|
FFirstVisibleCategoryIndexes := nil;
|
|
SetLength(FFirstVisibleCategoryIndexes, GridView.DataLevelCount);
|
|
end;
|
|
|
|
procedure TcxGridChartController.FirstVisibleCategoryIndexChanged;
|
|
begin
|
|
if FStoredFirstVisibleCategoryIndex <> FirstVisibleCategoryIndex then
|
|
begin
|
|
FStoredFirstVisibleCategoryIndex := FirstVisibleCategoryIndex;
|
|
GridView.DoFirstVisibleCategoryIndexChanged;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartController.GetDataLevelActiveValuePopupClass: TcxGridChartDataLevelActiveValuePopupClass;
|
|
begin
|
|
Result := TcxGridChartDataLevelActiveValuePopup;
|
|
end;
|
|
|
|
function TcxGridChartController.GetDesignHitTest(AHitTest: TcxCustomGridHitTest): Boolean;
|
|
begin
|
|
Result := inherited GetDesignHitTest(AHitTest);
|
|
if not Result then
|
|
Result := AHitTest.HitTestCode in [htLegendItem, htDataLevelInfo, htDiagramSelector,
|
|
htChartValue, htChartValueLine, htChartValueArea, htSeriesSite, htSeriesSiteCaption];
|
|
end;
|
|
|
|
function TcxGridChartController.GetDiagramSelectorPopupClass: TcxGridChartDiagramSelectorPopupClass;
|
|
begin
|
|
Result := TcxGridChartDiagramSelectorPopup;
|
|
end;
|
|
|
|
function TcxGridChartController.GetPatternObject(AObject: TPersistent): TPersistent;
|
|
begin
|
|
if AObject is GridView.GetCategoriesClass then
|
|
Result := TcxGridChartView(GridView.PatternGridView).Categories
|
|
else
|
|
if AObject is GridView.GetDataGroupClass then
|
|
Result := TcxGridChartView(GridView.PatternGridView).FindDataGroupByID(TcxGridChartDataGroup(AObject).ID)
|
|
else
|
|
if AObject is GridView.GetSeriesClass then
|
|
Result := TcxGridChartView(GridView.PatternGridView).FindSeriesByID(TcxGridChartSeries(AObject).ID)
|
|
else
|
|
Result := inherited GetPatternObject(AObject);
|
|
end;
|
|
|
|
function TcxGridChartController.GetFirstVisibleCategoryIndex: Integer;
|
|
begin
|
|
if ActiveDiagramSupportsPaging then
|
|
Result := FFirstVisibleCategoryIndex
|
|
else
|
|
Result := 0;
|
|
end;
|
|
|
|
function TcxGridChartController.GetVisibleCategoryCount(ACheckCount: Boolean): Integer;
|
|
begin
|
|
Result := GridView.ViewData.VisibleCategoryCount;
|
|
if ActiveDiagramSupportsPaging and (GridView.OptionsView.CategoriesPerPage <> 0) then
|
|
begin
|
|
Result := Min(Result, GridView.OptionsView.CategoriesPerPage);
|
|
if ACheckCount then
|
|
Result := Min(Result, Max(0, GridView.ViewData.VisibleCategoryCount - FirstVisibleCategoryIndex));
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartController.CanDataDrillDown(AValueIndex: Integer): Boolean;
|
|
begin
|
|
Result := GridView.ActiveDataLevel < GridView.DataLevelCount - 1;
|
|
end;
|
|
|
|
function TcxGridChartController.CanDataDrillUp: Boolean;
|
|
begin
|
|
Result := GridView.ActiveDataLevel > 0;
|
|
end;
|
|
|
|
function TcxGridChartController.DoDataDrillDown(AValueIndex: Integer): Boolean;
|
|
begin
|
|
Result := MayDataDrillDown and DataDrillDown(AValueIndex);
|
|
end;
|
|
|
|
function TcxGridChartController.DoDataDrillUp: Boolean;
|
|
begin
|
|
Result := MayDataDrillDown and DataDrillUp;
|
|
end;
|
|
|
|
function TcxGridChartController.MayDataDrillDown(ACheckDesignTime: Boolean = True): Boolean;
|
|
begin
|
|
Result := (not ACheckDesignTime or not GridView.IsDesigning) and
|
|
GridView.OptionsCustomize.DataDrillDown;
|
|
end;
|
|
|
|
function TcxGridChartController.CanShowScrollBar: Boolean;
|
|
begin
|
|
Result := ActiveDiagramSupportsPaging;
|
|
end;
|
|
|
|
function TcxGridChartController.GetScrollBarKind: TScrollBarKind;
|
|
begin
|
|
if GridView.ActiveDiagram.HorizontalPaging then
|
|
Result := sbHorizontal
|
|
else
|
|
Result := sbVertical;
|
|
end;
|
|
|
|
function TcxGridChartController.GetScrollBarPageSize: Integer;
|
|
begin
|
|
Result := VisibleCategoryCount;
|
|
end;
|
|
|
|
function TcxGridChartController.GetScrollBarPos: Integer;
|
|
begin
|
|
Result := ScrollPosToCategoryIndex(FirstVisibleCategoryIndex);
|
|
end;
|
|
|
|
function TcxGridChartController.GetScrollBarSize: Integer;
|
|
begin
|
|
Result := GridView.ViewData.VisibleCategoryCount;
|
|
end;
|
|
|
|
function TcxGridChartController.ScrollPosToCategoryIndex(AScrollPos: Integer): Integer;
|
|
begin
|
|
if GridView.ActiveDiagram.PagingInOppositeDirection then
|
|
Result := GetScrollBarSize - GetScrollBarPageSize - AScrollPos
|
|
else
|
|
Result := AScrollPos;
|
|
end;
|
|
|
|
function TcxGridChartController.CanShowDataLevelActiveValuePopup(ACheckDesignTime: Boolean = True): Boolean;
|
|
begin
|
|
Result := MayDataDrillDown(ACheckDesignTime);
|
|
end;
|
|
|
|
procedure TcxGridChartController.CustomizationChanged;
|
|
begin
|
|
GridView.ViewInfo.ToolBoxViewInfo.InvalidateCustomizeButton;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartController.GetCustomizationFormClass: TcxCustomGridCustomizationFormClass;
|
|
begin
|
|
Result := TcxGridChartCustomizationForm;
|
|
end;
|
|
|
|
function TcxGridChartController.GetCustomizationFormDefaultWidth: Integer;
|
|
begin
|
|
Result := cxGridChartCustomizationFormDefaultWidth;
|
|
end;
|
|
|
|
function TcxGridChartController.GetDataLevelInfoDragAndDropObjectClass: TcxGridChartDataGroupMovingObjectClass;
|
|
begin
|
|
Result := TcxGridChartDataGroupMovingObject;
|
|
end;
|
|
|
|
function TcxGridChartController.HasDataLevelActiveValuePopup: Boolean;
|
|
begin
|
|
Result := FDataLevelActiveValuePopup <> nil;
|
|
end;
|
|
|
|
function TcxGridChartController.HasDiagramSelectorPopup: Boolean;
|
|
begin
|
|
Result := FDiagramSelectorPopup <> nil;
|
|
end;
|
|
|
|
procedure TcxGridChartController.MouseDown(Button: TMouseButton; Shift: TShiftState;
|
|
X, Y: Integer);
|
|
begin
|
|
inherited;
|
|
if (Button = mbRight) and not (ssDouble in Shift) and
|
|
(GridView.OptionsCustomize.DataDrillUpMethod = ddumMouseRightButtonClick) then
|
|
DoDataDrillUp;
|
|
end;
|
|
|
|
procedure TcxGridChartController.InitScrollBarsParameters;
|
|
begin
|
|
if CanShowScrollBar then
|
|
SetScrollBarInfo(GetScrollBarKind, 0, GetScrollBarSize - 1, 1,
|
|
GetScrollBarPageSize, GetScrollBarPos, True, True);
|
|
end;
|
|
|
|
procedure TcxGridChartController.Scroll(AScrollBarKind: TScrollBarKind;
|
|
AScrollCode: TScrollCode; var AScrollPos: Integer);
|
|
var
|
|
ADelta: Integer;
|
|
begin
|
|
if AScrollBarKind <> GetScrollBarKind then Exit;
|
|
ADelta := 0;
|
|
case AScrollCode of
|
|
scLineUp:
|
|
ADelta := -1;
|
|
scLineDown:
|
|
ADelta := 1;
|
|
scPageUp:
|
|
ADelta := -GetScrollBarPageSize;
|
|
scPageDown:
|
|
ADelta := GetScrollBarPageSize;
|
|
scTrack:
|
|
FirstVisibleCategoryIndex := ScrollPosToCategoryIndex(AScrollPos);
|
|
end;
|
|
if ADelta <> 0 then
|
|
begin
|
|
if GridView.ActiveDiagram.PagingInOppositeDirection then
|
|
ADelta := -ADelta;
|
|
FirstVisibleCategoryIndex := FirstVisibleCategoryIndex + ADelta;
|
|
end;
|
|
AScrollPos := GetScrollBarPos;
|
|
end;
|
|
|
|
function TcxGridChartController.GetValueHintText(ASeries: TcxGridChartSeries; AValueIndex: Integer): string;
|
|
begin
|
|
Result := Format(cxGetResourceString(@scxGridChartValueHintFormat),
|
|
[ASeries.GetDisplayText, GridView.Categories.VisibleDisplayTexts[AValueIndex],
|
|
ASeries.VisibleDisplayTexts[AValueIndex]]);
|
|
GridView.DoGetValueHint(ASeries, AValueIndex, Result);
|
|
end;
|
|
|
|
function TcxGridChartController.DataDrillDown(AValueIndex: Integer): Boolean;
|
|
begin
|
|
Result := CanDataDrillDown(AValueIndex);
|
|
if not Result then Exit;
|
|
GridView.BeginUpdate;
|
|
try
|
|
GridView.ActiveDataGroup.ActiveValue := GridView.ActiveDataGroup.VisibleValues[AValueIndex];
|
|
GridView.ActiveDataLevel := GridView.ActiveDataLevel + 1;
|
|
finally
|
|
GridView.EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartController.DataDrillUp: Boolean;
|
|
begin
|
|
Result := CanDataDrillUp;
|
|
if Result then
|
|
GridView.ActiveDataLevel := GridView.ActiveDataLevel - 1;
|
|
end;
|
|
|
|
function TcxGridChartController.IsDataDrillDownPossible(AValueIndex: Integer): Boolean;
|
|
begin
|
|
Result := MayDataDrillDown and CanDataDrillDown(AValueIndex);
|
|
end;
|
|
|
|
function TcxGridChartController.ActiveDiagramSupportsPaging: Boolean;
|
|
begin
|
|
Result := (GridView.ActiveDiagram <> nil) and GridView.ActiveDiagram.SupportsPaging;
|
|
end;
|
|
|
|
{ TcxGridChartDataController }
|
|
|
|
function TcxGridChartDataController.GetGridViewValue: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(GetOwner);
|
|
end;
|
|
|
|
function TcxGridChartDataController.GetOnAfterSummary: TcxAfterSummaryEvent;
|
|
begin
|
|
Result := Summary.OnAfterSummary;
|
|
end;
|
|
|
|
function TcxGridChartDataController.GetOnSummary: TcxSummaryEvent;
|
|
begin
|
|
Result := Summary.DefaultGroupSummaryItems.OnSummary;
|
|
end;
|
|
|
|
procedure TcxGridChartDataController.SetOnAfterSummary(Value: TcxAfterSummaryEvent);
|
|
begin
|
|
Summary.OnAfterSummary := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartDataController.SetOnSummary(Value: TcxSummaryEvent);
|
|
begin
|
|
Summary.DefaultGroupSummaryItems.OnSummary := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartDataController.AssignData(ADataController: TcxCustomDataController);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxGridChartDataController.CreateAllItems(AMissingItemsOnly: Boolean);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxGridChartDataController.DeleteAllItems;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxGridChartDataController.GetFakeComponentLinks(AList: TList);
|
|
begin
|
|
end;
|
|
|
|
function TcxGridChartDataController.GetGridView: TcxCustomGridView;
|
|
begin
|
|
Result := GridView;
|
|
end;
|
|
|
|
function TcxGridChartDataController.HasAllItems: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TcxGridChartDataController.IsDataChangeable: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxGridChartDataController.IsDataLinked: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TcxGridChartDataController.SupportsCreateAllItems: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TcxGridChartDataController.DoValueTypeClassChanged(AItemIndex: Integer);
|
|
var
|
|
AChartItem: IcxGridChartItem;
|
|
begin
|
|
inherited;
|
|
if Supports(GetItem(AItemIndex), IcxGridChartItem, AChartItem) then
|
|
AChartItem.ValueTypeClassChanged;
|
|
end;
|
|
|
|
{function TcxGridChartDataController.GetChartViewItemIndex: Integer;
|
|
begin
|
|
if GridView.SortedSeries = nil then
|
|
Result := -1
|
|
else
|
|
Result := GridView.SortedSeries.DataBinding.DataIndex;
|
|
end;}
|
|
|
|
function TcxGridChartDataController.GetItemID(AItem: TObject): Integer;
|
|
var
|
|
AChartItem: IcxGridChartItem;
|
|
begin
|
|
if Supports(AItem, IcxGridChartItem, AChartItem) then
|
|
Result := AChartItem.GetID
|
|
else
|
|
Result := -1;
|
|
end;
|
|
|
|
function TcxGridChartDataController.GetSortingBySummaryEngineClass: TcxSortingBySummaryEngineClass;
|
|
begin
|
|
Result := GridView.ViewData.GetSortingBySummaryEngineClass;
|
|
end;
|
|
|
|
procedure TcxGridChartDataController.Unlocked;
|
|
begin
|
|
inherited;
|
|
GridView.DataControllerUnlocked;
|
|
end;
|
|
|
|
procedure TcxGridChartDataController.BeginFullUpdate;
|
|
begin
|
|
GridView.BeginUpdate;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartDataController.EndFullUpdate;
|
|
begin
|
|
inherited;
|
|
GridView.EndUpdate;
|
|
end;
|
|
|
|
function TcxGridChartDataController.GetItem(Index: Integer): TObject;
|
|
begin
|
|
Result := Fields[Index].Item;
|
|
end;
|
|
|
|
{ TcxGridChartTitlePainter }
|
|
|
|
function TcxGridChartTitlePainter.GetViewInfo: TcxCustomGridChartTitleViewInfo;
|
|
begin
|
|
Result := TcxCustomGridChartTitleViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
procedure TcxGridChartTitlePainter.PrepareCanvasForDrawText;
|
|
begin
|
|
inherited;
|
|
if ViewInfo.Orientation = cpoVertical then
|
|
Canvas.SetFontAngle(90);
|
|
end;
|
|
|
|
procedure TcxGridChartTitlePainter.UnprepareCanvasForDrawText;
|
|
begin
|
|
if ViewInfo.Orientation = cpoVertical then
|
|
Canvas.SetFontAngle(0);
|
|
inherited;
|
|
end;
|
|
|
|
{ TcxGridChartLegendItemPainter }
|
|
|
|
function TcxGridChartLegendItemPainter.GetViewInfo: TcxGridChartLegendItemViewInfo;
|
|
begin
|
|
Result := TcxGridChartLegendItemViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
procedure TcxGridChartLegendItemPainter.DrawContent;
|
|
begin
|
|
inherited;
|
|
DrawLegendKey;
|
|
end;
|
|
|
|
procedure TcxGridChartLegendItemPainter.DrawLegendKey;
|
|
begin
|
|
Canvas.FillRect(ViewInfo.LegendKeyBounds, ViewInfo.LegendKeyParams,
|
|
ViewInfo.LegendKeyBorders, ViewInfo.LegendKeyParams.TextColor);
|
|
end;
|
|
|
|
{ TcxGridChartLegendPainter }
|
|
|
|
function TcxGridChartLegendPainter.GetViewInfo: TcxGridChartLegendViewInfo;
|
|
begin
|
|
Result := TcxGridChartLegendViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
procedure TcxGridChartLegendPainter.DrawContent;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
inherited;
|
|
for I := 0 to ViewInfo.Count - 1 do
|
|
ViewInfo.Items[I].Paint(Canvas);
|
|
end;
|
|
|
|
function TcxGridChartLegendPainter.ExcludeFromClipRect: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
{ TcxGridChartDiagramPainter }
|
|
|
|
function TcxGridChartDiagramPainter.GetViewInfo: TcxGridChartDiagramViewInfo;
|
|
begin
|
|
Result := TcxGridChartDiagramViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramPainter.DrawValueCaptions;
|
|
var
|
|
AClipRegion, AUsedSpaceRegion, ARegion: TcxRegion;
|
|
I: Integer;
|
|
AValueCaptionViewInfo: TcxGridChartDiagramValueCaptionViewInfo;
|
|
ABounds: TRect;
|
|
begin
|
|
AClipRegion := Canvas.GetClipRegion;
|
|
AUsedSpaceRegion := TcxRegion.Create;
|
|
try
|
|
for I := 0 to ViewInfo.ValueViewInfoCount - 1 do
|
|
begin
|
|
PrepareClipRegionForValueDrawing(ViewInfo.ValueViewInfos[I], AClipRegion);
|
|
AValueCaptionViewInfo := ViewInfo.ValueViewInfos[I].CaptionViewInfo;
|
|
if AValueCaptionViewInfo.Visible then
|
|
begin
|
|
ABounds := AValueCaptionViewInfo.Bounds;
|
|
ARegion := TcxRegion.Create(ABounds);
|
|
try
|
|
ARegion.Combine(AUsedSpaceRegion, roIntersect, False);
|
|
if ARegion.IsEmpty then
|
|
begin
|
|
AValueCaptionViewInfo.Paint(Canvas);
|
|
AUsedSpaceRegion.Combine(TcxRegion.Create(ABounds), roAdd);
|
|
end;
|
|
finally
|
|
ARegion.Free;
|
|
end;
|
|
end;
|
|
end;
|
|
finally
|
|
AUsedSpaceRegion.Free;
|
|
AClipRegion.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramPainter.DrawValues;
|
|
var
|
|
AClipRegion: TcxRegion;
|
|
I: Integer;
|
|
begin
|
|
AClipRegion := Canvas.GetClipRegion;
|
|
try
|
|
for I := 0 to ViewInfo.ValueViewInfoCount - 1 do
|
|
begin
|
|
PrepareClipRegionForValueDrawing(ViewInfo.ValueViewInfos[I], AClipRegion);
|
|
ViewInfo.ValueViewInfos[I].Paint(Canvas);
|
|
end;
|
|
finally
|
|
AClipRegion.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramPainter.FillAndExcludeRect(const R: TRect);
|
|
begin
|
|
Canvas.FillRect(R);
|
|
Canvas.ExcludeClipRect(R);
|
|
end;
|
|
|
|
function TcxGridChartDiagramPainter.NeedsPainting: Boolean;
|
|
var
|
|
I: Integer;
|
|
AValueCaptionViewInfo: TcxGridChartDiagramValueCaptionViewInfo;
|
|
begin
|
|
Result := inherited NeedsPainting;
|
|
if not Result then
|
|
for I := 0 to ViewInfo.ValueViewInfoCount - 1 do
|
|
begin
|
|
AValueCaptionViewInfo := ViewInfo.ValueViewInfos[I].CaptionViewInfo;
|
|
Result := AValueCaptionViewInfo.Visible and
|
|
Canvas.RectVisible(AValueCaptionViewInfo.GetAreaBoundsForPainting);
|
|
if Result then Break;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramPainter.Paint;
|
|
begin
|
|
inherited;
|
|
DrawValueCaptions;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramPainter.PrepareClipRegionForValueDrawing(
|
|
AValueViewInfo: TcxGridChartDiagramValueViewInfo; AOriginalClipRegion: TcxRegion);
|
|
begin
|
|
end;
|
|
|
|
{ TcxGridChartHistogramTickMarkLabelsPainter }
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsPainter.GetViewInfo: TcxGridChartHistogramTickMarkLabelsViewInfo;
|
|
begin
|
|
Result := TcxGridChartHistogramTickMarkLabelsViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramTickMarkLabelsPainter.DrawCaptions;
|
|
var
|
|
I: Integer;
|
|
ABounds: TRect;
|
|
begin
|
|
Canvas.SetParams(ViewInfo.Params);
|
|
Canvas.Brush.Style := bsClear;
|
|
for I := 0 to ViewInfo.Count - 1 do
|
|
begin
|
|
ABounds := ViewInfo.CaptionBounds[I];
|
|
if not ViewInfo.IsVertical or Canvas.RectFullyVisible(ABounds) then
|
|
begin
|
|
Canvas.DrawText(ViewInfo.Captions[I], ABounds, ViewInfo.GetTextAttributes(True));
|
|
if ViewInfo.IsVertical then
|
|
Canvas.ExcludeClipRect(ABounds);
|
|
end;
|
|
end;
|
|
Canvas.Brush.Style := bsSolid;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramTickMarkLabelsPainter.DrawContent;
|
|
begin
|
|
if ViewInfo.CaptionsVisible then
|
|
DrawCaptions;
|
|
ViewInfo.TitleViewInfo.Paint(Canvas);
|
|
end;
|
|
|
|
{ TcxGridChartHistogramPainter }
|
|
|
|
function TcxGridChartHistogramPainter.GetViewInfo: TcxGridChartHistogramViewInfo;
|
|
begin
|
|
Result := TcxGridChartHistogramViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramPainter.DrawCategoryAxis;
|
|
var
|
|
R: TRect;
|
|
I: Integer;
|
|
begin
|
|
Canvas.Brush.Color := ViewInfo.CategoryAxisColor;
|
|
|
|
R := ViewInfo.CategoryAxisBounds;
|
|
FillAndExcludeRect(R);
|
|
|
|
for I := 0 to ViewInfo.CategoryMarkCount - 1 do
|
|
begin
|
|
R := ViewInfo.CategoryMarkBounds[I];
|
|
FillAndExcludeRect(R);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramPainter.DrawCategoryGridLines;
|
|
var
|
|
I: Integer;
|
|
R: TRect;
|
|
begin
|
|
Canvas.Brush.Color := ViewInfo.CategoryGridLineColor;
|
|
for I := 0 to ViewInfo.CategoryMarkCount - 1 do
|
|
begin
|
|
R := ViewInfo.CategoryGridLineBounds[I];
|
|
FillAndExcludeRect(R);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramPainter.DrawContent;
|
|
var
|
|
AClipRegion, APlotClipRegion: TcxRegion;
|
|
begin
|
|
AClipRegion := Canvas.GetClipRegion;
|
|
try
|
|
if ViewInfo.HasCategoryAxis then DrawCategoryAxis;
|
|
if ViewInfo.HasValueAxis then DrawValueAxis;
|
|
APlotClipRegion := Canvas.GetClipRegion;
|
|
try
|
|
APlotClipRegion.Combine(TcxRegion.Create(ViewInfo.PlotBounds), roSubtract);
|
|
SetValuesClipRegion;
|
|
DrawValuesBackground;
|
|
if not TransparentValues then DrawValues;
|
|
if ViewInfo.HasCategoryGridLines then DrawCategoryGridLines;
|
|
if ViewInfo.HasValueGridLines then DrawValueGridLines;
|
|
if not ViewInfo.DoCustomDrawPlot(Canvas) then
|
|
DrawPlotBackground;
|
|
finally
|
|
Canvas.SetClipRegion(APlotClipRegion, roSet);
|
|
end;
|
|
inherited;
|
|
finally
|
|
Canvas.SetClipRegion(AClipRegion, roSet);
|
|
end;
|
|
ViewInfo.CategoryTickMarkLabelsViewInfo.Paint(Canvas);
|
|
ViewInfo.ValueTickMarkLabelsViewInfo.Paint(Canvas);
|
|
if TransparentValues then
|
|
begin
|
|
AClipRegion := Canvas.GetClipRegion;
|
|
try
|
|
SetValuesClipRegion;
|
|
DrawValues;
|
|
finally
|
|
Canvas.SetClipRegion(AClipRegion, roSet);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramPainter.DrawPlotBackground;
|
|
begin
|
|
Canvas.FillRect(ViewInfo.PlotBounds, ViewInfo.PlotParams);
|
|
Canvas.ExcludeClipRect(ViewInfo.PlotBounds);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramPainter.DrawValueAxis;
|
|
var
|
|
R: TRect;
|
|
I: Integer;
|
|
begin
|
|
Canvas.Brush.Color := ViewInfo.ValueAxisColor;
|
|
|
|
R := ViewInfo.ValueAxisBounds;
|
|
FillAndExcludeRect(R);
|
|
|
|
for I := 0 to ViewInfo.ValueMarkCount - 1 do
|
|
begin
|
|
R := ViewInfo.ValueMarkBounds[I];
|
|
FillAndExcludeRect(R);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramPainter.DrawValueGridLines;
|
|
var
|
|
I: Integer;
|
|
R: TRect;
|
|
begin
|
|
Canvas.Brush.Color := ViewInfo.ValueGridLineColor;
|
|
for I := 0 to ViewInfo.ValueMarkCount - 1 do
|
|
begin
|
|
R := ViewInfo.ValueGridLineBounds[I];
|
|
FillAndExcludeRect(R);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramPainter.DrawValuesBackground;
|
|
begin
|
|
end;
|
|
|
|
function TcxGridChartHistogramPainter.GetValuesClipRect: TRect;
|
|
begin
|
|
Result := ViewInfo.Bounds;
|
|
if ViewInfo.IsValueAxisVert then
|
|
begin
|
|
Result.Top := ViewInfo.PlotBounds.Top;
|
|
Result.Bottom := ViewInfo.PlotBounds.Bottom;
|
|
end
|
|
else
|
|
begin
|
|
Result.Left := ViewInfo.PlotBounds.Left;
|
|
Result.Right := ViewInfo.PlotBounds.Right;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramPainter.SetValuesClipRegion;
|
|
begin
|
|
if ViewInfo.HasValuesOutOfRange then
|
|
Canvas.SetClipRegion(TcxRegion.Create(GetValuesClipRect), roIntersect);
|
|
end;
|
|
|
|
{ TcxGridChartColumnDiagramValuePainter }
|
|
|
|
function TcxGridChartColumnDiagramValuePainter.ExcludeFromClipRect: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
{ TcxGridChartColumnDiagramPainter }
|
|
|
|
function TcxGridChartColumnDiagramPainter.GetTransparentValues: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
{ TcxGridChartLineDiagramLegendItemPainter }
|
|
|
|
function TcxGridChartLineDiagramLegendItemPainter.GetViewInfo: TcxGridChartLineDiagramLegendItemViewInfo;
|
|
begin
|
|
Result := TcxGridChartLineDiagramLegendItemViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramLegendItemPainter.DrawLegendKey;
|
|
begin
|
|
DrawMarker;
|
|
DrawLine;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramLegendItemPainter.DrawLine;
|
|
begin
|
|
ViewInfo.GetDiagramValueViewInfoClass.GetPainterClassEx.DrawLineEx(Canvas,
|
|
ViewInfo.LineStart, ViewInfo.LineFinish, ViewInfo.LineStyle, ViewInfo.LineWidth,
|
|
ViewInfo.LineColor);
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramLegendItemPainter.DrawMarker;
|
|
begin
|
|
ViewInfo.GetDiagramValueViewInfoClass.GetPainterClassEx.DrawMarkerEx(
|
|
Canvas, ViewInfo.MarkerBounds, ViewInfo.MarkerPoints, ViewInfo.MarkerStyle,
|
|
ViewInfo.MarkerParams);
|
|
end;
|
|
|
|
{ TcxGridChartLineDiagramValuePainter }
|
|
|
|
function TcxGridChartLineDiagramValuePainter.GetViewInfo: TcxGridChartLineDiagramValueViewInfo;
|
|
begin
|
|
Result := TcxGridChartLineDiagramValueViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValuePainter.CanDrawDesignSelection: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValuePainter.DrawContent;
|
|
begin
|
|
inherited;
|
|
DrawMarker;
|
|
DrawLine;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValuePainter.DrawLine;
|
|
begin
|
|
DrawLineEx(Canvas, ViewInfo.LineStart, ViewInfo.LineFinish, ViewInfo.LineStyle,
|
|
ViewInfo.LineWidth, ViewInfo.LineColor);
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValuePainter.DrawMarker;
|
|
begin
|
|
DrawMarkerEx(Canvas, ViewInfo.MarkerBounds, ViewInfo.MarkerPoints,
|
|
ViewInfo.MarkerStyle, ViewInfo.MarkerParams);
|
|
end;
|
|
|
|
class procedure TcxGridChartLineDiagramValuePainter.DrawLineEx(ACanvas: TcxCanvas;
|
|
const AStart, AFinish: TPoint; AStyle: TcxGridChartLineStyle;
|
|
AWidth: Integer; AColor: TColor);
|
|
var
|
|
APoints: TPointArray;
|
|
begin
|
|
SetLength(APoints, 2);
|
|
APoints[0] := AStart;
|
|
APoints[1] := AFinish;
|
|
DrawLines(ACanvas, APoints, AStyle, AWidth, AColor);
|
|
end;
|
|
|
|
class procedure TcxGridChartLineDiagramValuePainter.DrawLines(ACanvas: TcxCanvas;
|
|
const APoints: TPointArray; AStyle: TcxGridChartLineStyle; AWidth: Integer; AColor: TColor);
|
|
const
|
|
PenTypes: array[Boolean] of Integer = (PS_COSMETIC, PS_GEOMETRIC);
|
|
PenStyles: array[TcxGridChartLineStyle] of Integer =
|
|
(0, PS_SOLID, PS_DASH, PS_DOT, PS_DASHDOT, PS_DASHDOTDOT);
|
|
var
|
|
APen: HPEN;
|
|
APenParams: TLogBrush;
|
|
begin
|
|
if AStyle = clsNone then Exit;
|
|
|
|
APenParams.lbStyle := BS_SOLID;
|
|
APenParams.lbColor := AColor;
|
|
APenParams.lbHatch := 0;
|
|
APen := ExtCreatePen(PenTypes[AWidth <> 1] or PenStyles[AStyle], AWidth,
|
|
APenParams, 0, nil);
|
|
APen := SelectObject(ACanvas.Handle, APen);
|
|
|
|
Polyline(ACanvas.Handle, APoints[0], Length(APoints));
|
|
|
|
DeleteObject(SelectObject(ACanvas.Handle, APen));
|
|
end;
|
|
|
|
class procedure TcxGridChartLineDiagramValuePainter.DrawMarkerEx(ACanvas: TcxCanvas;
|
|
const ABounds: TRect; const APoints: TPointArray; AStyle: TcxGridChartMarkerStyle;
|
|
const AParams: TcxViewParams);
|
|
var
|
|
ARegion, AInternalRegion: TcxRegion;
|
|
ARgn: HRGN;
|
|
R: TRect;
|
|
begin
|
|
case AStyle of
|
|
cmsSquare, cmsTriangle, cmsDiamond:
|
|
begin
|
|
if AStyle = cmsSquare then
|
|
ARgn := CreateRectRgnIndirect(ABounds)
|
|
else
|
|
ARgn := CreatePolygonRgn(APoints[0], Length(APoints), WINDING);
|
|
ARegion := TcxRegion.Create(ARgn);
|
|
try
|
|
ACanvas.DrawRegion(ARegion, AParams.Color, AParams.TextColor);
|
|
finally
|
|
ACanvas.SetClipRegion(ARegion, roSubtract);
|
|
end;
|
|
end;
|
|
cmsCircle:
|
|
begin
|
|
R := ABounds;
|
|
Inc(R.Right);
|
|
Inc(R.Bottom);
|
|
ARegion := TcxRegion.Create(CreateEllipticRgnIndirect(R));
|
|
try
|
|
ACanvas.FillRegion(ARegion, AParams.TextColor);
|
|
if ABounds.Right - ABounds.Left = 4 then
|
|
InflateRect(R, 0, -1)
|
|
else
|
|
InflateRect(R, -1, -1);
|
|
AInternalRegion := TcxRegion.Create(CreateEllipticRgnIndirect(R));
|
|
try
|
|
ACanvas.FillRegion(AInternalRegion, AParams.Color);
|
|
finally
|
|
AInternalRegion.Free;
|
|
end;
|
|
finally
|
|
ACanvas.SetClipRegion(ARegion, roSubtract);
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartLineDiagramPainter }
|
|
|
|
procedure TcxGridChartLineDiagramPainter.DrawContent;
|
|
begin
|
|
inherited;
|
|
DrawValuesDesignSelection;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramPainter.DrawValuesDesignSelection;
|
|
var
|
|
I: Integer;
|
|
AViewInfo: TcxGridChartDiagramValueViewInfo;
|
|
begin
|
|
for I := 0 to ViewInfo.ValueViewInfoCount - 1 do
|
|
begin
|
|
AViewInfo := ViewInfo.ValueViewInfos[I];
|
|
AViewInfo.GetPainterClass.DoDrawDesignSelection(Canvas, AViewInfo);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramPainter.GetTransparentValues: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
{ TcxGridChartAreaDiagramLegendItemPainter }
|
|
|
|
procedure TcxGridChartAreaDiagramLegendItemPainter.DrawAreaBackground;
|
|
begin
|
|
Canvas.FillRect(ViewInfo.LegendKeyBounds, ViewInfo.LegendKeyParams);
|
|
end;
|
|
|
|
procedure TcxGridChartAreaDiagramLegendItemPainter.DrawAreaBorder;
|
|
|
|
function GetPointsRect: TRect;
|
|
begin
|
|
Result := ViewInfo.LegendKeyBounds;
|
|
InflateRect(Result, -ViewInfo.LineWidth div 2, -ViewInfo.LineWidth div 2);
|
|
if Odd(ViewInfo.LineWidth) then
|
|
begin
|
|
Dec(Result.Right);
|
|
Dec(Result.Bottom);
|
|
end;
|
|
end;
|
|
|
|
procedure CalculatePointsForRect(const ARect: TRect; var APoints: TPointArray);
|
|
begin
|
|
SetLength(APoints, 5);
|
|
APoints[0] := ARect.TopLeft;
|
|
APoints[1] := Point(ARect.Right, ARect.Top);
|
|
APoints[2] := ARect.BottomRight;
|
|
APoints[3] := Point(ARect.Left, ARect.Bottom);
|
|
APoints[4] := APoints[0];
|
|
end;
|
|
|
|
var
|
|
APoints: TPointArray;
|
|
begin
|
|
if ViewInfo.LineStyle = clsNone then Exit;
|
|
CalculatePointsForRect(GetPointsRect, APoints);
|
|
ViewInfo.GetDiagramValueViewInfoClass.GetPainterClassEx.DrawLines(Canvas,
|
|
APoints, ViewInfo.LineStyle, ViewInfo.LineWidth, ViewInfo.LineColor);
|
|
end;
|
|
|
|
procedure TcxGridChartAreaDiagramLegendItemPainter.DrawLegendKey;
|
|
begin
|
|
DrawMarker;
|
|
DrawAreaBackground;
|
|
DrawAreaBorder;
|
|
end;
|
|
|
|
{ TcxGridChartAreaDiagramValuePainter }
|
|
|
|
function TcxGridChartAreaDiagramValuePainter.GetViewInfo: TcxGridChartAreaDiagramValueViewInfo;
|
|
begin
|
|
Result := TcxGridChartAreaDiagramValueViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
procedure TcxGridChartAreaDiagramValuePainter.DoDrawArea;
|
|
begin
|
|
if not ViewInfo.DoCustomDrawBackground(Canvas) then
|
|
DrawArea;
|
|
end;
|
|
|
|
procedure TcxGridChartAreaDiagramValuePainter.DrawArea;
|
|
begin
|
|
Canvas.Pen.Color := ViewInfo.AreaColor;
|
|
Canvas.Brush.Color := ViewInfo.AreaColor;
|
|
Canvas.Polygon(ViewInfo.AreaPoints);
|
|
end;
|
|
|
|
{ TcxGridChartAreaDiagramPainter }
|
|
|
|
procedure TcxGridChartAreaDiagramPainter.DrawValuesBackground;
|
|
var
|
|
ABackgroundRegion: TcxRegion;
|
|
I: Integer;
|
|
AValueViewInfo: TcxGridChartAreaDiagramValueViewInfo;
|
|
begin
|
|
inherited;
|
|
ABackgroundRegion := nil;
|
|
for I := 0 to ViewInfo.ValueViewInfoCount - 1 do
|
|
begin
|
|
AValueViewInfo := TcxGridChartAreaDiagramValueViewInfo(ViewInfo.ValueViewInfos[I]);
|
|
|
|
with TcxGridChartAreaDiagramValuePainter(AValueViewInfo.GetPainterClass.Create(Canvas, AValueViewInfo)) do
|
|
try
|
|
DoDrawArea;
|
|
finally
|
|
Free;
|
|
end;
|
|
|
|
if ABackgroundRegion = nil then
|
|
ABackgroundRegion := TcxRegion.Create;
|
|
ABackgroundRegion.Combine(AValueViewInfo.CreateAreaRegion, roAdd);
|
|
if (I = ViewInfo.ValueViewInfoCount - 1) or
|
|
(ViewInfo.ValueViewInfos[I + 1].SeriesIndex <> AValueViewInfo.SeriesIndex) then
|
|
begin
|
|
Canvas.SetClipRegion(ABackgroundRegion, roSubtract);
|
|
ABackgroundRegion := nil;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartPieDiagramValuePainter }
|
|
|
|
function TcxGridChartPieDiagramValuePainter.GetViewInfo: TcxGridChartPieDiagramValueViewInfo;
|
|
begin
|
|
Result := TcxGridChartPieDiagramValueViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramValuePainter.DrawContent;
|
|
begin
|
|
inherited;
|
|
DrawSlice;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramValuePainter.DrawLeaderLine;
|
|
begin
|
|
Canvas.Pen.Color := ViewInfo.Params.TextColor;
|
|
Canvas.Polyline(ViewInfo.LeaderLinePoints);
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramValuePainter.DrawSlice;
|
|
begin
|
|
Canvas.SetParams(ViewInfo.Params);
|
|
Canvas.Pen.Color := ViewInfo.Params.TextColor;
|
|
Canvas.Pie(ViewInfo.Bounds, 90 - ViewInfo.FinishAngle,
|
|
ViewInfo.FinishAngle - ViewInfo.StartAngle);
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramValuePainter.MainPaint;
|
|
begin
|
|
inherited;
|
|
if ViewInfo.CaptionPosition = pdvcpOutsideEndWithLeaderLines then
|
|
DrawLeaderLine;
|
|
end;
|
|
|
|
{ TcxGridChartPieSeriesSiteCaptionPainter }
|
|
|
|
function TcxGridChartPieSeriesSiteCaptionPainter.ExcludeFromClipRect: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
{ TcxGridChartPieSeriesSitePainter }
|
|
|
|
function TcxGridChartPieSeriesSitePainter.CanDrawDesignSelection: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSitePainter.ExcludeFromClipRect: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
{ TcxGridChartPieDiagramPainter }
|
|
|
|
function TcxGridChartPieDiagramPainter.GetViewInfo: TcxGridChartPieDiagramViewInfo;
|
|
begin
|
|
Result := TcxGridChartPieDiagramViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramPainter.DrawContent;
|
|
var
|
|
AClipRegion: TcxRegion;
|
|
begin
|
|
AClipRegion := Canvas.GetClipRegion;
|
|
try
|
|
ExcludeSeriesPieAreasFromClipRegion;
|
|
DrawSeriesSites;
|
|
inherited;
|
|
finally
|
|
Canvas.SetClipRegion(AClipRegion, roSet);
|
|
end;
|
|
DrawValues;
|
|
DrawSeriesDesignSelection;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramPainter.DrawSeriesDesignSelection;
|
|
var
|
|
I: Integer;
|
|
ASeriesSiteViewInfo: TcxGridChartPieSeriesSiteViewInfo;
|
|
begin
|
|
for I := 0 to ViewInfo.SeriesSiteViewInfoCount - 1 do
|
|
begin
|
|
ASeriesSiteViewInfo := ViewInfo.SeriesSiteViewInfos[I];
|
|
ASeriesSiteViewInfo.GetPainterClass.DoDrawDesignSelection(Canvas, ASeriesSiteViewInfo);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramPainter.DrawSeriesSites;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to ViewInfo.SeriesSiteViewInfoCount - 1 do
|
|
ViewInfo.SeriesSiteViewInfos[I].Paint(Canvas);
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramPainter.DrawValues;
|
|
var
|
|
AClipRegion: TcxRegion;
|
|
begin
|
|
AClipRegion := Canvas.GetClipRegion;
|
|
try
|
|
inherited;
|
|
finally
|
|
Canvas.SetClipRegion(AClipRegion, roSet);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramPainter.ExcludeSeriesPieAreasFromClipRegion;
|
|
var
|
|
I: Integer;
|
|
R: TRect;
|
|
begin
|
|
for I := 0 to ViewInfo.SeriesSiteViewInfoCount - 1 do
|
|
if not ViewInfo.SeriesSiteViewInfos[I].IsPieEmpty then
|
|
begin
|
|
R := ViewInfo.SeriesSiteViewInfos[I].PieAreaBounds;
|
|
InflateRect(R, -1, -1); // to fill the gap between drawn pie and elliptic region
|
|
if not IsRectEmpty(R) then
|
|
Canvas.SetClipRegion(TcxRegion.Create(CreateEllipticRgnIndirect(R)), roSubtract);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramPainter.PrepareClipRegionForValueDrawing(
|
|
AValueViewInfo: TcxGridChartDiagramValueViewInfo; AOriginalClipRegion: TcxRegion);
|
|
var
|
|
ARegion: TcxRegion;
|
|
begin
|
|
if AValueViewInfo.VisibleValueIndex <> 0 then Exit;
|
|
ARegion := TcxRegion.Create(ViewInfo.SeriesSiteViewInfos[AValueViewInfo.SeriesIndex].ContentBounds);
|
|
ARegion.Combine(AOriginalClipRegion, roIntersect, False);
|
|
Canvas.SetClipRegion(ARegion, roSet);
|
|
end;
|
|
|
|
{ TcxGridChartToolBoxItemSeparatorPainter }
|
|
|
|
procedure TcxGridChartToolBoxItemSeparatorPainter.DrawContent;
|
|
begin
|
|
Canvas.Pen.Color := ViewInfo.Params.Color;
|
|
Canvas.Pen.Style := psDot;
|
|
with ViewInfo.Bounds do
|
|
begin
|
|
Canvas.MoveTo(Left, Top);
|
|
Canvas.LineTo(Left, Bottom);
|
|
end;
|
|
Canvas.Pen.Style := psSolid;
|
|
{ Canvas.Brush.Color := ViewInfo.ItemSeparatorColor;
|
|
Canvas.FillRect(ViewInfo.Bounds);}
|
|
end;
|
|
|
|
{ TcxGridChartToolBoxDataLevelActiveValuePainter }
|
|
|
|
function TcxGridChartToolBoxDataLevelActiveValuePainter.GetViewInfo: TcxGridChartToolBoxDataLevelActiveValueViewInfo;
|
|
begin
|
|
Result := TcxGridChartToolBoxDataLevelActiveValueViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxDataLevelActiveValuePainter.PrepareCanvasForDrawText;
|
|
begin
|
|
inherited;
|
|
if ViewInfo.GridView.Controller.CanShowDataLevelActiveValuePopup(False) then
|
|
with Canvas.Font do
|
|
Style := Style + [fsUnderline];
|
|
end;
|
|
|
|
{ TcxGridChartToolBoxDataLevelInfoPainter }
|
|
|
|
procedure TcxGridChartToolBoxDataLevelInfoPainter.DrawBackground;
|
|
begin
|
|
DrawBackground(ViewInfo.ContentBounds);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoPainter.ExcludeFromClipRect: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
{ TcxGridChartToolBoxCustomizeButtonPainter }
|
|
|
|
function TcxGridChartToolBoxCustomizeButtonPainter.GetViewInfo: TcxGridChartToolBoxCustomizeButtonViewInfo;
|
|
begin
|
|
Result := TcxGridChartToolBoxCustomizeButtonViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxCustomizeButtonPainter.Paint;
|
|
begin
|
|
Canvas.Font := ViewInfo.Params.Font;
|
|
ViewInfo.LookAndFeelPainter.DrawButton(Canvas, ViewInfo.Bounds, ViewInfo.Text,
|
|
ViewInfo.ButtonState);
|
|
end;
|
|
|
|
{ TcxGridChartToolBoxDiagramSelectorPainter }
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorPainter.GetViewInfo: TcxGridChartToolBoxDiagramSelectorViewInfo;
|
|
begin
|
|
Result := TcxGridChartToolBoxDiagramSelectorViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxDiagramSelectorPainter.DrawContent;
|
|
begin
|
|
inherited;
|
|
DrawImage;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxDiagramSelectorPainter.DrawImage;
|
|
begin
|
|
if ViewInfo.ImageIndex <> -1 then
|
|
with ViewInfo.ImageBounds do
|
|
cxGridChartDiagramImages.Draw(Canvas.Canvas, Left, Top, ViewInfo.ImageIndex);
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxDiagramSelectorPainter.PrepareCanvasForDrawText;
|
|
begin
|
|
inherited;
|
|
if ViewInfo.CanShowDropDownWindow then
|
|
with Canvas.Font do
|
|
Style := Style + [fsUnderline];
|
|
end;
|
|
|
|
{ TcxGridChartToolBoxPainter }
|
|
|
|
function TcxGridChartToolBoxPainter.GetViewInfo: TcxGridChartToolBoxViewInfo;
|
|
begin
|
|
Result := TcxGridChartToolBoxViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxPainter.DrawContent;
|
|
var
|
|
AClipRegion: TcxRegion;
|
|
begin
|
|
AClipRegion := Canvas.GetClipRegion;
|
|
try
|
|
Canvas.IntersectClipRect(ViewInfo.ClientBounds);
|
|
DrawItems(True);
|
|
DrawDataLevelInfoConnectors;
|
|
inherited;
|
|
DrawItems(False);
|
|
finally
|
|
Canvas.SetClipRegion(AClipRegion, roSet);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxPainter.DrawDataLevelInfoConnectors;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Canvas.Brush.Color := ViewInfo.DataLevelInfoConnectorColor;
|
|
for I := 0 to ViewInfo.DataLevelInfoConnectorCount - 1 do
|
|
Canvas.FillRect(ViewInfo.DataLevelInfoConnectors[I], nil, True);
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxPainter.DrawItems(AOpaqueItems: Boolean);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to ViewInfo.Count - 1 do
|
|
if ViewInfo.Items[I].HasBackground = AOpaqueItems then
|
|
ViewInfo.Items[I].Paint(Canvas);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxPainter.ExcludeFromClipRect: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
{ TcxGridChartPainter }
|
|
|
|
function TcxGridChartPainter.GetViewInfo: TcxGridChartViewInfo;
|
|
begin
|
|
Result := TcxGridChartViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
procedure TcxGridChartPainter.PaintAfter;
|
|
begin
|
|
inherited;
|
|
ViewInfo.TitleViewInfo.Paint(Canvas);
|
|
if ViewInfo.DiagramViewInfo <> nil then
|
|
ViewInfo.DiagramViewInfo.Paint(Canvas);
|
|
end;
|
|
|
|
procedure TcxGridChartPainter.PaintContent;
|
|
begin
|
|
inherited;
|
|
if ViewInfo.DiagramViewInfo <> nil then
|
|
ExcludeFromBackground(ViewInfo.DiagramViewInfo.Bounds);
|
|
ViewInfo.ToolBoxViewInfo.Paint(Canvas);
|
|
if ViewInfo.LegendViewInfo <> nil then
|
|
ViewInfo.LegendViewInfo.Paint(Canvas);
|
|
end;
|
|
|
|
{ TcxGridChartViewData }
|
|
|
|
constructor TcxGridChartViewData.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited;
|
|
UpdateDataGroupIndex;
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetCategory(AIndex: Integer): Variant;
|
|
begin
|
|
Result := DataController.Values[AIndex, GridView.Categories.DataBinding.DataIndex];
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetCategoryCount: Integer;
|
|
begin
|
|
Result := DataController.RecordCount;
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetChildCount: Integer;
|
|
begin
|
|
Result := DataController.Groups.ChildCount[DataGroupIndex];
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetChildDataGroupIndex(Index: Integer): Integer;
|
|
begin
|
|
Result := DataController.Groups.ChildDataGroupIndex[DataGroupIndex, Index];
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetChildLevel: Integer;
|
|
begin
|
|
Result := GridView.ActiveDataLevel;
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetChildRecordIndex(Index: Integer): Integer;
|
|
begin
|
|
Result := DataController.Groups.ChildRecordIndex[DataGroupIndex, Index];
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetDataGroupIndex: Integer;
|
|
begin
|
|
if FDataGroupIndex = -2 then
|
|
FDataGroupIndex := CalculateDataGroupIndex;
|
|
Result := FDataGroupIndex;
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetGroupValue(ADataGroupIndex, AIndex: Integer): Variant;
|
|
begin
|
|
Result := DataController.Values[AIndex,
|
|
GridView.DataGroups[ADataGroupIndex].DataBinding.DataIndex];
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetSumOfValues(ASeriesIndex: Integer): Variant;
|
|
begin
|
|
if FSumOfValues = nil then CalculateSumsOfValues;
|
|
Result := FSumOfValues[ASeriesIndex];
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetValue(ASeriesIndex, AIndex: Integer): Variant;
|
|
begin
|
|
Result := DataController.Values[AIndex,
|
|
GridView.Series[ASeriesIndex].DataBinding.DataIndex];
|
|
if not IsValueValid(Result) then
|
|
Result := 0;
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetVisibleCategory(AIndex: Integer): Variant;
|
|
begin
|
|
if IsDataGrouped then
|
|
if IsSummaryLevel then
|
|
Result := DataController.Groups.GroupValues[ChildDataGroupIndex[AIndex]]
|
|
else
|
|
Result := Categories[ChildRecordIndex[AIndex]]
|
|
else
|
|
Result := Categories[GetRecordIndexByValueIndex(AIndex)];
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetVisibleCategoryCount: Integer;
|
|
begin
|
|
if IsDataGrouped then
|
|
Result := ChildCount
|
|
else
|
|
Result := DataController.RowCount;
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetVisibleGroupValue(AVisibleDataGroupIndex, AIndex: Integer): Variant;
|
|
begin
|
|
Result := DataController.Groups.GroupValues[
|
|
DataController.Groups.ChildDataGroupIndex[GetDataGroupIndexByLevel(AVisibleDataGroupIndex), AIndex]];
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetVisibleGroupValueCount(AVisibleDataGroupIndex: Integer): Integer;
|
|
begin
|
|
Result := DataController.Groups.ChildCount[GetDataGroupIndexByLevel(AVisibleDataGroupIndex)];
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetVisibleValue(ASeriesIndex, AIndex: Integer): Variant;
|
|
begin
|
|
if IsDataGrouped then
|
|
if IsSummaryLevel then
|
|
begin
|
|
Result := DataController.Summary.GroupSummaryValues[
|
|
ChildDataGroupIndex[AIndex],
|
|
GridView.Series[ASeriesIndex].DataBinding.SummaryIndex];
|
|
if not IsValueValid(Result) then
|
|
Result := 0;
|
|
end
|
|
else
|
|
Result := Values[ASeriesIndex, ChildRecordIndex[AIndex]]
|
|
else
|
|
Result := Values[ASeriesIndex, GetRecordIndexByValueIndex(AIndex)];
|
|
end;
|
|
|
|
procedure TcxGridChartViewData.SetCategory(AIndex: Integer; const Value: Variant);
|
|
begin
|
|
DataController.Values[AIndex, GridView.Categories.DataBinding.DataIndex] := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartViewData.SetCategoryCount(Value: Integer);
|
|
begin
|
|
DataController.RecordCount := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartViewData.SetGroupValue(ADataGroupIndex, AIndex: Integer;
|
|
const Value: Variant);
|
|
begin
|
|
DataController.Values[AIndex,
|
|
GridView.DataGroups[ADataGroupIndex].DataBinding.DataIndex] := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartViewData.SetValue(ASeriesIndex, AIndex: Integer;
|
|
const Value: Variant);
|
|
begin
|
|
DataController.Values[AIndex,
|
|
GridView.Series[ASeriesIndex].DataBinding.DataIndex] := Value;
|
|
end;
|
|
|
|
function TcxGridChartViewData.CalculateDataGroupIndex: Integer;
|
|
begin
|
|
Result := GetDataGroupIndexByLevel(ChildLevel);
|
|
end;
|
|
|
|
function TcxGridChartViewData.CalculateSumOfValues(ASeriesIndex: Integer): Variant;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := 0;
|
|
for I := 0 to VisibleCategoryCount - 1 do
|
|
Result := Result + Abs(VisibleValues[ASeriesIndex, I]);
|
|
end;
|
|
|
|
procedure TcxGridChartViewData.CheckValueAtLevel(ALevel: Integer; var AValue: Variant);
|
|
var
|
|
ADataGroupIndex: Integer;
|
|
begin
|
|
ADataGroupIndex := GetDataGroupIndexByLevel(ALevel);
|
|
if (ADataGroupIndex = -2) or
|
|
(DataController.Groups.GetDataGroupIndexByGroupValue(ADataGroupIndex, AValue) = -1) then
|
|
AValue := Null;
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetDataGroupIndexByLevel(ALevel: Integer): Integer;
|
|
var
|
|
I, ADataGroupIndex: Integer;
|
|
begin
|
|
Result := -1;
|
|
for I := 0 to ALevel - 1 do
|
|
begin
|
|
ADataGroupIndex := DataController.Groups.GetDataGroupIndexByGroupValue(Result,
|
|
(DataController.GetItem(DataController.Groups.GroupingItemIndex[I]) as TcxGridChartDataGroup).ActiveValue);
|
|
if ADataGroupIndex = -1 then
|
|
begin
|
|
Result := -2;
|
|
Break;
|
|
end;
|
|
{ if ADataGroupIndex = -1 then
|
|
ADataGroupIndex := DataController.Groups.ChildDataGroupIndex[Result, 0];}
|
|
Result := ADataGroupIndex;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartViewData.GetRecordIndexByValueIndex(AValueIndex: Integer): Integer;
|
|
begin
|
|
Result := DataController.GetRowInfo(AValueIndex).RecordIndex;
|
|
end;
|
|
|
|
procedure TcxGridChartViewData.DataLevelsChanged;
|
|
begin
|
|
UpdateDataGroupIndex;
|
|
UpdateSumsOfValues;
|
|
end;
|
|
|
|
function TcxGridChartViewData.IsDataGrouped: Boolean;
|
|
begin
|
|
Result := DataController.Groups.GroupingItemCount <> 0;
|
|
end;
|
|
|
|
function TcxGridChartViewData.IsSummaryLevel: Boolean;
|
|
begin
|
|
Result := ChildLevel < DataController.Groups.GroupingItemCount;
|
|
end;
|
|
|
|
procedure TcxGridChartViewData.CalculateSumsOfValues;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
SetLength(FSumOfValues, GridView.SeriesCount);
|
|
for I := 0 to GridView.SeriesCount - 1 do
|
|
FSumOfValues[I] := CalculateSumOfValues(I);
|
|
end;
|
|
|
|
procedure TcxGridChartViewData.SeriesPosChanged(ASeries: TcxGridChartSeries);
|
|
begin
|
|
UpdateSumsOfValues;
|
|
end;
|
|
|
|
procedure TcxGridChartViewData.Update(AInfo: TcxUpdateControlInfo);
|
|
begin
|
|
if (AInfo is TcxDataChangedInfo) or (AInfo is TcxLayoutChangedInfo) then
|
|
begin
|
|
DataLevelsChanged;
|
|
GridView.UpdateDataGroupActiveValues;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartViewData.UpdateDataGroupIndex;
|
|
begin
|
|
FDataGroupIndex := -2;
|
|
end;
|
|
|
|
procedure TcxGridChartViewData.UpdateSumsOfValues;
|
|
begin
|
|
FSumOfValues := nil;
|
|
end;
|
|
|
|
procedure TcxGridChartViewData.GetVisibleGroupValues(ADataGroup: TcxGridChartDataGroup;
|
|
AStrings: TStrings; out AValues: TVariantArray);
|
|
var
|
|
ADataGroupIndex, I: Integer;
|
|
AValue: Variant;
|
|
begin
|
|
ADataGroupIndex := GetDataGroupIndexByLevel(ADataGroup.VisibleIndex);
|
|
I := DataController.Groups.ChildCount[ADataGroupIndex];
|
|
SetLength(AValues, I);
|
|
AStrings.BeginUpdate;
|
|
try
|
|
AStrings.Clear;
|
|
for I := 0 to I - 1 do
|
|
begin
|
|
AValue := DataController.Groups.GroupValues[
|
|
DataController.Groups.ChildDataGroupIndex[ADataGroupIndex, I]];
|
|
AStrings.Add(ADataGroup.GetValueDisplayText(AValue));
|
|
AValues[I] := AValue;
|
|
end;
|
|
finally
|
|
AStrings.EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
{ TcxCustomGridChartPartViewInfo }
|
|
|
|
function TcxCustomGridChartPartViewInfo.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
function TcxCustomGridChartPartViewInfo.GetGridViewInfo: TcxGridChartViewInfo;
|
|
begin
|
|
Result := TcxGridChartViewInfo(inherited GridViewInfo);
|
|
end;
|
|
|
|
function TcxCustomGridChartPartViewInfo.GetHeight: Integer;
|
|
begin
|
|
if inherited GetHeight = 0 then
|
|
Height := CalculateHeight;
|
|
Result := inherited GetHeight;
|
|
end;
|
|
|
|
function TcxCustomGridChartPartViewInfo.GetVisible: Boolean;
|
|
begin
|
|
Result := Position <> cppNone;
|
|
end;
|
|
|
|
function TcxCustomGridChartPartViewInfo.GetWidth: Integer;
|
|
begin
|
|
if inherited GetWidth = 0 then
|
|
Width := CalculateWidth;
|
|
Result := inherited GetWidth;
|
|
end;
|
|
|
|
{ TcxCustomGridChartTitleViewInfo }
|
|
|
|
constructor TcxCustomGridChartTitleViewInfo.Create(AGridViewInfo: TcxCustomGridViewInfo;
|
|
ATitle: TcxCustomGridChartTitle);
|
|
begin
|
|
inherited Create(AGridViewInfo);
|
|
FTitle := ATitle;
|
|
end;
|
|
|
|
function TcxCustomGridChartTitleViewInfo.CalculateHeight: Integer;
|
|
begin
|
|
if Orientation = cpoHorizontal then
|
|
Result := TextHeight
|
|
else
|
|
Result := CalculateTextWidth(90);
|
|
end;
|
|
|
|
function TcxCustomGridChartTitleViewInfo.CalculateWidth: Integer;
|
|
begin
|
|
if Orientation = cpoHorizontal then
|
|
Result := TextWidth
|
|
else
|
|
Result := CalculateTextHeight(False, 90);
|
|
end;
|
|
|
|
function TcxCustomGridChartTitleViewInfo.GetAlignment: TcxGridChartPartAlignment;
|
|
begin
|
|
Result := FTitle.GetAlignment;
|
|
end;
|
|
|
|
function TcxCustomGridChartTitleViewInfo.GetOrientation: TcxGridChartPartOrientation;
|
|
begin
|
|
Result := FTitle.GetOrientation;
|
|
end;
|
|
|
|
function TcxCustomGridChartTitleViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartTitlePainter;
|
|
end;
|
|
|
|
function TcxCustomGridChartTitleViewInfo.GetPosition: TcxGridChartPartPosition;
|
|
begin
|
|
Result := FTitle.GetPosition;
|
|
end;
|
|
|
|
function TcxCustomGridChartTitleViewInfo.GetText: string;
|
|
begin
|
|
Result := FTitle.GetText;
|
|
end;
|
|
|
|
function TcxCustomGridChartTitleViewInfo.GetTextAreaBounds: TRect;
|
|
begin
|
|
Result := ContentBounds;
|
|
if Orientation = cpoVertical then
|
|
SwapIntegers(Result.Top, Result.Bottom);
|
|
end;
|
|
|
|
function TcxCustomGridChartTitleViewInfo.HasBackground: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
{ TcxGridChartLegendItemViewInfo }
|
|
|
|
constructor TcxGridChartLegendItemViewInfo.Create(AContainer: TcxGridChartLegendViewInfo;
|
|
AIndex: Integer);
|
|
begin
|
|
inherited Create(AContainer.GridViewInfo);
|
|
FContainer := AContainer;
|
|
FIndex := AIndex;
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.GetDiagram: TcxGridChartDiagram;
|
|
begin
|
|
Result := FContainer.Diagram;
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.GetLegendKeyHeight: Integer;
|
|
begin
|
|
Result := FContainer.ItemLegendKeyHeight;
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.GetLegendKeyWidth: Integer;
|
|
begin
|
|
Result := FContainer.ItemLegendKeyWidth;
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.GetSeries: TcxGridChartSeries;
|
|
begin
|
|
if Container.GetItemSeriesIndex(Index) = -1 then
|
|
Result := nil
|
|
else
|
|
Result := GridView.VisibleSeries[Container.GetItemSeriesIndex(Index)];
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.CalculateContentBounds: TRect;
|
|
begin
|
|
Result := inherited CalculateContentBounds;
|
|
InflateRect(Result, -LegendKeyOffset div 2, 0);
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.CalculateHeight: Integer;
|
|
begin
|
|
Result := TextHeight;
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.CalculateWidth: Integer;
|
|
begin
|
|
Result := TextWidth;
|
|
Inc(Result, LegendKeyOffset div 2 * 2 + LegendKeyWidth + LegendKeyOffset);
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.CalculateLegendKeyHeight: Integer;
|
|
begin
|
|
Result := CalculateLegendKeySize;
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.CalculateLegendKeySize: Integer;
|
|
begin
|
|
Result := 2 * LegendKeyOffset;
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.CalculateLegendKeyWidth: Integer;
|
|
begin
|
|
Result := CalculateLegendKeySize;
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.CustomDraw(ACanvas: TcxCanvas): Boolean;
|
|
begin
|
|
Result := inherited CustomDraw(ACanvas);
|
|
if not Result then
|
|
begin
|
|
Diagram.DoCustomDrawLegendItem(ACanvas, Self, Result);
|
|
if not Result then
|
|
GridView.DoCustomDrawLegendItem(ACanvas, Self, Result);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartLegendItemViewInfo.DoCalculateParams;
|
|
begin
|
|
inherited;
|
|
Container.GetItemLegendKeyParams(Index, LegendKeyParams);
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.GetDesignSelectionBounds: TRect;
|
|
begin
|
|
Result := Bounds;
|
|
InflateRect(Result, DesignSelectionWidth, DesignSelectionWidth);
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
|
|
begin
|
|
Result := TcxGridChartLegendItemHitTest;
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.GetIsDesignSelected: Boolean;
|
|
begin
|
|
Result := (Container.Kind = lkSeries) and GridView.IsDesigning and
|
|
GridView.Controller.DesignController.IsObjectSelected(Series);
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.GetLegendKeyBorders: TcxBorders;
|
|
begin
|
|
if Diagram.Legend.GetKeyBorder = lbSingle then
|
|
Result := cxBordersAll
|
|
else
|
|
Result := [];
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.GetLegendKeyBounds: TRect;
|
|
begin
|
|
CalculateParams;
|
|
Result := ContentBounds;
|
|
with Result do
|
|
begin
|
|
Right := Left + LegendKeyWidth;
|
|
Top := MulDiv(Top + Bottom - LegendKeyHeight, 1, 2);
|
|
Bottom := Top + LegendKeyHeight;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.GetLegendKeyOffset: Integer;
|
|
begin
|
|
CalculateParams;
|
|
Result := MulDiv(Canvas.FontHeight(Params.Font), 3, 8);
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartLegendItemPainter;
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.GetText: string;
|
|
begin
|
|
Result := FContainer.GetItemCaption(FIndex);
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.GetTextAreaBounds: TRect;
|
|
begin
|
|
Result := ContentBounds;
|
|
Inc(Result.Left, LegendKeyWidth + LegendKeyOffset);
|
|
end;
|
|
|
|
procedure TcxGridChartLegendItemViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
FContainer.GetViewParams(AParams);
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.HasBackground: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.HasCustomDraw: Boolean;
|
|
begin
|
|
Result := Diagram.HasCustomDrawLegendItem or GridView.HasCustomDrawLegendItem;
|
|
end;
|
|
|
|
procedure TcxGridChartLegendItemViewInfo.InitHitTest(AHitTest: TcxCustomGridHitTest);
|
|
begin
|
|
inherited;
|
|
with AHitTest as TcxGridChartLegendItemHitTest do
|
|
begin
|
|
Index := Self.Index;
|
|
Series := Self.Series;
|
|
ValueIndex := Container.GetItemValueIndex(Self.Index);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.GetAreaBoundsForPainting: TRect;
|
|
begin
|
|
Result := DesignSelectionBounds;
|
|
end;
|
|
|
|
function TcxGridChartLegendItemViewInfo.MouseDown(AHitTest: TcxCustomGridHitTest;
|
|
AButton: TMouseButton; AShift: TShiftState): Boolean;
|
|
begin
|
|
Result := inherited MouseDown(AHitTest, AButton, AShift);
|
|
if (Container.Kind = lkSeries) and
|
|
(AButton = mbLeft) and not (ssDouble in AShift) and GridView.IsDesigning then
|
|
begin
|
|
GridView.Controller.DesignController.SelectObject(Series, not (ssShift in AShift));
|
|
Result := True;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartLegendViewInfo }
|
|
|
|
constructor TcxGridChartLegendViewInfo.Create(AGridViewInfo: TcxCustomGridViewInfo;
|
|
ADiagram: TcxGridChartDiagram);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
inherited Create(AGridViewInfo);
|
|
FDiagram := ADiagram;
|
|
FItems := TList.Create;
|
|
for I := 0 to GetItemCount - 1 do
|
|
AddItem;
|
|
end;
|
|
|
|
destructor TcxGridChartLegendViewInfo.Destroy;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to Count - 1 do
|
|
Items[I].Free;
|
|
FItems.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetCount: Integer;
|
|
begin
|
|
Result := FItems.Count;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetItem(Index: Integer): TcxGridChartLegendItemViewInfo;
|
|
begin
|
|
Result := TcxGridChartLegendItemViewInfo(FItems[Index]);
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetItemLegendKeyWidth: Integer;
|
|
begin
|
|
if FItemLegendKeyWidth = 0 then
|
|
FItemLegendKeyWidth := CalculateItemLegendKeyWidth;
|
|
Result := FItemLegendKeyWidth;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetItemLegendKeyHeight: Integer;
|
|
begin
|
|
if FItemLegendKeyHeight = 0 then
|
|
FItemLegendKeyHeight := CalculateItemLegendKeyHeight;
|
|
Result := FItemLegendKeyHeight;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetItemOffset: Integer;
|
|
begin
|
|
if FItemOffset = 0 then
|
|
FItemOffset := CalculateItemOffset;
|
|
Result := FItemOffset;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.CalculateHeight: Integer;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
CalculateParams;
|
|
if Orientation = cpoHorizontal then
|
|
begin
|
|
Result := 0;
|
|
for I := 0 to Count - 1 do
|
|
Result := Max(Result, Items[I].CalculateHeight);
|
|
end
|
|
else
|
|
begin
|
|
Result := ItemOffset * (Count - 1);
|
|
for I := 0 to Count - 1 do
|
|
Inc(Result, Items[I].CalculateHeight);
|
|
end;
|
|
Inc(Result, BorderSize[bTop] + BorderSize[bBottom] + 2 * ItemOffset);
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.CalculateWidth: Integer;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
CalculateParams;
|
|
if Orientation = cpoHorizontal then
|
|
begin
|
|
Result := ItemOffset * (Count - 1);
|
|
for I := 0 to Count - 1 do
|
|
Inc(Result, Items[I].CalculateWidth);
|
|
end
|
|
else
|
|
begin
|
|
Result := 0;
|
|
for I := 0 to Count - 1 do
|
|
Result := Max(Result, Items[I].CalculateWidth);
|
|
end;
|
|
Inc(Result, BorderSize[bLeft] + BorderSize[bRight] + 2 * ItemOffset);
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.CalculateItemLegendKeyWidth: Integer;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := 0;
|
|
for I := 0 to Count - 1 do
|
|
Result := Max(Result, Items[I].CalculateLegendKeyWidth);
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.CalculateItemLegendKeyHeight: Integer;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := 0;
|
|
for I := 0 to Count - 1 do
|
|
Result := Max(Result, Items[I].CalculateLegendKeyHeight);
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.CalculateItemOffset: Integer;
|
|
begin
|
|
CalculateParams;
|
|
Result := MulDiv(Canvas.FontHeight(Params.Font), 1, 4);
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.CustomDraw(ACanvas: TcxCanvas): Boolean;
|
|
begin
|
|
Result := inherited CustomDraw(ACanvas);
|
|
if not Result then
|
|
begin
|
|
Diagram.DoCustomDrawLegend(ACanvas, Self, Result);
|
|
if not Result then
|
|
GridView.DoCustomDrawLegend(ACanvas, Self, Result);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetAlignment: TcxGridChartPartAlignment;
|
|
begin
|
|
Result := Diagram.Legend.GetAlignment;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetBorderColor(AIndex: TcxBorder): TColor;
|
|
begin
|
|
Result := Params.TextColor;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetBorders: TcxBorders;
|
|
begin
|
|
if Diagram.Legend.GetBorder = lbSingle then
|
|
Result := cxBordersAll
|
|
else
|
|
Result := [];
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetBorderWidth(AIndex: TcxBorder): Integer;
|
|
begin
|
|
Result := 1;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
|
|
begin
|
|
Result := TcxGridChartLegendHitTest;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetOrientation: TcxGridChartPartOrientation;
|
|
begin
|
|
Result := Diagram.Legend.GetOrientation;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartLegendPainter;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetPosition: TcxGridChartPartPosition;
|
|
begin
|
|
Result := Diagram.Legend.GetPosition;
|
|
end;
|
|
|
|
procedure TcxGridChartLegendViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
Diagram.Styles.GetViewParams(dsLegend, nil, nil, AParams);
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetVisible: Boolean;
|
|
begin
|
|
Result := inherited GetVisible and (Count <> 0);
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.HasCustomDraw: Boolean;
|
|
begin
|
|
Result := Diagram.HasCustomDrawLegend or GridView.HasCustomDrawLegend;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.AddItem: TcxGridChartLegendItemViewInfo;
|
|
begin
|
|
Result := GetItemClass.Create(Self, Count);
|
|
FItems.Add(Result);
|
|
end;
|
|
|
|
procedure TcxGridChartLegendViewInfo.CalculateItems;
|
|
var
|
|
AItemLeftOffset, AItemTopOffset, I: Integer;
|
|
begin
|
|
AItemLeftOffset := ContentBounds.Left + ItemOffset;
|
|
AItemTopOffset := ContentBounds.Top + ItemOffset;
|
|
for I := 0 to Count - 1 do
|
|
begin
|
|
Items[I].Calculate(AItemLeftOffset, AItemTopOffset);
|
|
if Orientation = cpoHorizontal then
|
|
AItemLeftOffset := Items[I].Bounds.Right + ItemOffset
|
|
else
|
|
AItemTopOffset := Items[I].Bounds.Bottom + ItemOffset;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetItemCaption(AIndex: Integer): string;
|
|
begin
|
|
if Kind = lkSeries then
|
|
Result := GridView.VisibleSeries[GetItemSeriesIndex(AIndex)].GetDisplayText
|
|
else
|
|
begin
|
|
Result := GridView.Categories.VisibleDisplayTexts[GetItemValueIndex(AIndex)];
|
|
if Result = '' then
|
|
Result := '<' + IntToStr(1 + AIndex) + '>';
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetItemClass: TcxGridChartLegendItemViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartLegendItemViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetItemCount: Integer;
|
|
begin
|
|
if Kind = lkSeries then
|
|
Result := GridView.VisibleSeriesCount
|
|
else
|
|
Result := GridView.Categories.VisibleValueCount;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetItemSeriesIndex(AIndex: Integer): Integer;
|
|
begin
|
|
if Kind = lkSeries then
|
|
Result := GetItemObjectIndex(AIndex)
|
|
else
|
|
if GridView.VisibleSeriesCount = 1 then
|
|
Result := 0
|
|
else
|
|
Result := -1;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetItemValueIndex(AIndex: Integer): Integer;
|
|
begin
|
|
if Kind = lkSeries then
|
|
Result := -1
|
|
else
|
|
Result := GetItemObjectIndex(AIndex);
|
|
end;
|
|
|
|
{function TcxGridChartLegendViewInfo.ItemLegendKeyBorderIsValueBorder: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;}
|
|
|
|
procedure TcxGridChartLegendViewInfo.Calculate(ALeftBound, ATopBound: Integer;
|
|
AWidth: Integer = -1; AHeight: Integer = -1);
|
|
begin
|
|
inherited;
|
|
CalculateItems;
|
|
end;
|
|
|
|
function TcxGridChartLegendViewInfo.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
|
|
var
|
|
I: Integer;
|
|
AHitTest: TcxCustomGridHitTest;
|
|
begin
|
|
Result := inherited GetHitTest(P);
|
|
if Result <> nil then
|
|
for I := 0 to Count - 1 do
|
|
begin
|
|
AHitTest := Items[I].GetHitTest(P);
|
|
if AHitTest <> nil then
|
|
begin
|
|
Result := AHitTest;
|
|
Break;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartLegendViewInfo.GetItemLegendKeyParams(AIndex: Integer;
|
|
out AParams: TcxViewParams);
|
|
begin
|
|
Diagram.Styles.GetValueParams(GetItemSeriesIndex(AIndex), GetItemValueIndex(AIndex), AParams);
|
|
{ if not ItemLegendKeyBorderIsValueBorder then
|
|
AParams.TextColor := Params.TextColor;}
|
|
end;
|
|
|
|
{ TcxGridChartDiagramValueCaptionViewInfo }
|
|
|
|
constructor TcxGridChartDiagramValueCaptionViewInfo.Create(AValueViewInfo: TcxGridChartDiagramValueViewInfo);
|
|
begin
|
|
inherited Create(AValueViewInfo.GridViewInfo);
|
|
FValueViewInfo := AValueViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueCaptionViewInfo.GetAlignmentHorz: TAlignment;
|
|
begin
|
|
Result := taCenter;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueCaptionViewInfo.GetAlignmentVert: TcxAlignmentVert;
|
|
begin
|
|
Result := vaCenter;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueCaptionViewInfo.CalculateHeight: Integer;
|
|
begin
|
|
Result := TextHeight;
|
|
if HasVisualCompensation then Inc(Result, 2 * cxTextOffset);
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueCaptionViewInfo.CalculateWidth: Integer;
|
|
begin
|
|
Result := TextWidthWithOffset;
|
|
if HasVisualCompensation then Inc(Result, 2 * cxTextOffset);
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueCaptionViewInfo.GetText: string;
|
|
begin
|
|
Result := FValueViewInfo.GetCaptionText;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueCaptionViewInfo.GetTextAreaBounds: TRect;
|
|
begin
|
|
Result := ContentBounds;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueCaptionViewInfo.GetTextAttributes(AForPainting: Boolean): Integer;
|
|
begin
|
|
Result := inherited GetTextAttributes(AForPainting) or cxDontClip;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramValueCaptionViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
FValueViewInfo.GetCaptionViewParams(AParams);
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueCaptionViewInfo.GetVisible: Boolean;
|
|
begin
|
|
Result := FValueViewInfo.HasCaption;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueCaptionViewInfo.HasBackground: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueCaptionViewInfo.HasVisualCompensation: Boolean;
|
|
begin
|
|
Result := FValueViewInfo.HasCaptionVisualCompensation;
|
|
end;
|
|
|
|
{ TcxGridChartDiagramValueViewInfo }
|
|
|
|
constructor TcxGridChartDiagramValueViewInfo.Create(ADiagramViewInfo: TcxGridChartDiagramViewInfo;
|
|
ASeriesIndex, AVisibleValueIndex: Integer);
|
|
begin
|
|
inherited Create(ADiagramViewInfo.GridViewInfo);
|
|
FDiagramViewInfo := ADiagramViewInfo;
|
|
FSeriesIndex := ASeriesIndex;
|
|
FVisibleValueIndex := AVisibleValueIndex;
|
|
FCaptionViewInfo := GetCaptionViewInfoClass.Create(Self);
|
|
end;
|
|
|
|
destructor TcxGridChartDiagramValueViewInfo.Destroy;
|
|
begin
|
|
FCaptionViewInfo.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.GetController: TcxGridChartController;
|
|
begin
|
|
Result := TcxGridChartController(inherited Controller);
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.GetDiagram: TcxGridChartDiagram;
|
|
begin
|
|
Result := FDiagramViewInfo.Diagram;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.GetSeries: TcxGridChartSeries;
|
|
begin
|
|
Result := GridView.VisibleSeries[FSeriesIndex];
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.GetValueIndex: Integer;
|
|
begin
|
|
Result := DiagramViewInfo.GetValueIndex(VisibleValueIndex);
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.CanShowHint: Boolean;
|
|
begin
|
|
Result := GridView.OptionsBehavior.ValueHints;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.CustomDraw(ACanvas: TcxCanvas): Boolean;
|
|
begin
|
|
Result := inherited CustomDraw(ACanvas);
|
|
if not Result then
|
|
begin
|
|
Series.DoCustomDrawValue(ACanvas, Self, Result);
|
|
if not Result then
|
|
Diagram.DoCustomDrawValue(ACanvas, Self, Result);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.GetCaptionViewInfoClass: TcxGridChartDiagramValueCaptionViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartDiagramValueCaptionViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.GetCaptionText: string;
|
|
begin
|
|
Result := DiagramViewInfo.GetValueCaption(SeriesIndex, VisibleValueIndex);
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramValueViewInfo.GetCaptionViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
Diagram.Styles.GetViewParams(dsValueCaptions, nil, nil, AParams);
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.GetCellBoundsForHint: TRect;
|
|
begin
|
|
Result := Bounds;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.GetHintText: string;
|
|
begin
|
|
Result := Controller.GetValueHintText(Series, ValueIndex);
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.GetHintTextRect(const AMousePos: TPoint): TRect;
|
|
begin
|
|
Result.TopLeft := AMousePos;
|
|
Inc(Result.Top, ValueHintOffset);
|
|
Result.BottomRight := Result.TopLeft;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
|
|
begin
|
|
Result := TcxGridChartValueHitTest;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.GetHotTrack: Boolean;
|
|
begin
|
|
Result := GridView.OptionsBehavior.GetValueHotTrack(ValueIndex);
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.GetIsDesignSelected: Boolean;
|
|
begin
|
|
Result := GridView.IsDesigning and
|
|
Controller.DesignController.IsObjectSelected(Series);
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramValueViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
Diagram.Styles.GetValueParams(SeriesIndex, ValueIndex, AParams);
|
|
if State <> gcsNone then
|
|
AParams.Color := GetHotColor(AParams.Color);
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.HasCaption: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.HasCaptionVisualCompensation: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.HasCustomDraw: Boolean;
|
|
begin
|
|
Result := Series.HasCustomDrawValue or Diagram.HasCustomDrawValue;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.HasHintPoint(const P: TPoint): Boolean;
|
|
begin
|
|
Result := HasPoint(P);
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramValueViewInfo.InitHitTest(AHitTest: TcxCustomGridHitTest);
|
|
begin
|
|
inherited;
|
|
TcxGridChartValueHitTest(AHitTest).CanDrillDown := Controller.IsDataDrillDownPossible(ValueIndex);
|
|
TcxGridChartValueHitTest(AHitTest).Series := Series;
|
|
TcxGridChartValueHitTest(AHitTest).ValueIndex := ValueIndex;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.IsHintForText: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.IsHintMultiLine: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramValueViewInfo.StateChanged(APrevState: TcxGridCellState);
|
|
begin
|
|
CalculateParamsNeeded;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramValueViewInfo.Calculate(ALeftBound, ATopBound: Integer;
|
|
AWidth: Integer = -1; AHeight: Integer = -1);
|
|
begin
|
|
inherited;
|
|
if HasCaption then
|
|
CaptionViewInfo.Calculate(CalculateCaptionBounds);
|
|
end;
|
|
|
|
function TcxGridChartDiagramValueViewInfo.MouseDown(AHitTest: TcxCustomGridHitTest;
|
|
AButton: TMouseButton; AShift: TShiftState): Boolean;
|
|
begin
|
|
Result := inherited MouseDown(AHitTest, AButton, AShift);
|
|
if not (ssDouble in AShift) then
|
|
if GridView.IsDesigning then
|
|
if AButton = mbLeft then
|
|
begin
|
|
Controller.DesignController.SelectObject(Series, not (ssShift in AShift));
|
|
Result := True;
|
|
end
|
|
else
|
|
else
|
|
begin
|
|
if AButton = mbLeft then
|
|
Result := Series.DoValueClick(ValueIndex);
|
|
if (AHitTest as TcxGridChartValueHitTest).CanDrillDown then
|
|
case AButton of
|
|
mbLeft:
|
|
if not Result then
|
|
Result := Controller.DoDataDrillDown(ValueIndex);
|
|
mbRight:
|
|
if GridView.OptionsCustomize.DataDrillUpMethod = ddumValueMouseRightButtonClick then
|
|
Result := Controller.DoDataDrillUp;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartDiagramViewInfo }
|
|
|
|
constructor TcxGridChartDiagramViewInfo.Create(AGridViewInfo: TcxCustomGridViewInfo;
|
|
ADiagram: TcxGridChartDiagram);
|
|
begin
|
|
inherited Create(AGridViewInfo);
|
|
FDiagram := ADiagram;
|
|
FValueViewInfos := TList.Create;
|
|
end;
|
|
|
|
destructor TcxGridChartDiagramViewInfo.Destroy;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to ValueViewInfoCount - 1 do
|
|
ValueViewInfos[I].Free;
|
|
FValueViewInfos.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartDiagramViewInfo.GetCategory(AIndex: Integer): string;
|
|
begin
|
|
Result := GridView.Categories.VisibleDisplayTexts[AIndex];
|
|
end;
|
|
|
|
function TcxGridChartDiagramViewInfo.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
function TcxGridChartDiagramViewInfo.GetSeries(AIndex: Integer): TcxGridChartSeries;
|
|
begin
|
|
Result := GridView.VisibleSeries[AIndex];
|
|
end;
|
|
|
|
function TcxGridChartDiagramViewInfo.GetSeriesCount: Integer;
|
|
begin
|
|
Result := GridView.VisibleSeriesCount;
|
|
end;
|
|
|
|
function TcxGridChartDiagramViewInfo.GetValueCount: Integer;
|
|
begin
|
|
Result := ViewData.VisibleCategoryCount;
|
|
end;
|
|
|
|
function TcxGridChartDiagramViewInfo.GetValueViewInfoValue(Index: Integer): TcxGridChartDiagramValueViewInfo;
|
|
begin
|
|
Result := TcxGridChartDiagramValueViewInfo(FValueViewInfos[Index]);
|
|
end;
|
|
|
|
function TcxGridChartDiagramViewInfo.GetValueViewInfoCount: Integer;
|
|
begin
|
|
Result := FValueViewInfos.Count;
|
|
end;
|
|
|
|
function TcxGridChartDiagramViewInfo.GetViewData: TcxGridChartViewData;
|
|
begin
|
|
Result := GridView.ViewData;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
Diagram.Styles.GetBackgroundParams(AParams);
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramViewInfo.InitHitTest(AHitTest: TcxCustomGridHitTest);
|
|
begin
|
|
inherited;
|
|
(AHitTest as TcxCustomGridChartDiagramHitTest).Diagram := Diagram;
|
|
end;
|
|
|
|
function TcxGridChartDiagramViewInfo.CreateValueViewInfo(ASeriesIndex, AVisibleValueIndex: Integer): TcxGridChartDiagramValueViewInfo;
|
|
begin
|
|
Result := GetValueViewInfoClass.Create(Self, ASeriesIndex, AVisibleValueIndex);
|
|
FValueViewInfos.Add(Result);
|
|
end;
|
|
|
|
function TcxGridChartDiagramViewInfo.GetValue(ASeriesIndex, AIndex: Integer): Variant;
|
|
begin
|
|
Result := GridView.VisibleSeries[ASeriesIndex].VisibleValues[AIndex];
|
|
end;
|
|
|
|
function TcxGridChartDiagramViewInfo.GetValueCaption(ASeriesIndex, AVisibleValueIndex: Integer): string;
|
|
begin
|
|
Result := Diagram.GetValueCaption(GridView.VisibleSeries[ASeriesIndex],
|
|
GetValueIndex(AVisibleValueIndex));
|
|
end;
|
|
|
|
function TcxGridChartDiagramViewInfo.GetValueIndex(AVisibleValueIndex: Integer): Integer;
|
|
begin
|
|
Result := GridView.Controller.FirstVisibleCategoryIndex + AVisibleValueIndex;
|
|
end;
|
|
|
|
class function TcxGridChartDiagramViewInfo.GetValueViewInfoClass: TcxGridChartDiagramValueViewInfoClass;
|
|
begin
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxGridChartDiagramViewInfo.GetVisibleCategory(AIndex: Integer): string;
|
|
begin
|
|
Result := Categories[GetValueIndex(AIndex)];
|
|
end;
|
|
|
|
function TcxGridChartDiagramViewInfo.GetVisibleValue(ASeriesIndex, AIndex: Integer): Variant;
|
|
begin
|
|
Result := Values[ASeriesIndex, GetValueIndex(AIndex)];
|
|
end;
|
|
|
|
function TcxGridChartDiagramViewInfo.GetVisibleValueCount: Integer;
|
|
begin
|
|
Result := GridView.Controller.GetVisibleCategoryCount(True);
|
|
end;
|
|
|
|
function TcxGridChartDiagramViewInfo.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := nil;
|
|
for I := 0 to ValueViewInfoCount - 1 do
|
|
begin
|
|
Result := ValueViewInfos[I].GetHitTest(P);
|
|
if Result <> nil then Break;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartDiagramViewInfo.GetValueViewInfo(ASeriesIndex, AVisibleIndex: Integer): TcxGridChartDiagramValueViewInfo;
|
|
begin
|
|
Result := ValueViewInfos[GetValueViewInfoIndex(ASeriesIndex, AVisibleIndex)];
|
|
end;
|
|
|
|
{ TcxGridChartHistogramLegendViewInfo }
|
|
|
|
function TcxGridChartHistogramLegendViewInfo.GetDiagram: TcxGridChartHistogram;
|
|
begin
|
|
Result := TcxGridChartHistogram(inherited Diagram);
|
|
end;
|
|
|
|
function TcxGridChartHistogramLegendViewInfo.GetItemObjectIndex(AIndex: Integer): Integer;
|
|
begin
|
|
if ItemsInReverseOrder then
|
|
Result := Count - 1 - AIndex
|
|
else
|
|
Result := AIndex;
|
|
end;
|
|
|
|
function TcxGridChartHistogramLegendViewInfo.GetItemsInReverseOrder: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxGridChartHistogramLegendViewInfo.GetKind: TcxGridChartLegendKind;
|
|
begin
|
|
if Diagram.Values.GetVaryColorsByCategory then
|
|
Result := lkCategories
|
|
else
|
|
Result := lkSeries;
|
|
end;
|
|
|
|
{ TcxGridChartHistogramValueViewInfo }
|
|
|
|
function TcxGridChartHistogramValueViewInfo.GetCategoryDirection: TcxDirection;
|
|
begin
|
|
Result := DiagramViewInfo.GetCategoryDirection;
|
|
end;
|
|
|
|
function TcxGridChartHistogramValueViewInfo.GetDiagramViewInfo: TcxGridChartHistogramViewInfo;
|
|
begin
|
|
Result := TcxGridChartHistogramViewInfo(inherited DiagramViewInfo);
|
|
end;
|
|
|
|
function TcxGridChartHistogramValueViewInfo.GetValueDirection: TcxDirection;
|
|
begin
|
|
Result := DiagramViewInfo.GetValueDirection(SeriesIndex, VisibleValueIndex);
|
|
end;
|
|
|
|
{ TcxGridChartHistogramAxisTitleViewInfo }
|
|
|
|
constructor TcxGridChartHistogramAxisTitleViewInfo.Create(AContainer: TcxGridChartHistogramTickMarkLabelsViewInfo;
|
|
ATitle: TcxCustomGridChartTitle);
|
|
begin
|
|
inherited Create(AContainer.GridViewInfo, ATitle);
|
|
FContainer := AContainer;
|
|
end;
|
|
|
|
function TcxGridChartHistogramAxisTitleViewInfo.GetTitle: TcxGridChartHistogramAxisTitle;
|
|
begin
|
|
Result := TcxGridChartHistogramAxisTitle(inherited Title);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramAxisTitleViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
FContainer.GetTitleViewParams(AParams);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramAxisTitleViewInfo.InitHitTest(AHitTest: TcxCustomGridHitTest);
|
|
begin
|
|
FContainer.DiagramViewInfo.InitHitTest(AHitTest);
|
|
inherited;
|
|
end;
|
|
|
|
{ TcxGridChartHistogramTickMarkLabelsViewInfo }
|
|
|
|
constructor TcxGridChartHistogramTickMarkLabelsViewInfo.Create(ADiagramViewInfo: TcxGridChartHistogramViewInfo);
|
|
begin
|
|
inherited Create(ADiagramViewInfo.GridViewInfo);
|
|
FDiagramViewInfo := ADiagramViewInfo;
|
|
FTitleViewInfo := GetTitleViewInfoClass.Create(Self, Axis.Title);
|
|
end;
|
|
|
|
destructor TcxGridChartHistogramTickMarkLabelsViewInfo.Destroy;
|
|
begin
|
|
FreeAndNil(FTitleViewInfo);
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.GetCaptionBounds(Index: Integer): TRect;
|
|
begin
|
|
Result := FCaptionBounds[Index];
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.GetCaptionHeight: Integer;
|
|
begin
|
|
if FCaptionHeight = 0 then
|
|
begin
|
|
CalculateParams;
|
|
Canvas.Font := Params.Font;
|
|
FCaptionHeight := Canvas.TextHeight('Qq');
|
|
end;
|
|
Result := FCaptionHeight;
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.GetCaptionWidth(Index: Integer): Integer;
|
|
begin
|
|
if Index >= Length(FCaptionWidths) then
|
|
SetLength(FCaptionWidths, Index + 1);
|
|
if FCaptionWidths[Index] = 0 then
|
|
begin
|
|
CalculateParams;
|
|
Canvas.Font := Params.Font;
|
|
FCaptionWidths[Index] := Canvas.TextWidth(Captions[Index]);
|
|
end;
|
|
Result := FCaptionWidths[Index];
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.GetDiagram: TcxGridChartHistogram;
|
|
begin
|
|
Result := FDiagramViewInfo.Diagram;
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.GetIsVertical: Boolean;
|
|
begin
|
|
Result := Position in [cppLeft, cppRight];
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramTickMarkLabelsViewInfo.SetCaptionBounds(Index: Integer;
|
|
const Value: TRect);
|
|
begin
|
|
FCaptionBounds[Index] := Value;
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartHistogramTickMarkLabelsPainter;
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.GetTitleViewInfoClass: TcxGridChartHistogramAxisTitleViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartHistogramAxisTitleViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.GetCaption(Index: Integer): string;
|
|
begin
|
|
Result := Values[Index];
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.CalculateCaptionBounds(AIndex: Integer): TRect;
|
|
var
|
|
ACaptionWidth, ADirection: Integer;
|
|
begin
|
|
Result := ContentBounds;
|
|
if IsVertical then
|
|
begin
|
|
Result.Top := GetCaptionPosition(AIndex) - CaptionHeight div 2;
|
|
Result.Bottom := Result.Top + CaptionHeight;
|
|
end
|
|
else
|
|
begin
|
|
ACaptionWidth := CaptionWidths[AIndex];
|
|
Result.Left := GetCaptionPosition(AIndex) - ACaptionWidth div 2;
|
|
Result.Right := Result.Left + ACaptionWidth;
|
|
if IsTwoRowLayout then
|
|
begin
|
|
if IsReverseOrder then
|
|
ADirection := -1
|
|
else
|
|
ADirection := 1;
|
|
if AIndex > 0 then
|
|
Result.Left := Max(Result.Left, GetCaptionPosition(AIndex - ADirection) + cxTextOffset);
|
|
if AIndex < Count - 1 then
|
|
Result.Right := Min(Result.Right, GetCaptionPosition(AIndex + ADirection) - cxTextOffset);
|
|
if Odd(AIndex) then
|
|
Result.Top := Result.Bottom - CaptionHeight;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramTickMarkLabelsViewInfo.CalculateCaptionsBounds;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
SetLength(FCaptionBounds, Count);
|
|
for I := 0 to Count - 1 do
|
|
CaptionBounds[I] := CalculateCaptionBounds(I);
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.CalculateHeight(
|
|
AWidth, ALeftReduction, ARightReduction: Integer): Integer;
|
|
begin
|
|
IsTwoRowLayout := CalculateIsTwoRowLayout(AWidth, ALeftReduction, ARightReduction);
|
|
if IsVertical then
|
|
Result := 0
|
|
else
|
|
begin
|
|
if CaptionsVisible then
|
|
begin
|
|
Result := CaptionHeight;
|
|
if IsTwoRowLayout then
|
|
Inc(Result, 2 * cxTextOffset + CaptionHeight);
|
|
end
|
|
else
|
|
Result := 0;
|
|
if TitleViewInfo.Visible then
|
|
begin
|
|
if CaptionsVisible then
|
|
Inc(Result, ChartPartOffset);
|
|
Inc(Result, TitleViewInfo.Height);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.CalculateWidth: Integer;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
if IsVertical then
|
|
begin
|
|
Result := 0;
|
|
if CaptionsVisible then
|
|
for I := 0 to Count - 1 do
|
|
Result := Max(Result, CaptionWidths[I]);
|
|
if TitleViewInfo.Visible then
|
|
begin
|
|
if CaptionsVisible then
|
|
Inc(Result, ChartPartOffset);
|
|
Inc(Result, TitleViewInfo.Width);
|
|
end;
|
|
end
|
|
else
|
|
Result := 0;
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.CalculateIsTwoRowLayout(
|
|
AWidth, ALeftReduction, ARightReduction: Integer): Boolean;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := False;
|
|
if IsVertical or (Count <= 1) then Exit;
|
|
AWidth := GetCaptionSpace(AWidth, ALeftReduction, ARightReduction);
|
|
for I := 0 to Count - 1 do
|
|
begin
|
|
Result := CaptionWidths[I] > AWidth;
|
|
if Result then Exit;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramTickMarkLabelsViewInfo.CalculateTitleBounds(out ATitleBounds, AContentBounds: TRect);
|
|
begin
|
|
AContentBounds := CalculateContentBounds;
|
|
if TitleViewInfo.Visible then
|
|
begin
|
|
PositionRect(ATitleBounds, AContentBounds, TitleViewInfo.Width, TitleViewInfo.Height,
|
|
ChartPartOffset, Position);
|
|
with DiagramViewInfo.PlotBounds do
|
|
if IsVertical then
|
|
begin
|
|
ATitleBounds.Top := Top;
|
|
ATitleBounds.Bottom := Bottom;
|
|
end
|
|
else
|
|
begin
|
|
ATitleBounds.Left := Left;
|
|
ATitleBounds.Right := Right;
|
|
end;
|
|
AlignRect(ATitleBounds, TitleViewInfo.Width, TitleViewInfo.Height, not IsVertical,
|
|
TitleViewInfo.Alignment);
|
|
end
|
|
else
|
|
SetRectEmpty(ATitleBounds);
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.GetAlignmentHorz: TAlignment;
|
|
begin
|
|
if IsVertical then
|
|
if Position = cppLeft then
|
|
Result := taRightJustify
|
|
else
|
|
Result := taLeftJustify
|
|
else
|
|
Result := taCenter;
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.GetCaptionsVisible: Boolean;
|
|
begin
|
|
Result := Axis.TickMarkLabels;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramTickMarkLabelsViewInfo.GetEdgeCaptionsReductions(
|
|
var ALeftReduction, ARightReduction: Integer);
|
|
begin
|
|
ALeftReduction := Max(ALeftReduction, CaptionWidths[0] div 2);
|
|
ARightReduction := Max(ARightReduction, CaptionWidths[Count - 1] div 2);
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.GetTextAttributes(AForPainting: Boolean): Integer;
|
|
begin
|
|
Result := inherited GetTextAttributes(AForPainting) or cxDontClip or cxShowEndEllipsis;
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.GetVisible: Boolean;
|
|
begin
|
|
Result := CaptionsVisible or TitleViewInfo.Visible;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramTickMarkLabelsViewInfo.Calculate(ALeftBound, ATopBound: Integer;
|
|
AWidth: Integer = -1; AHeight: Integer = -1);
|
|
var
|
|
ATitleBounds: TRect;
|
|
begin
|
|
inherited;
|
|
CalculateTitleBounds(ATitleBounds, FContentBounds);
|
|
CalculateCaptionsBounds;
|
|
if TitleViewInfo.Visible then
|
|
TitleViewInfo.Calculate(ATitleBounds);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramTickMarkLabelsViewInfo.FitCaptionsHorz(AWidth: Integer;
|
|
var ALeftReduction, ARightReduction: Integer);
|
|
var
|
|
ACaptionSpace, ALeftOffset, ARightOffset: Integer;
|
|
begin
|
|
if not CaptionsVisible then Exit;
|
|
if IsTwoRowLayout and not IsEdgeCaptions then
|
|
begin
|
|
ACaptionSpace := GetCaptionSpace(AWidth, ALeftReduction, ARightReduction);
|
|
ALeftOffset := Max(0, (CaptionWidths[0] - ACaptionSpace) div 2 - ALeftReduction);
|
|
ARightOffset := Max(0, (CaptionWidths[Count - 1] - ACaptionSpace) div 2 - ARightReduction);
|
|
|
|
Inc(ALeftReduction, MulDiv((2 * ARightOffset + (4 * Count - 2) * ALeftOffset), 1, 4 * Count - 4));
|
|
Inc(ARightReduction, MulDiv((2 * ALeftOffset + (4 * Count - 2) * ARightOffset), 1, 4 * Count - 4));
|
|
end
|
|
else
|
|
if IsEdgeCaptions and (Count <> 0) then
|
|
GetEdgeCaptionsReductions(ALeftReduction, ARightReduction);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramTickMarkLabelsViewInfo.FitCaptionsVert(
|
|
var ATopReduction, ABottomReduction: Integer);
|
|
begin
|
|
if not CaptionsVisible then Exit;
|
|
if IsEdgeCaptions then
|
|
begin
|
|
ATopReduction := Max(ATopReduction, CaptionHeight div 2);
|
|
ABottomReduction := Max(ABottomReduction, CaptionHeight div 2);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.GetCaptionSpace(
|
|
AWidth, ALeftReduction, ARightReduction: Integer): Integer;
|
|
var
|
|
ACount: Integer;
|
|
begin
|
|
ACount := Count;
|
|
if IsEdgeCaptions then
|
|
begin
|
|
Dec(ACount);
|
|
GetEdgeCaptionsReductions(ALeftReduction, ARightReduction);
|
|
end;
|
|
Dec(AWidth, ALeftReduction + ARightReduction);
|
|
Result := AWidth div ACount - 4 * cxTextOffset;
|
|
end;
|
|
|
|
function TcxGridChartHistogramTickMarkLabelsViewInfo.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
|
|
begin
|
|
Result := FTitleViewInfo.GetHitTest(P);
|
|
end;
|
|
|
|
{ TcxGridChartHistogramCategoryAxisTitleViewInfo }
|
|
|
|
function TcxGridChartHistogramCategoryAxisTitleViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
|
|
begin
|
|
Result := TcxGridChartHistogramCategoryAxisTitleHitTest;
|
|
end;
|
|
|
|
{ TcxGridChartHistogramCategoryTickMarkLabelsViewInfo }
|
|
|
|
function TcxGridChartHistogramCategoryTickMarkLabelsViewInfo.GetTitleViewInfoClass: TcxGridChartHistogramAxisTitleViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartHistogramCategoryAxisTitleViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartHistogramCategoryTickMarkLabelsViewInfo.GetCount: Integer;
|
|
begin
|
|
Result := DiagramViewInfo.VisibleValueCount;
|
|
end;
|
|
|
|
function TcxGridChartHistogramCategoryTickMarkLabelsViewInfo.GetIsReverseOrder: Boolean;
|
|
begin
|
|
Result := DiagramViewInfo.IsCategoriesInReverseOrder;
|
|
end;
|
|
|
|
function TcxGridChartHistogramCategoryTickMarkLabelsViewInfo.GetValue(Index: Integer): Variant;
|
|
begin
|
|
Result := DiagramViewInfo.VisibleCategories[Index];
|
|
end;
|
|
|
|
function TcxGridChartHistogramCategoryTickMarkLabelsViewInfo.GetAxis: TcxGridChartHistogramAxis;
|
|
begin
|
|
Result := Diagram.AxisCategory;
|
|
end;
|
|
|
|
function TcxGridChartHistogramCategoryTickMarkLabelsViewInfo.GetCaptionPosition(AIndex: Integer): Integer;
|
|
begin
|
|
Result := DiagramViewInfo.GetUnitOffset(DiagramViewInfo.GetCategoryTickMarkLabelOffsetUnits(AIndex));
|
|
end;
|
|
|
|
function TcxGridChartHistogramCategoryTickMarkLabelsViewInfo.GetIsEdgeCaptions: Boolean;
|
|
begin
|
|
Result := DiagramViewInfo.IsEdgeCategoryTickMarkLabels;
|
|
end;
|
|
|
|
function TcxGridChartHistogramCategoryTickMarkLabelsViewInfo.GetPosition: TcxGridChartAxisPosition;
|
|
begin
|
|
Result := DiagramViewInfo.CategoryAxisPosition;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramCategoryTickMarkLabelsViewInfo.GetTitleViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
Diagram.Styles.GetViewParams(dsCategoryAxisTitle, nil, nil, AParams);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramCategoryTickMarkLabelsViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
Diagram.Styles.GetViewParams(dsCategoryAxis, nil, nil, AParams);
|
|
end;
|
|
|
|
{ TcxGridChartHistogramValueAxisTitleViewInfo }
|
|
|
|
function TcxGridChartHistogramValueAxisTitleViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
|
|
begin
|
|
Result := TcxGridChartHistogramValueAxisTitleHitTest;
|
|
end;
|
|
|
|
{ TcxGridChartHistogramValueTickMarkLabelsViewInfo }
|
|
|
|
function TcxGridChartHistogramValueTickMarkLabelsViewInfo.GetAxisValue: TcxGridChartHistogramAxisValue;
|
|
begin
|
|
Result := TcxGridChartHistogramAxisValue(inherited Axis);
|
|
end;
|
|
|
|
function TcxGridChartHistogramValueTickMarkLabelsViewInfo.GetTitleViewInfoClass: TcxGridChartHistogramAxisTitleViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartHistogramValueAxisTitleViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartHistogramValueTickMarkLabelsViewInfo.GetCaption(Index: Integer): string;
|
|
begin
|
|
Result := Axis.GetTickMarkLabel(Values[Index]);
|
|
end;
|
|
|
|
function TcxGridChartHistogramValueTickMarkLabelsViewInfo.GetCount: Integer;
|
|
begin
|
|
Result := DiagramViewInfo.ValueMarkCount;
|
|
end;
|
|
|
|
function TcxGridChartHistogramValueTickMarkLabelsViewInfo.GetIsReverseOrder: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxGridChartHistogramValueTickMarkLabelsViewInfo.GetValue(Index: Integer): Variant;
|
|
begin
|
|
Result := DiagramViewInfo.ValueMarkValues[Index];
|
|
end;
|
|
|
|
function TcxGridChartHistogramValueTickMarkLabelsViewInfo.GetAxis: TcxGridChartHistogramAxis;
|
|
begin
|
|
Result := Diagram.AxisValue;
|
|
end;
|
|
|
|
function TcxGridChartHistogramValueTickMarkLabelsViewInfo.GetCaptionPosition(AIndex: Integer): Integer;
|
|
begin
|
|
Result := DiagramViewInfo.ValueMarkPositions[AIndex];
|
|
end;
|
|
|
|
function TcxGridChartHistogramValueTickMarkLabelsViewInfo.GetIsEdgeCaptions: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TcxGridChartHistogramValueTickMarkLabelsViewInfo.GetPosition: TcxGridChartAxisPosition;
|
|
begin
|
|
Result := DiagramViewInfo.ValueAxisPosition;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramValueTickMarkLabelsViewInfo.GetTitleViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
Diagram.Styles.GetViewParams(dsValueAxisTitle, nil, nil, AParams);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramValueTickMarkLabelsViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
Diagram.Styles.GetViewParams(dsValueAxis, nil, nil, AParams);
|
|
end;
|
|
|
|
{ TcxGridChartHistogramViewInfo }
|
|
|
|
constructor TcxGridChartHistogramViewInfo.Create(AGridViewInfo: TcxCustomGridViewInfo;
|
|
ADiagram: TcxGridChartDiagram);
|
|
begin
|
|
inherited;
|
|
FCategoryTickMarkLabelsViewInfo := GetCategoryTickMarkLabelsViewInfoClass.Create(Self);
|
|
FValueTickMarkLabelsViewInfo := GetValueTickMarkLabelsViewInfoClass.Create(Self);
|
|
end;
|
|
|
|
destructor TcxGridChartHistogramViewInfo.Destroy;
|
|
begin
|
|
FValueTickMarkLabelsViewInfo.Free;
|
|
FCategoryTickMarkLabelsViewInfo.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetCategoryAxisColor: TColor;
|
|
var
|
|
AParams: TcxViewParams;
|
|
begin
|
|
Diagram.Styles.GetViewParams(dsCategoryAxis, nil, nil, AParams);
|
|
Result := AParams.Color;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetCategoryGridLineColor: TColor;
|
|
var
|
|
AParams: TcxViewParams;
|
|
begin
|
|
Diagram.Styles.GetViewParams(dsCategoryGridLines, nil, nil, AParams);
|
|
Result := AParams.Color;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetCategoryMarkCount: Integer;
|
|
begin
|
|
Result := Length(FCategoryMarks);
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetCategoryMarkPosition(Index: Integer): Integer;
|
|
begin
|
|
Result := FCategoryMarks[Index].Position;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetCategoryMarkValue(Index: Integer): Integer;
|
|
begin
|
|
Result := FCategoryMarks[Index].Value;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetDiagram: TcxGridChartHistogram;
|
|
begin
|
|
Result := TcxGridChartHistogram(inherited Diagram);
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetHasCategoryAxis: Boolean;
|
|
begin
|
|
Result := Diagram.AxisCategory.Visible and (VisibleValueCount <> 0);
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetHasCategoryGridLines: Boolean;
|
|
begin
|
|
Result := Diagram.AxisCategory.GridLines;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetHasValueAxis: Boolean;
|
|
begin
|
|
Result := Diagram.AxisValue.Visible and (VisibleValueCount <> 0);
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetHasValueGridLines: Boolean;
|
|
begin
|
|
Result := Diagram.AxisValue.GridLines;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetIsCategoriesInReverseOrder: Boolean;
|
|
begin
|
|
Result := Diagram.AxisCategory.CategoriesInReverseOrder;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetIsCategoryAxisHorz: Boolean;
|
|
begin
|
|
Result := CategoryAxisPosition in [cppTop, cppBottom];
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetIsValueAxisVert: Boolean;
|
|
begin
|
|
Result := ValueAxisPosition in [cppLeft, cppRight];
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetPlotBounds: TRect;
|
|
begin
|
|
if not FIsPlotBoundsCalculated then
|
|
begin
|
|
FPlotBounds := CalculatePlotBounds;
|
|
FIsPlotBoundsCalculated := True;
|
|
end;
|
|
Result := FPlotBounds;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetSumOfValues(AValueIndex: Integer): Variant;
|
|
begin
|
|
if FSumOfValues = nil then
|
|
SetLength(FSumOfValues, ValueCount);
|
|
if VarIsEmpty(FSumOfValues[AValueIndex]) then
|
|
FSumOfValues[AValueIndex] := CalculateSumOfValues(AValueIndex);
|
|
Result := FSumOfValues[AValueIndex];
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetValueAxisColor: TColor;
|
|
var
|
|
AParams: TcxViewParams;
|
|
begin
|
|
Diagram.Styles.GetViewParams(dsValueAxis, nil, nil, AParams);
|
|
Result := AParams.Color;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetValueGridLineColor: TColor;
|
|
var
|
|
AParams: TcxViewParams;
|
|
begin
|
|
Diagram.Styles.GetViewParams(dsValueGridLines, nil, nil, AParams);
|
|
Result := AParams.Color;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetValueMarkCount: Integer;
|
|
begin
|
|
Result := Length(FValueMarks);
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetValueMarkPosition(Index: Integer): Integer;
|
|
begin
|
|
Result := FValueMarks[Index].Position;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetValueMarkValue(Index: Integer): Extended;
|
|
begin
|
|
Result := FValueMarks[Index].Value;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetZeroValueOffset: Integer;
|
|
begin
|
|
Result := GetValueOffset(ZeroValue);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramViewInfo.SetCategoryMarkPosition(Index: Integer; Value: Integer);
|
|
begin
|
|
FCategoryMarks[Index].Position := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramViewInfo.SetValueMarkPosition(Index: Integer; Value: Integer);
|
|
begin
|
|
FValueMarks[Index].Position := Value;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetCategoryTickMarkLabelsViewInfoClass: TcxGridChartHistogramCategoryTickMarkLabelsViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartHistogramCategoryTickMarkLabelsViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartHistogramPainter;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetValueTickMarkLabelsViewInfoClass: TcxGridChartHistogramValueTickMarkLabelsViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartHistogramValueTickMarkLabelsViewInfo;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramViewInfo.DoCalculateParams;
|
|
begin
|
|
inherited;
|
|
GetPlotBackgroundParams(PlotParams);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramViewInfo.GetPlotBackgroundParams(out AParams: TcxViewParams);
|
|
begin
|
|
Diagram.Styles.GetViewParams(dsPlot, nil, nil, AParams);
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetCategoryDirection: TcxDirection;
|
|
begin
|
|
if IsCategoryAxisHorz then
|
|
if IsCategoriesInReverseOrder then
|
|
Result := dirLeft
|
|
else
|
|
Result := dirRight
|
|
else
|
|
if IsCategoriesInReverseOrder then
|
|
Result := dirDown
|
|
else
|
|
Result := dirUp;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetUnitAdjustedOffset(AIndex: Integer): Integer;
|
|
begin
|
|
Result := GetUnitOffset(AIndex);
|
|
if IsCategoryAxisHorz and (AIndex = UnitCount) or
|
|
not IsCategoryAxisHorz and (AIndex = 0) then
|
|
Dec(Result, CategoryGridLineWidth);
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetUnitOffset(AIndex: Integer): Integer;
|
|
var
|
|
AOffset: Integer;
|
|
begin
|
|
with PlotBounds do
|
|
if IsCategoryAxisHorz then
|
|
begin
|
|
AOffset := MulDiv(Right - Left, AIndex, UnitCount);
|
|
if IsCategoriesInReverseOrder then
|
|
Result := Right - AOffset
|
|
else
|
|
Result := Left + AOffset;
|
|
end
|
|
else
|
|
begin
|
|
AOffset := MulDiv(Bottom - Top, AIndex, UnitCount);
|
|
if IsCategoriesInReverseOrder then
|
|
Result := Top + AOffset
|
|
else
|
|
Result := Bottom - AOffset;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramViewInfo.CalculateMinMaxValues(out AMinValue, AMaxValue: Extended;
|
|
out AHasValuesOutOfRange: Boolean);
|
|
var
|
|
I, J: Integer;
|
|
AValue: Extended;
|
|
begin
|
|
if Diagram.AxisValue.MinMaxValues = mmvCustom then
|
|
begin
|
|
AMinValue := Diagram.AxisValue.MinValue;
|
|
AMaxValue := Diagram.AxisValue.MaxValue;
|
|
if AMinValue > AMaxValue then
|
|
begin
|
|
AValue := AMinValue;
|
|
AMinValue := AMaxValue;
|
|
AMaxValue := AValue;
|
|
end;
|
|
end
|
|
else
|
|
begin
|
|
AMinValue := 0;
|
|
AMaxValue := 0;
|
|
end;
|
|
AHasValuesOutOfRange := False;
|
|
|
|
for I := 0 to ValueCount - 1 do
|
|
for J := 0 to SeriesCount - 1 do
|
|
begin
|
|
AValue := Values[J, I];
|
|
if Diagram.AxisValue.MinMaxValues = mmvCustom then
|
|
begin
|
|
AHasValuesOutOfRange := (AValue < AMinValue) or (AValue > AMaxValue);
|
|
if AHasValuesOutOfRange then Exit;
|
|
end
|
|
else
|
|
if (Diagram.AxisValue.MinMaxValues = mmvAuto) and (I = 0) and (J = 0) then
|
|
begin
|
|
AMinValue := AValue;
|
|
AMaxValue := AValue;
|
|
end
|
|
else
|
|
begin
|
|
AMinValue := Min(AMinValue, AValue);
|
|
AMaxValue := Max(AMaxValue, AValue);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramViewInfo.CalculateMinMaxVisualValues(out AMinVisualValue, AMaxVisualValue: Extended);
|
|
begin
|
|
if (ValueStep = 0) or (Diagram.AxisValue.MinMaxValues = mmvCustom) then
|
|
begin
|
|
AMinVisualValue := MinValue;
|
|
AMaxVisualValue := MaxValue;
|
|
end
|
|
else
|
|
begin
|
|
AMinVisualValue := Floor(MinValue / ValueStep);
|
|
if NeedsMinMaxValuesOffset and
|
|
(MinValue <> 0) and (Fraction(MinValue / ValueStep) = 0) then
|
|
AMinVisualValue := AMinVisualValue - 1;
|
|
AMinVisualValue := AMinVisualValue * ValueStep;
|
|
|
|
AMaxVisualValue := Ceiling(MaxValue / ValueStep);
|
|
if NeedsMinMaxValuesOffset and
|
|
(MaxValue <> 0) and (Fraction(MaxValue / ValueStep) = 0) then
|
|
AMaxVisualValue := AMaxVisualValue + 1;
|
|
AMaxVisualValue := AMaxVisualValue * ValueStep;
|
|
end;
|
|
if AMaxVisualValue - AMinVisualValue = 0 then
|
|
AMaxVisualValue := AMinVisualValue + 1;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.CalculateSumOfValues(AValueIndex: Integer): Variant;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := 0;
|
|
for I := 0 to SeriesCount - 1 do
|
|
Result := Result + Abs(inherited GetValue(I, AValueIndex));
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.CalculateValueStep: Extended;
|
|
const
|
|
MaxStepCount = 10;
|
|
BaseStepCount = 3;
|
|
BaseSteps: array[0..BaseStepCount - 1] of Integer = (1, 2, 5);
|
|
var
|
|
AStep: Extended;
|
|
AIntMultiple10, ABaseStepIndex: Integer;
|
|
begin
|
|
AStep := (FMaxValue - FMinValue) / MaxStepCount;
|
|
if AStep = 0 then
|
|
begin
|
|
Result := 0;
|
|
Exit;
|
|
end;
|
|
AIntMultiple10 := Floor(Log10(AStep));
|
|
if (AIntMultiple10 < 0) and IsDataInteger then
|
|
AIntMultiple10 := 0;
|
|
ABaseStepIndex := 0;
|
|
repeat
|
|
Result := BaseSteps[ABaseStepIndex] * IntPower(10, AIntMultiple10);
|
|
if Result >= AStep then Break;
|
|
Inc(ABaseStepIndex);
|
|
if ABaseStepIndex = BaseStepCount then
|
|
begin
|
|
ABaseStepIndex := 0;
|
|
Inc(AIntMultiple10);
|
|
end;
|
|
until False;
|
|
CheckZero(Result);
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetValue(ASeriesIndex, AIndex: Integer): Variant;
|
|
var
|
|
I: Integer;
|
|
AIsPositive: Boolean;
|
|
AValue, ASum: Variant;
|
|
begin
|
|
Result := inherited GetValue(ASeriesIndex, AIndex);
|
|
case Diagram.Values.Stacking of
|
|
vsNormal:
|
|
for I := 0 to ASeriesIndex - 1 do
|
|
Result := Result + inherited GetValue(I, AIndex);
|
|
vs100Percent:
|
|
begin
|
|
AIsPositive := IsPositive(Result);
|
|
for I := 0 to ASeriesIndex - 1 do
|
|
begin
|
|
AValue := inherited GetValue(I, AIndex);
|
|
if IsPositive(AValue) = AIsPositive then
|
|
Result := Result + AValue;
|
|
end;
|
|
ASum := SumOfValues[AIndex];
|
|
if ASum = 0 then
|
|
Result := 0
|
|
else
|
|
Result := 100 * Result / ASum;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetValueDirection(ASeriesIndex, AVisibleValueIndex: Integer): TcxDirection;
|
|
begin
|
|
if IsValueAxisVert then
|
|
if IsValuePositive(ASeriesIndex, AVisibleValueIndex) then
|
|
Result := dirUp
|
|
else
|
|
Result := dirDown
|
|
else
|
|
if IsValuePositive(ASeriesIndex, AVisibleValueIndex) then
|
|
Result := dirRight
|
|
else
|
|
Result := dirLeft;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetValueOffset(const AValue: Variant): Integer;
|
|
var
|
|
AIsVertical: Boolean;
|
|
AAreaSize, AOffset: Integer;
|
|
begin
|
|
AIsVertical := IsValueAxisVert;
|
|
with PlotBounds do
|
|
begin
|
|
if AIsVertical then
|
|
AAreaSize := Bottom - Top - ValueGridLineWidth
|
|
else
|
|
AAreaSize := Right - Left - ValueGridLineWidth;
|
|
AOffset := AAreaSize * (AValue - MinVisualValue) / (MaxVisualValue - MinVisualValue);
|
|
if AIsVertical then
|
|
Result := Bottom - ValueGridLineWidth - AOffset
|
|
else
|
|
Result := Left + AOffset;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetZeroValue: Extended;
|
|
begin
|
|
Result := 0;
|
|
if Diagram.AxisValue.MinMaxValues <> mmvZeroBasedAuto then
|
|
begin
|
|
if Result < MinVisualValue then
|
|
Result := MinVisualValue;
|
|
if Result > MaxVisualValue then
|
|
Result := MaxVisualValue;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.IsDataInteger: Boolean;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to SeriesCount - 1 do
|
|
begin
|
|
Result := Series[I].DataBinding.IsValueTypeInteger;
|
|
if not Result then Exit;
|
|
end;
|
|
Result := True;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.IsValuePositive(ASeriesIndex, AVisibleValueIndex: Integer): Boolean;
|
|
begin
|
|
Result := IsPositive(VisibleValues[ASeriesIndex, AVisibleValueIndex] - ZeroValue);
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.NeedsMinMaxValuesOffset: Boolean;
|
|
begin
|
|
Result := Diagram.Values.Stacking <> vs100Percent;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramViewInfo.AddMark(var AMarks: TcxGridChartHistogramMarks;
|
|
const AValue: Variant);
|
|
begin
|
|
SetLength(AMarks, Length(AMarks) + 1);
|
|
AMarks[Length(AMarks) - 1].Value := AValue;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramViewInfo.AddCategoryMark(AValue: Integer);
|
|
begin
|
|
AddMark(FCategoryMarks, AValue);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramViewInfo.CalculateCategoryMarkPositions;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to CategoryMarkCount - 1 do
|
|
CategoryMarkPositions[I] := GetUnitAdjustedOffset(CategoryMarkValues[I]);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramViewInfo.CalculateCategoryMarkValues;
|
|
var
|
|
ACount, I: Integer;
|
|
begin
|
|
if VisibleValueCount = 0 then Exit;
|
|
ACount := VisibleValueCount;
|
|
if Diagram.AxisCategory.ValueAxisBetweenCategories then
|
|
Inc(ACount);
|
|
for I := 0 to ACount - 1 do
|
|
AddCategoryMark(GetCategoryTickMarkOffsetUnits(I, Diagram.AxisCategory.ValueAxisBetweenCategories));
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramViewInfo.AddValueMark(const AValue: Extended);
|
|
begin
|
|
AddMark(FValueMarks, AValue);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramViewInfo.CalculateValueMarkPositions;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to ValueMarkCount - 1 do
|
|
ValueMarkPositions[I] := GetValueOffset(ValueMarkValues[I]);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramViewInfo.CalculateValueMarkValues;
|
|
var
|
|
AValue: Extended;
|
|
begin
|
|
if ValueStep = 0 then Exit;
|
|
AValue := MinVisualValue;
|
|
repeat
|
|
CheckZero(AValue);
|
|
AddValueMark(AValue);
|
|
AValue := AValue + ValueStep;
|
|
until AValue > MaxVisualValue;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.CalculateCategoryMarkHeight: Integer;
|
|
begin
|
|
Result := MulDiv(CategoryTickMarkLabelsViewInfo.CaptionHeight, 1, 4);
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.CalculateValueMarkHeight: Integer;
|
|
begin
|
|
Result := MulDiv(ValueTickMarkLabelsViewInfo.CaptionHeight, 1, 4);
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.CalculatePlotBounds: TRect;
|
|
var
|
|
AOffsets: TRect;
|
|
begin
|
|
Result := Bounds;
|
|
SetRectEmpty(AOffsets);
|
|
CalculatePlotOffsets(Result.Right - Result.Left, AOffsets);
|
|
Inc(Result.Left, AOffsets.Left);
|
|
Dec(Result.Right, AOffsets.Right);
|
|
Inc(Result.Top, AOffsets.Top);
|
|
Dec(Result.Bottom, AOffsets.Bottom);
|
|
with Result do
|
|
begin
|
|
if Left > Right then Left := Right;
|
|
if Top > Bottom then Top := Bottom;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramViewInfo.CalculatePlotOffsets(APlotAreaWidth: Integer;
|
|
var AOffsets: TRect);
|
|
|
|
procedure ProcessVerticalAxisCaptions(ACaptionsViewInfo: TcxGridChartHistogramTickMarkLabelsViewInfo;
|
|
var AOffsets: TRect);
|
|
var
|
|
AOffset: Integer;
|
|
begin
|
|
if not ACaptionsViewInfo.Visible then Exit;
|
|
AOffset := TickMarkLabelsOffset + ACaptionsViewInfo.CalculateWidth;
|
|
if ACaptionsViewInfo.Position = cppLeft then
|
|
AOffsets.Left := Max(AOffsets.Left, AOffset)
|
|
else
|
|
AOffsets.Right := Max(AOffsets.Right, AOffset);
|
|
ACaptionsViewInfo.FitCaptionsVert(AOffsets.Top, AOffsets.Bottom);
|
|
end;
|
|
|
|
procedure ProcessHorizontalAxisCaptions(ACaptionsViewInfo: TcxGridChartHistogramTickMarkLabelsViewInfo;
|
|
var AOffsets: TRect; APlotAreaWidth: Integer);
|
|
var
|
|
AOffset: Integer;
|
|
begin
|
|
if not ACaptionsViewInfo.Visible then Exit;
|
|
AOffset := TickMarkLabelsOffset +
|
|
ACaptionsViewInfo.CalculateHeight(APlotAreaWidth, AOffsets.Left, AOffsets.Right);
|
|
if ACaptionsViewInfo.Position = cppTop then
|
|
AOffsets.Top := Max(AOffsets.Top, AOffset)
|
|
else
|
|
AOffsets.Bottom := Max(AOffsets.Bottom, AOffset);
|
|
ACaptionsViewInfo.FitCaptionsHorz(APlotAreaWidth, AOffsets.Left, AOffsets.Right);
|
|
end;
|
|
|
|
var
|
|
ACaptionsViewInfoHorz, ACaptionsViewInfoVert: TcxGridChartHistogramTickMarkLabelsViewInfo;
|
|
begin
|
|
if ValueTickMarkLabelsViewInfo.IsVertical then
|
|
begin
|
|
ACaptionsViewInfoHorz := CategoryTickMarkLabelsViewInfo;
|
|
ACaptionsViewInfoVert := ValueTickMarkLabelsViewInfo;
|
|
end
|
|
else
|
|
begin
|
|
ACaptionsViewInfoHorz := ValueTickMarkLabelsViewInfo;
|
|
ACaptionsViewInfoVert := CategoryTickMarkLabelsViewInfo;
|
|
end;
|
|
|
|
ProcessVerticalAxisCaptions(ACaptionsViewInfoVert, AOffsets);
|
|
ProcessHorizontalAxisCaptions(ACaptionsViewInfoHorz, AOffsets, APlotAreaWidth);
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetCategoryAxisBounds: TRect;
|
|
begin
|
|
Result := PlotBounds;
|
|
if IsCategoryAxisHorz then
|
|
begin
|
|
Result.Top := ZeroValueOffset;
|
|
Result.Bottom := Result.Top + CategoryAxisWidth;
|
|
end
|
|
else
|
|
begin
|
|
Result.Left := ZeroValueOffset;
|
|
Result.Right := Result.Left + CategoryAxisWidth;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetCategoryAxisPosition: TcxGridChartAxisPosition;
|
|
begin
|
|
Result := Diagram.GetCategoryAxisPosition;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetCategoryGridLineBounds(AIndex: Integer): TRect;
|
|
begin
|
|
Result := PlotBounds;
|
|
if IsCategoryAxisHorz then
|
|
begin
|
|
Result.Left := CategoryMarkPositions[AIndex];
|
|
Result.Right := Result.Left + CategoryGridLineWidth;
|
|
end
|
|
else
|
|
begin
|
|
Result.Top := CategoryMarkPositions[AIndex];
|
|
Result.Bottom := Result.Top + CategoryGridLineWidth;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetCategoryMarkBounds(Index: Integer): TRect;
|
|
var
|
|
AIsHorizontal: Boolean;
|
|
begin
|
|
AIsHorizontal := IsCategoryAxisHorz;
|
|
|
|
Result := CategoryAxisBounds;
|
|
if AIsHorizontal then
|
|
begin
|
|
Result.Left := CategoryMarkPositions[Index];
|
|
Result.Right := Result.Left + MarkWidth;
|
|
end
|
|
else
|
|
begin
|
|
Result.Top := CategoryMarkPositions[Index];
|
|
Result.Bottom := Result.Top + MarkWidth;
|
|
end;
|
|
|
|
if Diagram.AxisCategory.TickMarkKind in [tmkCross, tmkInside] then
|
|
if AIsHorizontal then
|
|
Dec(Result.Top, CategoryMarkHeight)
|
|
else
|
|
Inc(Result.Right, CategoryMarkHeight);
|
|
if Diagram.AxisCategory.TickMarkKind in [tmkCross, tmkOutside] then
|
|
if AIsHorizontal then
|
|
Inc(Result.Bottom, CategoryMarkHeight)
|
|
else
|
|
Dec(Result.Left, CategoryMarkHeight);
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetCategoryTickMarkLabelsBounds: TRect;
|
|
begin
|
|
Result := GetTickMarkLabelsBounds(CategoryAxisPosition);
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetTickMarkLabelsBounds(APosition: TcxGridChartAxisPosition): TRect;
|
|
begin
|
|
Result := Bounds;
|
|
case APosition of
|
|
cppLeft:
|
|
Result.Right := PlotBounds.Left - TickMarkLabelsOffset;
|
|
cppRight:
|
|
Result.Left := PlotBounds.Right + TickMarkLabelsOffset;
|
|
cppTop:
|
|
Result.Bottom := PlotBounds.Top - TickMarkLabelsOffset;
|
|
cppBottom:
|
|
Result.Top := PlotBounds.Bottom + TickMarkLabelsOffset;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetValueAxisBounds: TRect;
|
|
begin
|
|
Result := PlotBounds;
|
|
if IsValueAxisVert then
|
|
begin
|
|
if (ValueAxisPosition = cppLeft) xor IsCategoriesInReverseOrder then
|
|
Result.Left := CategoryMarkPositions[0]
|
|
else
|
|
Result.Left := CategoryMarkPositions[CategoryMarkCount - 1];
|
|
Result.Right := Result.Left + ValueAxisWidth;
|
|
end
|
|
else
|
|
begin
|
|
if (ValueAxisPosition = cppBottom) xor IsCategoriesInReverseOrder then
|
|
Result.Top := CategoryMarkPositions[0]
|
|
else
|
|
Result.Top := CategoryMarkPositions[CategoryMarkCount - 1];
|
|
Result.Bottom := Result.Top + ValueAxisWidth;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetValueAxisPosition: TcxGridChartAxisPosition;
|
|
begin
|
|
Result := Diagram.GetValueAxisPosition;
|
|
end;
|
|
|
|
{function TcxGridChartHistogramViewInfo.GetValueBounds(AValueIndex, ASeriesIndex: Integer): TRect;
|
|
var
|
|
ACategoryOffset, ACategoryOffsetStart, ACategoryOffsetFinish, AValueOffsetStart, AValueOffsetFinish: Integer;
|
|
begin
|
|
ACategoryOffset := GetValueOffsetUnits(AValueIndex, ASeriesIndex);
|
|
ACategoryOffsetStart := GetUnitOffset(ACategoryOffset);
|
|
ACategoryOffsetFinish := GetUnitOffset(ACategoryOffset + ValueSizeUnits);
|
|
AValueOffsetStart := ZeroValueOffset;
|
|
AValueOffsetFinish := GetValueOffset(Values[ASeriesIndex, AValueIndex]);
|
|
|
|
if IsValueAxisVert then
|
|
begin
|
|
Result.Left := ACategoryOffsetStart;
|
|
Result.Right := ACategoryOffsetFinish;
|
|
Result.Bottom := AValueOffsetStart;
|
|
Result.Top := AValueOffsetFinish;
|
|
CheckRectBounds(Result);
|
|
Inc(Result.Bottom, ValueGridLineWidth);
|
|
end
|
|
else
|
|
begin
|
|
Result.Bottom := ACategoryOffsetStart;
|
|
Result.Top := ACategoryOffsetFinish;
|
|
Result.Left := AValueOffsetStart;
|
|
Result.Right := AValueOffsetFinish;
|
|
CheckRectBounds(Result);
|
|
Inc(Result.Right, ValueGridLineWidth);
|
|
end;
|
|
end;}
|
|
|
|
function TcxGridChartHistogramViewInfo.GetValueGridLineBounds(AIndex: Integer): TRect;
|
|
begin
|
|
Result := PlotBounds;
|
|
if IsValueAxisVert then
|
|
begin
|
|
Result.Top := ValueMarkPositions[AIndex];
|
|
Result.Bottom := Result.Top + ValueGridLineWidth;
|
|
end
|
|
else
|
|
begin
|
|
Result.Left := ValueMarkPositions[AIndex];
|
|
Result.Right := Result.Left + ValueGridLineWidth;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetValueMarkBounds(Index: Integer): TRect;
|
|
var
|
|
AIsVertical: Boolean;
|
|
AMarkKind: TcxGridChartHistogramTickMarkKind;
|
|
begin
|
|
Result := ValueAxisBounds;
|
|
AIsVertical := IsValueAxisVert;
|
|
if AIsVertical then
|
|
begin
|
|
Result.Top := ValueMarkPositions[Index];
|
|
Result.Bottom := Result.Top + MarkWidth;
|
|
end
|
|
else
|
|
begin
|
|
Result.Left := ValueMarkPositions[Index];
|
|
Result.Right := Result.Left + MarkWidth;
|
|
end;
|
|
AMarkKind := Diagram.AxisValue.TickMarkKind;
|
|
if (AMarkKind = tmkCross) or
|
|
(ValueAxisPosition in [cppRight, cppTop]) and (AMarkKind = tmkInside) or
|
|
(ValueAxisPosition in [cppLeft, cppBottom]) and (AMarkKind = tmkOutside) then
|
|
if AIsVertical then
|
|
Dec(Result.Left, ValueMarkHeight)
|
|
else
|
|
Inc(Result.Bottom, ValueMarkHeight);
|
|
if (AMarkKind = tmkCross) or
|
|
(ValueAxisPosition in [cppRight, cppTop]) and (AMarkKind = tmkOutside) or
|
|
(ValueAxisPosition in [cppLeft, cppBottom]) and (AMarkKind = tmkInside) then
|
|
if AIsVertical then
|
|
Inc(Result.Right, ValueMarkHeight)
|
|
else
|
|
Dec(Result.Top, ValueMarkHeight);
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetValueTickMarkLabelsBounds: TRect;
|
|
begin
|
|
Result := GetTickMarkLabelsBounds(ValueAxisPosition);
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.CustomDrawPlot(ACanvas: TcxCanvas): Boolean;
|
|
begin
|
|
Result := False;
|
|
Diagram.DoCustomDrawPlot(ACanvas, Self, PlotBounds, Result);
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.DoCustomDrawPlot(ACanvas: TcxCanvas): Boolean;
|
|
begin
|
|
Result := HasCustomDrawPlot;
|
|
if Result then
|
|
begin
|
|
ACanvas.SetParams(PlotParams);
|
|
Result := CustomDrawPlot(ACanvas);
|
|
if not Result then
|
|
ACanvas.GetParams(PlotParams);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.HasCustomDrawPlot: Boolean;
|
|
begin
|
|
Result := Diagram.HasCustomDrawPlot;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramViewInfo.Calculate(const ABounds: TRect);
|
|
begin
|
|
inherited;
|
|
CalculateMinMaxValues(FMinValue, FMaxValue, FHasValuesOutOfRange);
|
|
FValueStep := CalculateValueStep;
|
|
CalculateMinMaxVisualValues(FMinVisualValue, FMaxVisualValue);
|
|
CalculateCategoryMarkValues;
|
|
CalculateValueMarkValues;
|
|
|
|
FCategoryMarkHeight := CalculateCategoryMarkHeight;
|
|
FValueMarkHeight := CalculateValueMarkHeight;
|
|
CalculateCategoryMarkPositions;
|
|
CalculateValueMarkPositions;
|
|
if CategoryTickMarkLabelsViewInfo.Visible then
|
|
CategoryTickMarkLabelsViewInfo.Calculate(GetCategoryTickMarkLabelsBounds);
|
|
if ValueTickMarkLabelsViewInfo.Visible then
|
|
ValueTickMarkLabelsViewInfo.Calculate(GetValueTickMarkLabelsBounds);
|
|
|
|
CalculateValues;
|
|
end;
|
|
|
|
function TcxGridChartHistogramViewInfo.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
|
|
begin
|
|
Result := inherited GetHitTest(P);
|
|
if Result = nil then
|
|
if PtInRect(PlotBounds, P) then
|
|
begin
|
|
Result := TcxGridChartHistogramPlotHitTest.Instance(P);
|
|
InitHitTest(Result);
|
|
end
|
|
else
|
|
begin
|
|
Result := CategoryTickMarkLabelsViewInfo.GetHitTest(P);
|
|
if Result = nil then
|
|
Result := ValueTickMarkLabelsViewInfo.GetHitTest(P);
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartColumnDiagramLegendViewInfo }
|
|
|
|
function TcxGridChartColumnDiagramLegendViewInfo.GetItemsInReverseOrder: Boolean;
|
|
begin
|
|
Result :=
|
|
(Diagram.GetCategoryAxisPosition in [cppTop, cppBottom]) and
|
|
Diagram.AxisCategory.CategoriesInReverseOrder or
|
|
not (Diagram.GetCategoryAxisPosition in [cppTop, cppBottom]) and
|
|
not Diagram.AxisCategory.CategoriesInReverseOrder;
|
|
end;
|
|
|
|
{ TcxGridChartColumnDiagramValueViewInfo }
|
|
|
|
function TcxGridChartColumnDiagramValueViewInfo.GetCaptionPosition: TcxGridChartColumnDiagramValueCaptionPosition;
|
|
begin
|
|
Result := DiagramViewInfo.Diagram.Values.CaptionPosition;
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagramValueViewInfo.GetDiagramViewInfo: TcxGridChartColumnDiagramViewInfo;
|
|
begin
|
|
Result := TcxGridChartColumnDiagramViewInfo(inherited DiagramViewInfo);
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagramValueViewInfo.CalculateCaptionBounds: TRect;
|
|
|
|
function GetVerticalValueCaptionBounds(ACaptionWidth, ACaptionHeight: Integer;
|
|
AIsUpDirection: Boolean): TRect;
|
|
begin
|
|
Result := ContentBounds;
|
|
with Result do
|
|
begin
|
|
Left := GetRangeCenter(Left, Right) - ACaptionWidth div 2;
|
|
Right := Left + ACaptionWidth;
|
|
case CaptionPosition of
|
|
cdvcpInsideBase:
|
|
if AIsUpDirection then
|
|
Top := Bottom - ACaptionHeight
|
|
else
|
|
Bottom := Top + ACaptionHeight;
|
|
cdvcpInsideEnd:
|
|
if AIsUpDirection then
|
|
Bottom := Top + ACaptionHeight
|
|
else
|
|
Top := Bottom - ACaptionHeight;
|
|
cdvcpOutsideEnd:
|
|
if AIsUpDirection then
|
|
begin
|
|
Bottom := Self.Bounds.Top;
|
|
Top := Bottom - ACaptionHeight;
|
|
end
|
|
else
|
|
begin
|
|
Top := Self.Bounds.Bottom;
|
|
Bottom := Top + ACaptionHeight;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function GetHorizontalValueCaptionBounds(ACaptionWidth, ACaptionHeight: Integer;
|
|
AIsRightDirection: Boolean): TRect;
|
|
begin
|
|
Result := ContentBounds;
|
|
with Result do
|
|
begin
|
|
Top := GetRangeCenter(Top, Bottom) - ACaptionHeight div 2;
|
|
Bottom := Top + ACaptionHeight;
|
|
case CaptionPosition of
|
|
cdvcpInsideBase:
|
|
if AIsRightDirection then
|
|
Right := Left + ACaptionWidth
|
|
else
|
|
Left := Right - ACaptionWidth;
|
|
cdvcpInsideEnd:
|
|
if AIsRightDirection then
|
|
Left := Right - ACaptionWidth
|
|
else
|
|
Right := Left + ACaptionWidth;
|
|
cdvcpOutsideEnd:
|
|
if AIsRightDirection then
|
|
begin
|
|
Left := Self.Bounds.Right;
|
|
Right := Left + ACaptionWidth;
|
|
end
|
|
else
|
|
begin
|
|
Right := Self.Bounds.Left;
|
|
Left := Right - ACaptionWidth;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
var
|
|
AIsPositive: Boolean;
|
|
begin
|
|
AIsPositive := DiagramViewInfo.IsValuePositive(SeriesIndex, VisibleValueIndex);
|
|
if DiagramViewInfo.IsValueAxisVert then
|
|
Result := GetVerticalValueCaptionBounds(CaptionViewInfo.CalculateWidth,
|
|
CaptionViewInfo.CalculateHeight, AIsPositive)
|
|
else
|
|
Result := GetHorizontalValueCaptionBounds(CaptionViewInfo.CalculateWidth,
|
|
CaptionViewInfo.CalculateHeight, AIsPositive);
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagramValueViewInfo.GetBorderColor(AIndex: TcxBorder): TColor;
|
|
begin
|
|
Result := Params.TextColor;
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagramValueViewInfo.GetBorders: TcxBorders;
|
|
begin
|
|
Result := cxBordersAll;
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagramValueViewInfo.GetBorderWidth(AIndex: TcxBorder): Integer;
|
|
begin
|
|
Result := DiagramViewInfo.Diagram.Values.BorderWidth;
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagramValueViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartColumnDiagramValuePainter;
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagramValueViewInfo.HasCaption: Boolean;
|
|
begin
|
|
Result := CaptionPosition <> cdvcpNone;
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagramValueViewInfo.HasCaptionVisualCompensation: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
{ TcxGridChartColumnDiagramViewInfo }
|
|
|
|
function TcxGridChartColumnDiagramViewInfo.GetDiagram: TcxGridChartColumnDiagram;
|
|
begin
|
|
Result := TcxGridChartColumnDiagram(inherited Diagram);
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagramViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartColumnDiagramPainter;
|
|
end;
|
|
|
|
class function TcxGridChartColumnDiagramViewInfo.GetValueViewInfoClass: TcxGridChartDiagramValueViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartColumnDiagramValueViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagramViewInfo.GetValueViewInfoIndex(ASeriesIndex, AVisibleIndex: Integer): Integer;
|
|
begin
|
|
Result := AVisibleIndex * SeriesCount + ASeriesIndex;
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagramViewInfo.GetCategoryTickMarkLabelOffsetUnits(AIndex: Integer): Integer;
|
|
begin
|
|
Result := GetCategoryTickMarkOffsetUnits(AIndex, False);
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagramViewInfo.GetCategoryTickMarkOffsetUnits(AIndex: Integer;
|
|
AValueAxisBetweenCategories: Boolean): Integer;
|
|
begin
|
|
if AValueAxisBetweenCategories then
|
|
Result := 0
|
|
else
|
|
Result := 1;
|
|
Result := GetValueGroupAreaSizeUnits * (Result + 2 * AIndex) div 2;
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagramViewInfo.GetUnitCount: Integer;
|
|
begin
|
|
Result := VisibleValueCount * GetValueGroupAreaSizeUnits;
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagramViewInfo.GetValueGroupAreaSizeUnits: Integer;
|
|
begin
|
|
Result := SeriesCount * ColumnDiagramValueSizeUnits + 2 * ColumnDiagramValueOffsetUnits;
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagramViewInfo.GetValueOffsetUnits(AVisibleValueIndex, ASeriesIndex: Integer): Integer;
|
|
begin
|
|
Result := AVisibleValueIndex * GetValueGroupAreaSizeUnits + ColumnDiagramValueOffsetUnits +
|
|
ASeriesIndex * ColumnDiagramValueSizeUnits;
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagramViewInfo.IsEdgeCategoryTickMarkLabels: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TcxGridChartColumnDiagramViewInfo.CalculateValues;
|
|
var
|
|
AValueIndex, ASeriesIndex: Integer;
|
|
begin
|
|
for AValueIndex := 0 to VisibleValueCount - 1 do
|
|
for ASeriesIndex := 0 to SeriesCount - 1 do
|
|
CreateValueViewInfo(ASeriesIndex, AValueIndex).Calculate(GetValueBounds(AValueIndex, ASeriesIndex));
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagramViewInfo.GetValueBounds(AVisibleValueIndex, ASeriesIndex: Integer): TRect;
|
|
var
|
|
ACategoryOffset, ACategoryOffsetStart, ACategoryOffsetFinish, AValueOffsetStart, AValueOffsetFinish: Integer;
|
|
begin
|
|
ACategoryOffset := GetValueOffsetUnits(AVisibleValueIndex, ASeriesIndex);
|
|
ACategoryOffsetStart := GetUnitOffset(ACategoryOffset);
|
|
ACategoryOffsetFinish := GetUnitOffset(ACategoryOffset + ColumnDiagramValueSizeUnits);
|
|
AValueOffsetStart := ZeroValueOffset;
|
|
AValueOffsetFinish := GetValueOffset(VisibleValues[ASeriesIndex, AVisibleValueIndex]);
|
|
|
|
if IsValueAxisVert then
|
|
begin
|
|
Result.Left := ACategoryOffsetStart;
|
|
Result.Right := ACategoryOffsetFinish;
|
|
Result.Bottom := AValueOffsetStart;
|
|
Result.Top := AValueOffsetFinish;
|
|
CheckRectBounds(Result);
|
|
Inc(Result.Bottom, ValueGridLineWidth);
|
|
end
|
|
else
|
|
begin
|
|
Result.Bottom := ACategoryOffsetStart;
|
|
Result.Top := ACategoryOffsetFinish;
|
|
Result.Left := AValueOffsetStart;
|
|
Result.Right := AValueOffsetFinish;
|
|
CheckRectBounds(Result);
|
|
Inc(Result.Right, ValueGridLineWidth);
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartLineDiagramLegendItemViewInfo }
|
|
|
|
function TcxGridChartLineDiagramLegendItemViewInfo.GetDiagram: TcxGridChartLineDiagram;
|
|
begin
|
|
Result := TcxGridChartLineDiagram(inherited Diagram);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramLegendItemViewInfo.GetLineStyle: TcxGridChartLineStyle;
|
|
begin
|
|
Result := Diagram.Values.GetLineStyle(Series);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramLegendItemViewInfo.GetLineWidth: Integer;
|
|
begin
|
|
Result := Diagram.Values.LineWidth;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramLegendItemViewInfo.GetMarkerSize: Integer;
|
|
begin
|
|
Result := Diagram.Values.MarkerSize;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramLegendItemViewInfo.GetMarkerStyle: TcxGridChartMarkerStyle;
|
|
begin
|
|
Result := Diagram.Values.GetMarkerStyle(Series);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramLegendItemViewInfo.CalculateHeight: Integer;
|
|
begin
|
|
Result := inherited CalculateHeight;
|
|
if LineStyle <> clsNone then
|
|
Result := Max(Result, LineWidth);
|
|
if MarkerStyle <> cmsNone then
|
|
Result := Max(Result, MarkerSize);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramLegendItemViewInfo.CalculateLegendKeyWidth: Integer;
|
|
begin
|
|
Result := 0;
|
|
if LineStyle <> clsNone then
|
|
Result := Max(Result, 20 + 10 * LineWidth);
|
|
if MarkerStyle <> cmsNone then
|
|
if LineStyle = clsNone then
|
|
Result := Max(Result, MarkerSize)
|
|
else
|
|
Result := Max(Result, 3 * MarkerSize);
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramLegendItemViewInfo.CalculateMarkerPoints;
|
|
begin
|
|
GetDiagramValueViewInfoClass.CalculateMarkerPointsEx(MarkerBounds, MarkerStyle,
|
|
MarkerPoints);
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramLegendItemViewInfo.DoCalculateParams;
|
|
begin
|
|
inherited;
|
|
TcxGridChartLineDiagramLegendViewInfo(Container).GetItemLegendKeyMarkerParams(Index, MarkerParams);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramLegendItemViewInfo.GetAlignmentVert: TcxAlignmentVert;
|
|
begin
|
|
Result := vaCenter;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramLegendItemViewInfo.GetDiagramValueViewInfoClass: TcxGridChartLineDiagramValueViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartLineDiagramValueViewInfoClass(Diagram.GetViewInfoClass.GetValueViewInfoClass);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramLegendItemViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartLineDiagramLegendItemPainter;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramLegendItemViewInfo.GetLineColor: TColor;
|
|
begin
|
|
Result := LegendKeyParams.Color;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramLegendItemViewInfo.GetLineStart: TPoint;
|
|
begin
|
|
with LegendKeyBounds do
|
|
begin
|
|
Result.X := Left + RoundDiv(LineWidth, 2);
|
|
Result.Y := GetRangeCenter(Top, Bottom);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramLegendItemViewInfo.GetLineFinish: TPoint;
|
|
begin
|
|
with LegendKeyBounds do
|
|
begin
|
|
Result.X := Right - RoundDiv(LineWidth, 2);
|
|
Result.Y := GetRangeCenter(Top, Bottom);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramLegendItemViewInfo.GetMarkerBounds: TRect;
|
|
begin
|
|
with LegendKeyBounds do
|
|
GetCenteredRect(Point(GetRangeCenter(Left, Right), GetRangeCenter(Top, Bottom)),
|
|
MarkerSize, MarkerSize, Result);
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramLegendItemViewInfo.Calculate(ALeftBound, ATopBound: Integer;
|
|
AWidth: Integer = -1; AHeight: Integer = -1);
|
|
begin
|
|
inherited;
|
|
CalculateMarkerPoints;
|
|
end;
|
|
|
|
{ TcxGridChartLineDiagramLegendViewInfo }
|
|
|
|
function TcxGridChartLineDiagramLegendViewInfo.GetItemClass: TcxGridChartLegendItemViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartLineDiagramLegendItemViewInfo;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramLegendViewInfo.GetItemLegendKeyMarkerParams(AIndex: Integer;
|
|
out AParams: TcxViewParams);
|
|
begin
|
|
TcxGridChartLineDiagram(Diagram).Styles.GetValueMarkerParams(GetItemSeriesIndex(AIndex),
|
|
GetItemValueIndex(AIndex), AParams);
|
|
end;
|
|
|
|
{ TcxGridChartLineDiagramValueViewInfo }
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetCaptionPosition: TcxGridChartLineDiagramValueCaptionPosition;
|
|
begin
|
|
Result := Diagram.Values.CaptionPosition;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetDiagram: TcxGridChartLineDiagram;
|
|
begin
|
|
Result := TcxGridChartLineDiagram(inherited Diagram);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetDiagramViewInfo: TcxGridChartLineDiagramViewInfo;
|
|
begin
|
|
Result := TcxGridChartLineDiagramViewInfo(inherited DiagramViewInfo);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetLineStyle: TcxGridChartLineStyle;
|
|
begin
|
|
Result := Diagram.Values.GetLineStyle(Series);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetLineWidth: Integer;
|
|
begin
|
|
Result := Diagram.Values.LineWidth;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetMarkerStyle: TcxGridChartMarkerStyle;
|
|
begin
|
|
Result := Diagram.Values.GetMarkerStyle(Series);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.CalculateCaptionBounds: TRect;
|
|
var
|
|
ACaptionWidth, ACaptionHeight: Integer;
|
|
begin
|
|
Result := MarkerBounds;
|
|
InflateRect(Result, LineDiagramCaptionOffset, LineDiagramCaptionOffset);
|
|
ACaptionWidth := CaptionViewInfo.CalculateWidth;
|
|
ACaptionHeight := CaptionViewInfo.CalculateHeight;
|
|
|
|
case CaptionPosition of
|
|
ldvcpLeft:
|
|
begin
|
|
Result.Right := Result.Left;
|
|
Dec(Result.Left, ACaptionWidth);
|
|
end;
|
|
ldvcpRight:
|
|
begin
|
|
Result.Left := Result.Right;
|
|
Inc(Result.Right, ACaptionWidth);
|
|
end;
|
|
else
|
|
Result.Left := GetRangeCenter(Result.Left, Result.Right) - ACaptionWidth div 2;
|
|
Result.Right := Result.Left + ACaptionWidth;
|
|
end;
|
|
case CaptionPosition of
|
|
ldvcpAbove:
|
|
begin
|
|
Result.Bottom := Result.Top;
|
|
Dec(Result.Top, ACaptionHeight);
|
|
end;
|
|
ldvcpBelow:
|
|
begin
|
|
Result.Top := Result.Bottom;
|
|
Inc(Result.Bottom, ACaptionHeight);
|
|
end;
|
|
else
|
|
Result.Top := GetRangeCenter(Result.Top, Result.Bottom) - ACaptionHeight div 2;
|
|
Result.Bottom := Result.Top + ACaptionHeight;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValueViewInfo.CalculateMarkerParams(var AParams: TcxViewParams);
|
|
begin
|
|
Diagram.Styles.GetValueMarkerParams(SeriesIndex, ValueIndex, AParams);
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValueViewInfo.CalculateMarkerPoints;
|
|
begin
|
|
CalculateMarkerPointsEx(MarkerBounds, MarkerStyle, MarkerPoints);
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValueViewInfo.DoCalculateParams;
|
|
begin
|
|
inherited;
|
|
CalculateMarkerParams(MarkerParams);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetCellBoundsForHint: TRect;
|
|
begin
|
|
Result := HotSpotBounds;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetDesignSelectionBounds: TRect;
|
|
begin
|
|
Result := HotSpotBounds;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetHotSpotBounds: TRect;
|
|
var
|
|
ASize: Integer;
|
|
begin
|
|
ASize := Diagram.Values.GetHotSpotSize;
|
|
GetCenteredRect(Position, ASize, ASize, Result);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetLineColor: TColor;
|
|
begin
|
|
Result := Params.Color;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetLineHotZoneMinWidth: Integer;
|
|
begin
|
|
Result := LineDiagramLineHotZoneMinWidth;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetLineStart: TPoint;
|
|
begin
|
|
Result.X := Bounds.Left;
|
|
Result.Y := LineStartY;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetLineFinish: TPoint;
|
|
begin
|
|
Result.X := Bounds.Right;
|
|
Result.Y := LineFinishY;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetMarkerBounds: TRect;
|
|
var
|
|
ASize: Integer;
|
|
begin
|
|
ASize := Diagram.Values.MarkerSize;
|
|
GetCenteredRect(Position, ASize, ASize, Result);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := GetPainterClassEx;
|
|
end;
|
|
|
|
class function TcxGridChartLineDiagramValueViewInfo.GetPainterClassEx: TcxGridChartLineDiagramValuePainterClass;
|
|
begin
|
|
Result := TcxGridChartLineDiagramValuePainter;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetPosition: TPoint;
|
|
begin
|
|
if CategoryDirection = dirRight then
|
|
Result.X := Bounds.Right
|
|
else
|
|
Result.X := Bounds.Left;
|
|
if ValueDirection = dirUp then
|
|
Result.Y := Bounds.Top
|
|
else
|
|
Result.Y := Bounds.Bottom;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValueViewInfo.MakeRealBounds(var ABounds: TRect);
|
|
begin
|
|
ABounds.Top := Min(ABounds.Top, Min(LineStartY, LineFinishY));
|
|
ABounds.Bottom := Max(ABounds.Bottom, Max(LineStartY, LineFinishY));
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.HasBackground: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.HasCaption: Boolean;
|
|
begin
|
|
Result := CaptionPosition <> ldvcpNone;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValueViewInfo.Calculate(const ABounds: TRect;
|
|
ALineStartY, ALineFinishY: Integer);
|
|
begin
|
|
inherited Calculate(ABounds);
|
|
FLineStartY := ALineStartY;
|
|
FLineFinishY := ALineFinishY;
|
|
CalculateMarkerPoints;
|
|
end;
|
|
|
|
class procedure TcxGridChartLineDiagramValueViewInfo.CalculateMarkerPointsEx(const ABounds: TRect;
|
|
AStyle: TcxGridChartMarkerStyle; var APoints: TPointArray);
|
|
var
|
|
AOrigin: TPoint;
|
|
ASize: Integer;
|
|
begin
|
|
if not (AStyle in [cmsTriangle, cmsDiamond]) then Exit;
|
|
with ABounds do
|
|
begin
|
|
AOrigin := TopLeft;
|
|
ASize := Right - Left;
|
|
end;
|
|
if not Odd(ASize) then
|
|
begin
|
|
Dec(ASize);
|
|
Inc(AOrigin.X);
|
|
Inc(AOrigin.Y);
|
|
end;
|
|
if AStyle = cmsTriangle then
|
|
begin
|
|
SetLength(APoints, 3);
|
|
APoints[0] := Point(AOrigin.X, AOrigin.Y + ASize - 1 - 1);
|
|
APoints[1] := Point(AOrigin.X + ASize div 2, AOrigin.Y - 1);
|
|
APoints[2] := Point(AOrigin.X + ASize, AOrigin.Y + ASize - 1);
|
|
end
|
|
else
|
|
begin
|
|
SetLength(APoints, 4);
|
|
APoints[0] := Point(AOrigin.X, AOrigin.Y + ASize div 2);
|
|
APoints[1] := Point(AOrigin.X + ASize div 2, AOrigin.Y - 1);
|
|
APoints[2] := Point(AOrigin.X + ASize, AOrigin.Y + ASize div 2);
|
|
APoints[3] := Point(AOrigin.X + ASize div 2, AOrigin.Y + ASize);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetAreaBoundsForPainting: TRect;
|
|
begin
|
|
Result := inherited GetAreaBoundsForPainting;
|
|
if LineStyle <> clsNone then
|
|
begin
|
|
MakeRealBounds(Result);
|
|
InflateRect(Result, RoundDiv(LineWidth, 2), RoundDiv(LineWidth, 2));
|
|
end;
|
|
if MarkerStyle <> cmsNone then
|
|
UnionRect(Result, Result, MarkerBounds);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
|
|
begin
|
|
Result := inherited GetHitTest(P);
|
|
if (Result = nil) and (LineStyle <> clsNone) and
|
|
LineHasPoint(LineStart, LineFinish, LineWidth, P, LineHotZoneMinWidth) then
|
|
begin
|
|
Result := TcxGridChartValueLineHitTest.Instance(P);
|
|
InitHitTest(Result);
|
|
TcxGridChartValueLineHitTest(Result).CanDrillDown := False;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.GetRealBounds: TRect;
|
|
begin
|
|
Result := Bounds;
|
|
MakeRealBounds(Result);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValueViewInfo.HasPoint(const P: TPoint): Boolean;
|
|
begin
|
|
Result := PtInRect(HotSpotBounds, P);
|
|
end;
|
|
|
|
{ TcxGridChartLineDiagramViewInfo }
|
|
|
|
function TcxGridChartLineDiagramViewInfo.GetDiagram: TcxGridChartLineDiagram;
|
|
begin
|
|
Result := TcxGridChartLineDiagram(inherited Diagram);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartLineDiagramPainter;
|
|
end;
|
|
|
|
class function TcxGridChartLineDiagramViewInfo.GetValueViewInfoClass: TcxGridChartDiagramValueViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartLineDiagramValueViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramViewInfo.GetValueViewInfoIndex(ASeriesIndex, AVisibleIndex: Integer): Integer;
|
|
begin
|
|
Result := ASeriesIndex * VisibleValueCount + AVisibleIndex;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramViewInfo.GetCategoryTickMarkLabelOffsetUnits(AIndex: Integer): Integer;
|
|
begin
|
|
Result := GetValueOffsetUnits(AIndex, -1);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramViewInfo.GetCategoryTickMarkOffsetUnits(AIndex: Integer;
|
|
AValueAxisBetweenCategories: Boolean): Integer;
|
|
begin
|
|
Result := LineDiagramValueSizeUnits * AIndex;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramViewInfo.GetUnitCount: Integer;
|
|
begin
|
|
Result := LineDiagramValueSizeUnits * VisibleValueCount;
|
|
if not Diagram.AxisCategory.ValueAxisBetweenCategories then
|
|
Dec(Result, LineDiagramValueSizeUnits);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramViewInfo.GetValueOffsetUnits(AVisibleValueIndex, ASeriesIndex: Integer): Integer;
|
|
begin
|
|
if Diagram.AxisCategory.ValueAxisBetweenCategories then
|
|
Result := LineDiagramValueSizeUnits div 2
|
|
else
|
|
Result := 0;
|
|
Inc(Result, LineDiagramValueSizeUnits * AVisibleValueIndex);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramViewInfo.IsEdgeCategoryTickMarkLabels: Boolean;
|
|
begin
|
|
Result := not Diagram.AxisCategory.ValueAxisBetweenCategories;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramViewInfo.GetValueY(AVisibleValueIndex, ASeriesIndex: Integer): Integer;
|
|
begin
|
|
Result := GetValueOffset(VisibleValues[ASeriesIndex, AVisibleValueIndex]);
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramViewInfo.CalculatePlotOffsets(APlotAreaWidth: Integer;
|
|
var AOffsets: TRect);
|
|
var
|
|
ACompensation: Integer;
|
|
begin
|
|
inherited;
|
|
if Diagram.Values.LineStyle = clsNone then
|
|
ACompensation := 0
|
|
else
|
|
ACompensation := RoundDiv(Diagram.Values.LineWidth, 2);
|
|
if Diagram.Values.MarkerStyle <> cmsNone then
|
|
ACompensation := Max(ACompensation, RoundDiv(Diagram.Values.MarkerSize, 2));
|
|
if ACompensation <> 0 then
|
|
begin
|
|
AOffsets.Left := Max(AOffsets.Left, ACompensation);
|
|
AOffsets.Top := Max(AOffsets.Top, ACompensation);
|
|
AOffsets.Right := Max(AOffsets.Right, ACompensation);
|
|
AOffsets.Bottom := Max(AOffsets.Bottom, ACompensation);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramViewInfo.CalculateValues;
|
|
var
|
|
AValueIndex, ASeriesIndex, ALineStartY, ALineFinishY: Integer;
|
|
begin
|
|
ALineStartY := 0; // to avoid warning
|
|
for ASeriesIndex := 0 to SeriesCount - 1 do
|
|
for AValueIndex := 0 to VisibleValueCount - 1 do
|
|
begin
|
|
ALineFinishY := GetValueY(AValueIndex, ASeriesIndex);
|
|
if AValueIndex = 0 then
|
|
ALineStartY := ALineFinishY;
|
|
if IsCategoriesInReverseOrder then
|
|
SwapIntegers(ALineStartY, ALineFinishY);
|
|
TcxGridChartLineDiagramValueViewInfo(CreateValueViewInfo(ASeriesIndex, AValueIndex)).Calculate(
|
|
GetValueBounds(AValueIndex, ASeriesIndex), ALineStartY, ALineFinishY);
|
|
if not IsCategoriesInReverseOrder then
|
|
ALineStartY := ALineFinishY;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramViewInfo.GetValueBounds(AVisibleValueIndex, ASeriesIndex: Integer): TRect;
|
|
var
|
|
ACategoryOffsetStart, ACategoryOffsetFinish, AValueOffsetStart, AValueOffsetFinish: Integer;
|
|
begin
|
|
ACategoryOffsetFinish := GetUnitAdjustedOffset(GetValueOffsetUnits(AVisibleValueIndex, ASeriesIndex));
|
|
if AVisibleValueIndex = 0 then
|
|
ACategoryOffsetStart := ACategoryOffsetFinish
|
|
else
|
|
ACategoryOffsetStart := GetUnitAdjustedOffset(GetValueOffsetUnits(AVisibleValueIndex - 1, ASeriesIndex));
|
|
AValueOffsetStart := ZeroValueOffset;
|
|
AValueOffsetFinish := GetValueY(AVisibleValueIndex, ASeriesIndex);
|
|
|
|
Result.Left := ACategoryOffsetStart;
|
|
Result.Right := ACategoryOffsetFinish;
|
|
Result.Bottom := AValueOffsetStart;
|
|
Result.Top := AValueOffsetFinish;
|
|
CheckRectBounds(Result);
|
|
end;
|
|
|
|
{ TcxGridChartAreaDiagramLegendItemViewInfo }
|
|
|
|
function TcxGridChartAreaDiagramLegendItemViewInfo.CalculateHeight: Integer;
|
|
begin
|
|
Result := Max(inherited CalculateHeight, 2 * AreaDiagramLegendKeyOffset + LegendKeyHeight);
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagramLegendItemViewInfo.CalculateLegendKeyHeight: Integer;
|
|
begin
|
|
Result := 2 * AreaDiagramLegendKeySpace;
|
|
if LineStyle <> clsNone then
|
|
Inc(Result, 2 * LineWidth);
|
|
if MarkerStyle <> cmsNone then
|
|
Inc(Result, MarkerSize);
|
|
Result := Max(Result, inherited CalculateLegendKeyHeight);
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagramLegendItemViewInfo.CalculateLegendKeyWidth: Integer;
|
|
begin
|
|
Result := inherited CalculateLegendKeyWidth;
|
|
if Result = 0 then
|
|
Result := LegendKeyHeight;
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagramLegendItemViewInfo.GetLineColor: TColor;
|
|
begin
|
|
Result := LegendKeyParams.TextColor;
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagramLegendItemViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartAreaDiagramLegendItemPainter;
|
|
end;
|
|
|
|
{ TcxGridChartAreaDiagramLegendViewInfo }
|
|
|
|
function TcxGridChartAreaDiagramLegendViewInfo.GetItemClass: TcxGridChartLegendItemViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartAreaDiagramLegendItemViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagramLegendViewInfo.GetItemsInReverseOrder: Boolean;
|
|
begin
|
|
Result := (Orientation = cpoVertical) and (Diagram.Values.Stacking <> vsNone);
|
|
end;
|
|
|
|
{function TcxGridChartAreaDiagramLegendViewInfo.ItemLegendKeyBorderIsValueBorder: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;}
|
|
|
|
{ TcxGridChartAreaDiagramValueViewInfo }
|
|
|
|
function TcxGridChartAreaDiagramValueViewInfo.GetDiagram: TcxGridChartAreaDiagram;
|
|
begin
|
|
Result := TcxGridChartAreaDiagram(inherited Diagram);
|
|
end;
|
|
|
|
procedure TcxGridChartAreaDiagramValueViewInfo.CalculateAreaPoints;
|
|
var
|
|
APrevSeriesValuePoints: TPointArray;
|
|
begin
|
|
SetLength(AreaPoints, 4);
|
|
AreaPoints[1] := LineStart;
|
|
AreaPoints[2] := LineFinish;
|
|
{$IFNDEF DELPHI7}
|
|
APrevSeriesValuePoints := nil; // to remove wrong warning
|
|
{$ENDIF}
|
|
if (Diagram.Values.Stacking <> vsNone) and (SeriesIndex > 0) then
|
|
begin
|
|
APrevSeriesValuePoints := TcxGridChartAreaDiagramValueViewInfo(
|
|
DiagramViewInfo.GetValueViewInfo(SeriesIndex - 1, VisibleValueIndex)).AreaPoints;
|
|
AreaPoints[0] := APrevSeriesValuePoints[1];
|
|
AreaPoints[3] := APrevSeriesValuePoints[2];
|
|
end
|
|
else
|
|
begin
|
|
AreaPoints[0] := Point(Bounds.Left, ZeroValueOffset);
|
|
AreaPoints[3] := Point(Bounds.Right, ZeroValueOffset);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagramValueViewInfo.CustomDrawBackground(ACanvas: TcxCanvas): Boolean;
|
|
begin
|
|
Result := inherited CustomDrawBackground(ACanvas);
|
|
if not Result then
|
|
Diagram.DoCustomDrawValueArea(ACanvas, Self, Result);
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagramValueViewInfo.GetAreaColor: TColor;
|
|
begin
|
|
Result := Params.Color;
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagramValueViewInfo.GetHotSpotBounds: TRect;
|
|
var
|
|
ASize: TPoint;
|
|
APrevSeriesValuePosition: Integer;
|
|
begin
|
|
ASize.X := Diagram.Values.GetHotSpotSize;
|
|
if MarkerStyle = cmsNone then
|
|
ASize.Y := 0
|
|
else
|
|
ASize.Y := ASize.X;
|
|
GetCenteredRect(Position, ASize.X, ASize.Y, Result);
|
|
|
|
if (Diagram.Values.Stacking <> vsNone) and (SeriesIndex > 0) then
|
|
begin
|
|
APrevSeriesValuePosition := TcxGridChartAreaDiagramValueViewInfo(
|
|
DiagramViewInfo.GetValueViewInfo(SeriesIndex - 1, VisibleValueIndex)).Position.Y;
|
|
if Result.Top < APrevSeriesValuePosition then
|
|
Result.Bottom := APrevSeriesValuePosition
|
|
else
|
|
Result.Top := APrevSeriesValuePosition;
|
|
end
|
|
else
|
|
begin
|
|
Result.Top := Min(Result.Top, ZeroValueOffset);
|
|
Result.Bottom := Max(Result.Bottom, ZeroValueOffset);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagramValueViewInfo.GetLineColor: TColor;
|
|
begin
|
|
Result := Params.TextColor;
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagramValueViewInfo.GetLineHotZoneMinWidth: Integer;
|
|
begin
|
|
Result := 0;
|
|
end;
|
|
|
|
class function TcxGridChartAreaDiagramValueViewInfo.GetPainterClassEx: TcxGridChartLineDiagramValuePainterClass;
|
|
begin
|
|
Result := TcxGridChartAreaDiagramValuePainter;
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagramValueViewInfo.GetZeroValueOffset: Integer;
|
|
begin
|
|
if ValueDirection = dirUp then
|
|
Result := Bounds.Bottom
|
|
else
|
|
Result := Bounds.Top;
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagramValueViewInfo.HasCustomDrawBackground: Boolean;
|
|
begin
|
|
Result := Diagram.HasCustomDrawValueArea;
|
|
end;
|
|
|
|
procedure TcxGridChartAreaDiagramValueViewInfo.Calculate(const ABounds: TRect;
|
|
ALineStartY, ALineFinishY: Integer);
|
|
begin
|
|
inherited;
|
|
CalculateAreaPoints;
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagramValueViewInfo.CreateAreaRegion: TcxRegion;
|
|
begin
|
|
Result := TcxRegion.Create(CreatePolygonRgn(AreaPoints[0], Length(AreaPoints), WINDING));
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagramValueViewInfo.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
|
|
var
|
|
ARegion: TcxRegion;
|
|
begin
|
|
Result := inherited GetHitTest(P);
|
|
if Result = nil then
|
|
begin
|
|
ARegion := CreateAreaRegion;
|
|
try
|
|
if ARegion.PtInRegion(P) then
|
|
begin
|
|
Result := TcxGridChartValueAreaHitTest.Instance(P);
|
|
InitHitTest(Result);
|
|
TcxGridChartValueAreaHitTest(Result).CanDrillDown := False;
|
|
end;
|
|
finally
|
|
ARegion.Free;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartAreaDiagramViewInfo }
|
|
|
|
function TcxGridChartAreaDiagramViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartAreaDiagramPainter;
|
|
end;
|
|
|
|
class function TcxGridChartAreaDiagramViewInfo.GetValueViewInfoClass: TcxGridChartDiagramValueViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartAreaDiagramValueViewInfo;
|
|
end;
|
|
|
|
{ TcxGridChartPieDiagramLegendViewInfo }
|
|
|
|
function TcxGridChartPieDiagramLegendViewInfo.GetDiagram: TcxGridChartPieDiagram;
|
|
begin
|
|
Result := TcxGridChartPieDiagram(inherited Diagram);
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramLegendViewInfo.GetItemObjectIndex(AIndex: Integer): Integer;
|
|
begin
|
|
Result := AIndex;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramLegendViewInfo.GetKind: TcxGridChartLegendKind;
|
|
begin
|
|
if GridView.VisibleSeriesCount = 0 then
|
|
Result := lkSeries
|
|
else
|
|
Result := lkCategories;
|
|
end;
|
|
|
|
{ TcxGridChartPieDiagramValueViewInfo }
|
|
|
|
function TcxGridChartPieDiagramValueViewInfo.GetCaptionPosition: TcxGridChartPieDiagramValueCaptionPosition;
|
|
begin
|
|
Result := DiagramViewInfo.CaptionPosition;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramValueViewInfo.GetCenter: TPoint;
|
|
begin
|
|
with Bounds do
|
|
begin
|
|
Result.X := GetRangeCenter(Left, Right);
|
|
Result.Y := GetRangeCenter(Top, Bottom);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramValueViewInfo.GetDiagramViewInfo: TcxGridChartPieDiagramViewInfo;
|
|
begin
|
|
Result := TcxGridChartPieDiagramViewInfo(inherited DiagramViewInfo);
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramValueViewInfo.GetRadius: Integer;
|
|
begin
|
|
with Bounds do
|
|
Result := (Right - Left) div 2;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramValueViewInfo.CalculateCaptionBounds: TRect;
|
|
var
|
|
ACaptionWidth, ACaptionHeight, AAngle: Integer;
|
|
begin
|
|
ACaptionWidth := CaptionViewInfo.CalculateWidth;
|
|
ACaptionHeight := CaptionViewInfo.CalculateHeight;
|
|
AAngle := GetRangeCenter(StartAngle, FinishAngle) mod 360;
|
|
GetCenteredRect(CalculateCaptionCenter(AAngle, ACaptionWidth, ACaptionHeight),
|
|
ACaptionWidth, ACaptionHeight, Result);
|
|
OffsetRect(Result, 0, -1); // to center text inside text rect
|
|
if CaptionPosition = pdvcpOutsideEndWithLeaderLines then
|
|
MakeCaptionVisible(Result, AAngle);
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramValueViewInfo.CalculateCaptionCenter(AAngle, ACaptionWidth, ACaptionHeight: Integer): TPoint;
|
|
const
|
|
SpecialCaseAngleDelta = 25;
|
|
var
|
|
ARadius: Integer;
|
|
AIsSpecialCase: Boolean;
|
|
ASin, ACos: Extended;
|
|
begin
|
|
if CaptionPosition = pdvcpOutsideEndWithLeaderLines then
|
|
begin
|
|
CalculateLeaderLinePoints(AAngle);
|
|
Result := LeaderLinePoints[Length(LeaderLinePoints) - 1];
|
|
if AAngle < 180 then
|
|
Inc(Result.X, RoundDiv(ACaptionWidth, 2))
|
|
else
|
|
Dec(Result.X, RoundDiv(ACaptionWidth, 2) - 1);
|
|
end
|
|
else
|
|
begin
|
|
ARadius := Radius;
|
|
AIsSpecialCase := False;
|
|
case CaptionPosition of
|
|
pdvcpCenter:
|
|
ARadius := ARadius div 2;
|
|
pdvcpInsideEnd:
|
|
Dec(ARadius, PieValueCaptionOffset + Max(ACaptionWidth div 2, ACaptionHeight div 2));
|
|
pdvcpOutsideEnd:
|
|
begin
|
|
Inc(ARadius, PieValueCaptionOffset + ACaptionHeight div 2);
|
|
AIsSpecialCase := not (AAngle mod 180 in [SpecialCaseAngleDelta..180 - SpecialCaseAngleDelta]);
|
|
if AIsSpecialCase then
|
|
begin
|
|
SinCos(DegToRad(AAngle mod 180), ASin, ACos);
|
|
if ACaptionWidth div 2 >= Abs(ASin / ACos * ARadius) then
|
|
ARadius := Round(Abs(ARadius / ACos))
|
|
else
|
|
ARadius := Round(ACaptionWidth div 2 * ASin + Sqrt(Sqr(ARadius) - Sqr(ACaptionWidth div 2 * ACos)));
|
|
end;
|
|
end;
|
|
end;
|
|
Result := GetPointOnCircle(Center, ARadius, AAngle);
|
|
if CaptionPosition = pdvcpOutsideEnd then
|
|
if AIsSpecialCase then
|
|
if AAngle in [180 - SpecialCaseAngleDelta..180 + SpecialCaseAngleDelta] then
|
|
Inc(Result.Y, ACaptionHeight div 2)
|
|
else
|
|
Dec(Result.Y, ACaptionHeight div 2)
|
|
else
|
|
if AAngle < 180 then
|
|
Inc(Result.X, ACaptionWidth div 2)
|
|
else
|
|
Dec(Result.X, ACaptionWidth div 2);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramValueViewInfo.CalculateLeaderLinePoints(AAngle: Integer);
|
|
begin
|
|
SetLength(LeaderLinePoints, 3);
|
|
LeaderLinePoints[0] := GetPointOnCircle(Center, Radius, AAngle);
|
|
LeaderLinePoints[1] :=
|
|
GetPointOnCircle(Center, Radius + PieLeaderLineSegment1, AAngle);
|
|
LeaderLinePoints[2] := LeaderLinePoints[1];
|
|
if AAngle < 180 then
|
|
Inc(LeaderLinePoints[2].X, PieLeaderLineSegment2)
|
|
else
|
|
Dec(LeaderLinePoints[2].X, PieLeaderLineSegment2);
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramValueViewInfo.GetIsDesignSelected: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramValueViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartPieDiagramValuePainter;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramValueViewInfo.HasBackground: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramValueViewInfo.HasCaption: Boolean;
|
|
begin
|
|
Result := (Radius <> 0) and (CaptionPosition <> pdvcpNone);
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramValueViewInfo.MakeCaptionVisible(var ACaptionBounds: TRect;
|
|
AAngle: Integer);
|
|
var
|
|
APrevValueIndex, ACaptionOffset: Integer;
|
|
APrevCaptionBounds, AIntersection: TRect;
|
|
begin
|
|
if VisibleValueIndex = 0 then Exit;
|
|
APrevValueIndex := VisibleValueIndex;
|
|
repeat
|
|
Dec(APrevValueIndex);
|
|
APrevCaptionBounds :=
|
|
DiagramViewInfo.GetValueViewInfo(SeriesIndex, APrevValueIndex).CaptionViewInfo.Bounds;
|
|
if not EqualRect(ACaptionBounds, APrevCaptionBounds) and
|
|
IntersectRect(AIntersection, ACaptionBounds, APrevCaptionBounds) then
|
|
begin
|
|
if AAngle < 180 then
|
|
ACaptionOffset := APrevCaptionBounds.Right - ACaptionBounds.Left
|
|
else
|
|
ACaptionOffset := APrevCaptionBounds.Left - ACaptionBounds.Right;
|
|
OffsetRect(ACaptionBounds, ACaptionOffset, 0);
|
|
if LeaderLinePoints <> nil then
|
|
Inc(LeaderLinePoints[Length(LeaderLinePoints) - 1].X, ACaptionOffset);
|
|
APrevValueIndex := VisibleValueIndex;
|
|
end;
|
|
until APrevValueIndex = 0;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramValueViewInfo.Calculate(const R: TRect;
|
|
AStartAngle, AFinishAngle: Integer);
|
|
begin
|
|
FStartAngle := AStartAngle;
|
|
FFinishAngle := AFinishAngle;
|
|
inherited Calculate(R);
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramValueViewInfo.HasPoint(const P: TPoint): Boolean;
|
|
var
|
|
APointRadius, APointAngle: Integer;
|
|
begin
|
|
Result := inherited HasPoint(P);
|
|
if Result then
|
|
begin
|
|
APointRadius := Round(Sqrt(Sqr(P.X - Center.X) + Sqr(P.Y - Center.Y)));
|
|
Result := APointRadius <= Radius;
|
|
if Result then
|
|
begin
|
|
APointAngle := 90 + Round(RadToDeg(ArcTan2(P.Y - Center.Y, P.X - Center.X)));
|
|
if APointAngle < 0 then Inc(APointAngle, 360);
|
|
Result := (StartAngle <= APointAngle) and (APointAngle < FinishAngle);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartPieSeriesSiteCaptionViewInfo }
|
|
|
|
constructor TcxGridChartPieSeriesSiteCaptionViewInfo.Create(ASiteViewInfo: TcxGridChartPieSeriesSiteViewInfo);
|
|
begin
|
|
inherited Create(ASiteViewInfo.GridViewInfo);
|
|
FSiteViewInfo := ASiteViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteCaptionViewInfo.CalculateHeight: Integer;
|
|
begin
|
|
Result := BorderSize[bTop] + TextHeightWithOffset + BorderSize[bBottom];
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteCaptionViewInfo.CustomDraw(ACanvas: TcxCanvas): Boolean;
|
|
begin
|
|
Result := inherited CustomDraw(ACanvas);
|
|
if not Result then
|
|
FSiteViewInfo.Diagram.DoCustomDrawSeriesSiteCaption(ACanvas, Self, Result);
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteCaptionViewInfo.GetAlignmentHorz: TAlignment;
|
|
begin
|
|
Result := taCenter;
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteCaptionViewInfo.GetBorderColor(AIndex: TcxBorder): TColor;
|
|
begin
|
|
Result := FSiteViewInfo.BorderColor[AIndex];
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteCaptionViewInfo.GetBorders: TcxBorders;
|
|
begin
|
|
if FSiteViewInfo.Visible then
|
|
Result := [bBottom]
|
|
else
|
|
Result := [];
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteCaptionViewInfo.GetBorderWidth(AIndex: TcxBorder): Integer;
|
|
begin
|
|
Result := FSiteViewInfo.BorderWidth[AIndex];
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteCaptionViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
|
|
begin
|
|
Result := TcxGridChartPieSeriesSiteCaptionHitTest;
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteCaptionViewInfo.GetText: string;
|
|
begin
|
|
Result := FSiteViewInfo.Series.GetDisplayText;
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteCaptionViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartPieSeriesSiteCaptionPainter;
|
|
end;
|
|
|
|
procedure TcxGridChartPieSeriesSiteCaptionViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
FSiteViewInfo.Diagram.Styles.GetViewParams(dsSeriesSiteCaptions, nil, nil, AParams);
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteCaptionViewInfo.GetVisible: Boolean;
|
|
begin
|
|
Result := FSiteViewInfo.Diagram.SeriesCaptions;
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteCaptionViewInfo.HasCustomDraw: Boolean;
|
|
begin
|
|
Result := FSiteViewInfo.Diagram.HasCustomDrawSeriesSiteCaption;
|
|
end;
|
|
|
|
procedure TcxGridChartPieSeriesSiteCaptionViewInfo.InitHitTest(AHitTest: TcxCustomGridHitTest);
|
|
begin
|
|
FSiteViewInfo.InitHitTest(AHitTest);
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteCaptionViewInfo.MouseDown(AHitTest: TcxCustomGridHitTest;
|
|
AButton: TMouseButton; AShift: TShiftState): Boolean;
|
|
begin
|
|
Result := inherited MouseDown(AHitTest, AButton, AShift);
|
|
if (AButton = mbLeft) and not (ssDouble in AShift) and GridView.IsDesigning then
|
|
begin
|
|
GridView.Controller.DesignController.SelectObject(FSiteViewInfo.Series, not (ssShift in AShift));
|
|
Result := True;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartPieSeriesSiteViewInfo }
|
|
|
|
constructor TcxGridChartPieSeriesSiteViewInfo.Create(ADiagramViewInfo: TcxGridChartPieDiagramViewInfo;
|
|
ASeries: TcxGridChartSeries);
|
|
begin
|
|
inherited Create(ADiagramViewInfo.GridViewInfo);
|
|
FDiagramViewInfo := ADiagramViewInfo;
|
|
FSeries := ASeries;
|
|
FCaptionViewInfo := GetCaptionViewInfoClass.Create(Self);
|
|
end;
|
|
|
|
destructor TcxGridChartPieSeriesSiteViewInfo.Destroy;
|
|
begin
|
|
FCaptionViewInfo.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteViewInfo.GetDiagram: TcxGridChartPieDiagram;
|
|
begin
|
|
Result := FDiagramViewInfo.Diagram;
|
|
end;
|
|
|
|
procedure TcxGridChartPieSeriesSiteViewInfo.CalculateAngles;
|
|
var
|
|
ASumOfValues, AValue: Variant;
|
|
AAngleOffset, I: Integer;
|
|
begin
|
|
ASumOfValues := Series.SumOfValues;
|
|
AAngleOffset := Diagram.Values.AngleOfFirstSlice;
|
|
SetLength(Angles, Series.VisibleValueCount + 1);
|
|
if ASumOfValues <> 0 then
|
|
begin
|
|
AValue := 0;
|
|
for I := 0 to Series.VisibleValueCount - 1 do
|
|
begin
|
|
Angles[I] := AAngleOffset + Min(Round(360 * AValue / ASumOfValues), 360);
|
|
AValue := AValue + Abs(Series.VisibleValues[I]);
|
|
end;
|
|
Angles[Series.VisibleValueCount] := AAngleOffset + 360;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartPieSeriesSiteViewInfo.CalculateCaptionAndPieAreaBounds(var ACaptionBounds, APieAreaBounds: TRect);
|
|
var
|
|
ASize: Integer;
|
|
begin
|
|
ACaptionBounds := ContentBounds;
|
|
if FCaptionViewInfo.Visible and not IsRectEmpty(ACaptionBounds) then
|
|
begin
|
|
ACaptionBounds.Bottom := ACaptionBounds.Top;
|
|
Dec(ACaptionBounds.Top, FCaptionViewInfo.CalculateHeight);
|
|
end;
|
|
|
|
APieAreaBounds := ContentBounds;
|
|
InflateRect(APieAreaBounds, -PieAreaOffset, -PieAreaOffset);
|
|
with APieAreaBounds do
|
|
begin
|
|
ASize := Max(PieMinSize, Min(Right - Left, Bottom - Top) -
|
|
2 * DiagramViewInfo.PieAreaValueCaptionCompensation);
|
|
if ASize > Min(ContentWidth, ContentHeight) then
|
|
SetRectEmpty(APieAreaBounds)
|
|
else
|
|
begin
|
|
Left := (Left + Right - ASize) div 2;
|
|
Right := Left + ASize;
|
|
Top := (Top + Bottom - ASize) div 2;
|
|
Bottom := Top + ASize;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteViewInfo.CalculateContentBounds: TRect;
|
|
begin
|
|
Result := inherited CalculateContentBounds;
|
|
if FCaptionViewInfo.Visible then
|
|
Inc(Result.Top, FCaptionViewInfo.CalculateHeight);
|
|
if IsRectEmpty(Result) then SetRectEmpty(Result); // for negative values
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteViewInfo.CustomDraw(ACanvas: TcxCanvas): Boolean;
|
|
begin
|
|
Result := inherited CustomDraw(ACanvas);
|
|
if not Result then
|
|
Diagram.DoCustomDrawSeriesSite(ACanvas, Self, Result);
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteViewInfo.GetBorderColor(AIndex: TcxBorder): TColor;
|
|
begin
|
|
Result := Params.TextColor;
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteViewInfo.GetBorders: TcxBorders;
|
|
begin
|
|
Result := cxBordersAll;
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteViewInfo.GetBorderWidth(AIndex: TcxBorder): Integer;
|
|
begin
|
|
Result := 1;
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteViewInfo.GetCaptionViewInfoClass: TcxGridChartPieSeriesSiteCaptionViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartPieSeriesSiteCaptionViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteViewInfo.GetDesignSelectionBounds: TRect;
|
|
begin
|
|
Result := ClientBounds;
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
|
|
begin
|
|
Result := TcxGridChartPieSeriesSiteHitTest;
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteViewInfo.GetIsDesignSelected: Boolean;
|
|
begin
|
|
Result := GridView.IsDesigning and
|
|
GridView.Controller.DesignController.IsObjectSelected(Series);
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartPieSeriesSitePainter;
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteViewInfo.GetValueViewInfo(AVisibleValueIndex: Integer): TcxGridChartPieDiagramValueViewInfo;
|
|
begin
|
|
Result := FDiagramViewInfo.GetValueViewInfo(FSeries.VisibleIndex, AVisibleValueIndex) as TcxGridChartPieDiagramValueViewInfo;
|
|
end;
|
|
|
|
procedure TcxGridChartPieSeriesSiteViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
Diagram.Styles.GetViewParams(dsSeriesSites, nil, nil, AParams);
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteViewInfo.GetVisible: Boolean;
|
|
begin
|
|
Result := Diagram.SeriesSites;
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteViewInfo.HasCustomDraw: Boolean;
|
|
begin
|
|
Result := Diagram.HasCustomDrawSeriesSite;
|
|
end;
|
|
|
|
procedure TcxGridChartPieSeriesSiteViewInfo.InitHitTest(AHitTest: TcxCustomGridHitTest);
|
|
begin
|
|
FDiagramViewInfo.InitHitTest(AHitTest);
|
|
inherited;
|
|
(AHitTest as TcxGridChartPieSeriesSiteHitTest).Series := Series;
|
|
end;
|
|
|
|
procedure TcxGridChartPieSeriesSiteViewInfo.Calculate(const ABounds: TRect);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
inherited;
|
|
CalculateCaptionAndPieAreaBounds(FCaptionBounds, FPieAreaBounds);
|
|
if FCaptionViewInfo.Visible then
|
|
FCaptionViewInfo.Calculate(CaptionBounds);
|
|
CalculateAngles;
|
|
for I := 0 to DiagramViewInfo.VisibleValueCount - 1 do
|
|
GetValueViewInfo(I).Calculate(PieAreaBounds, Angles[I], Angles[I + 1]);
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteViewInfo.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
|
|
begin
|
|
Result := FCaptionViewInfo.GetHitTest(P);
|
|
if Result = nil then
|
|
Result := inherited GetHitTest(P);
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteViewInfo.IsPieEmpty: Boolean;
|
|
begin
|
|
Result := (Angles = nil) or (Angles[Length(Angles) - 1] = 0);
|
|
end;
|
|
|
|
function TcxGridChartPieSeriesSiteViewInfo.MouseDown(AHitTest: TcxCustomGridHitTest;
|
|
AButton: TMouseButton; AShift: TShiftState): Boolean;
|
|
begin
|
|
Result := inherited MouseDown(AHitTest, AButton, AShift);
|
|
if (AButton = mbLeft) and not (ssDouble in AShift) and GridView.IsDesigning then
|
|
begin
|
|
GridView.Controller.DesignController.SelectObject(Series, not (ssShift in AShift));
|
|
Result := True;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartPieSeriesSiteViewInfo.Paint(ACanvas: TcxCanvas = nil);
|
|
begin
|
|
FCaptionViewInfo.Paint(ACanvas);
|
|
inherited;
|
|
end;
|
|
|
|
{ TcxGridChartPieDiagramViewInfo }
|
|
|
|
constructor TcxGridChartPieDiagramViewInfo.Create(AGridViewInfo: TcxCustomGridViewInfo;
|
|
ADiagram: TcxGridChartDiagram);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
inherited;
|
|
FSeriesSiteViewInfos := TList.Create;
|
|
for I := 0 to SeriesCount - 1 do
|
|
FSeriesSiteViewInfos.Add(GetSeriesSiteViewInfoClass.Create(Self, Series[I]));
|
|
end;
|
|
|
|
destructor TcxGridChartPieDiagramViewInfo.Destroy;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to SeriesSiteViewInfoCount - 1 do
|
|
SeriesSiteViewInfos[I].Free;
|
|
FSeriesSiteViewInfos.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramViewInfo.GetCaptionPosition: TcxGridChartPieDiagramValueCaptionPosition;
|
|
begin
|
|
Result := Diagram.Values.GetCaptionPosition;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramViewInfo.GetDiagram: TcxGridChartPieDiagram;
|
|
begin
|
|
Result := TcxGridChartPieDiagram(inherited Diagram);
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramViewInfo.GetSeriesSiteViewInfo(Index: Integer): TcxGridChartPieSeriesSiteViewInfo;
|
|
begin
|
|
Result := TcxGridChartPieSeriesSiteViewInfo(FSeriesSiteViewInfos[Index]);
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramViewInfo.GetSeriesSiteViewInfoCount: Integer;
|
|
begin
|
|
Result := FSeriesSiteViewInfos.Count;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartPieDiagramPainter;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramViewInfo.GetSeriesSiteViewInfoClass: TcxGridChartPieSeriesSiteViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartPieSeriesSiteViewInfo;
|
|
end;
|
|
|
|
class function TcxGridChartPieDiagramViewInfo.GetValueViewInfoClass: TcxGridChartDiagramValueViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartPieDiagramValueViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramViewInfo.GetValueViewInfoIndex(ASeriesIndex, AVisibleIndex: Integer): Integer;
|
|
begin
|
|
Result := ASeriesIndex * VisibleValueCount + AVisibleIndex;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramViewInfo.CalculatePieAreaValueCaptionCompensation: Integer;
|
|
begin
|
|
case CaptionPosition of
|
|
pdvcpOutsideEnd:
|
|
Result := PieValueCaptionOffset + CalculateValueCaptionMaxHeight div 2 +
|
|
CalculateValueCaptionMaxWidth;
|
|
pdvcpOutsideEndWithLeaderLines:
|
|
Result := PieLeaderLineSegment1 + PieLeaderLineSegment2 + CalculateValueCaptionMaxWidth;
|
|
else
|
|
Result := 0;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramViewInfo.CalculateSeriesSiteViewInfoBounds(AIndex: Integer): TRect;
|
|
var
|
|
AColumnCount, ARowCount, ASiteWidth, ASiteHeight: Integer;
|
|
begin
|
|
AColumnCount := Diagram.GetSeriesColumnCount;
|
|
ARowCount := RoundDiv(SeriesSiteViewInfoCount, AColumnCount);
|
|
|
|
ASiteWidth := (Bounds.Right - Bounds.Left - (AColumnCount - 1) * PieSeriesSiteOffset) div AColumnCount;
|
|
ASiteHeight := (Bounds.Bottom - Bounds.Top - (ARowCount - 1) * PieSeriesSiteOffset) div ARowCount;
|
|
|
|
Result := Bounds;
|
|
Inc(Result.Left, AIndex mod AColumnCount * (ASiteWidth + PieSeriesSiteOffset));
|
|
Result.Right := Result.Left + ASiteWidth;
|
|
Inc(Result.Top, AIndex div AColumnCount * (ASiteHeight + PieSeriesSiteOffset));
|
|
Result.Bottom := Result.Top + ASiteHeight;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramViewInfo.CalculateValueCaptionMaxWidth: Integer;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := 0;
|
|
for I := 0 to ValueViewInfoCount - 1 do
|
|
Result := Max(Result, ValueViewInfos[I].CaptionViewInfo.CalculateWidth);
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramViewInfo.CalculateValueCaptionMaxHeight: Integer;
|
|
begin
|
|
if ValueViewInfoCount = 0 then
|
|
Result := 0
|
|
else
|
|
Result := ValueViewInfos[0].CaptionViewInfo.CalculateHeight;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramViewInfo.Calculate(const ABounds: TRect);
|
|
var
|
|
I, J: Integer;
|
|
begin
|
|
inherited;
|
|
for I := 0 to SeriesCount - 1 do
|
|
for J := 0 to VisibleValueCount - 1 do
|
|
CreateValueViewInfo(I, J);
|
|
FPieAreaValueCaptionCompensation := CalculatePieAreaValueCaptionCompensation;
|
|
for I := 0 to SeriesSiteViewInfoCount - 1 do
|
|
SeriesSiteViewInfos[I].Calculate(CalculateSeriesSiteViewInfoBounds(I));
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramViewInfo.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := inherited GetHitTest(P);
|
|
if Result = nil then
|
|
for I := 0 to SeriesSiteViewInfoCount - 1 do
|
|
begin
|
|
Result := SeriesSiteViewInfos[I].GetHitTest(P);
|
|
if Result <> nil then Break;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartToolBoxItemViewInfo }
|
|
|
|
constructor TcxGridChartToolBoxItemViewInfo.Create(AContainer: TcxGridChartToolBoxViewInfo;
|
|
AAlignment: TcxGridChartToolBoxItemAlignment);
|
|
begin
|
|
inherited Create(AContainer.GridViewInfo);
|
|
FContainer := AContainer;
|
|
FAlignment := AAlignment;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxItemViewInfo.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxItemViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
FContainer.GetViewParams(AParams);
|
|
end;
|
|
|
|
{ TcxGridChartToolBoxItemSeparatorViewInfo }
|
|
|
|
function TcxGridChartToolBoxItemSeparatorViewInfo.CalculateHeight: Integer;
|
|
begin
|
|
Result := 0;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxItemSeparatorViewInfo.CalculateWidth: Integer;
|
|
begin
|
|
Result := ToolBoxItemSeparatorWidth;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxItemSeparatorViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
|
|
begin
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxItemSeparatorViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartToolBoxItemSeparatorPainter;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxItemSeparatorViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
AParams.Color := LookAndFeelPainter.DefaultChartToolBoxItemSeparatorColor;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxItemSeparatorViewInfo.HasBackground: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
{ TcxGridChartToolBoxDataLevelActiveValueViewInfo }
|
|
|
|
constructor TcxGridChartToolBoxDataLevelActiveValueViewInfo.Create(AContainer: TcxGridChartToolBoxDataLevelInfoViewInfo);
|
|
begin
|
|
inherited Create(AContainer.GridViewInfo);
|
|
FContainer := AContainer;
|
|
FCanShowDropDownWindow := GridView.Controller.CanShowDataLevelActiveValuePopup;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelActiveValueViewInfo.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelActiveValueViewInfo.GetDataGroup: TcxGridChartDataGroup;
|
|
begin
|
|
Result := FContainer.DataLevelObject;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelActiveValueViewInfo.CalculateContentBounds: TRect;
|
|
begin
|
|
Result := inherited CalculateContentBounds;
|
|
InflateRect(Result, -cxTextOffset, 0);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelActiveValueViewInfo.CalculateHeight: Integer;
|
|
begin
|
|
Result := TextHeightWithOffset;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelActiveValueViewInfo.CalculateWidth: Integer;
|
|
begin
|
|
Result := BorderSize[bLeft] + 2 * cxTextOffset + TextWidthWithOffset;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelActiveValueViewInfo.GetAlignmentVert: TcxAlignmentVert;
|
|
begin
|
|
Result := vaCenter;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelActiveValueViewInfo.GetBorderColor(AIndex: TcxBorder): TColor;
|
|
begin
|
|
Result := FContainer.BorderColor[AIndex];
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelActiveValueViewInfo.GetBorders: TcxBorders;
|
|
begin
|
|
Result := [bLeft];
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelActiveValueViewInfo.GetBorderWidth(AIndex: TcxBorder): Integer;
|
|
begin
|
|
Result := FContainer.BorderWidth[AIndex];
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelActiveValueViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
|
|
begin
|
|
Result := TcxGridChartDataLevelActiveValueInfoHitTest;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelActiveValueViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartToolBoxDataLevelActiveValuePainter;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelActiveValueViewInfo.GetText: string;
|
|
begin
|
|
if FContainer.DataLevelObject.HasActiveValue then
|
|
Result := FContainer.DataLevelObject.ActiveValueDisplayText
|
|
else
|
|
Result := cxGetResourceString(@scxGridChartToolBoxDataLevelSelectValue);
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxDataLevelActiveValueViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
GridView.Styles.GetViewParams(vsDataLevelActiveValueInfo, nil, nil, AParams);
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxDataLevelActiveValueViewInfo.InitHitTest(AHitTest: TcxCustomGridHitTest);
|
|
begin
|
|
FContainer.InitHitTest(AHitTest);
|
|
inherited;
|
|
TcxGridChartDataLevelActiveValueInfoHitTest(AHitTest).CanDropDown := CanShowDropDownWindow;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelActiveValueViewInfo.DropDownWindowExists: Boolean;
|
|
begin
|
|
Result := CanShowDropDownWindow and GridView.Controller.HasDataLevelActiveValuePopup;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelActiveValueViewInfo.GetDropDownWindow: TcxCustomGridPopup;
|
|
begin
|
|
if CanShowDropDownWindow then
|
|
Result := GridView.Controller.DataLevelActiveValuePopup
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelActiveValueViewInfo.GetDropDownWindowOwnerBounds: TRect;
|
|
begin
|
|
Result := FContainer.Bounds;
|
|
Result.Left := Bounds.Left;
|
|
end;
|
|
|
|
{ TcxGridChartToolBoxDataLevelInfoViewInfo }
|
|
|
|
constructor TcxGridChartToolBoxDataLevelInfoViewInfo.Create(AContainer: TcxGridChartToolBoxViewInfo;
|
|
AAlignment: TcxGridChartToolBoxItemAlignment; ADataLevel: Integer);
|
|
begin
|
|
inherited Create(AContainer, AAlignment);
|
|
FDataLevel := ADataLevel;
|
|
if HasActiveValue then
|
|
FActiveValueViewInfo := GetActiveValueViewInfoClass.Create(Self);
|
|
end;
|
|
|
|
destructor TcxGridChartToolBoxDataLevelInfoViewInfo.Destroy;
|
|
begin
|
|
FActiveValueViewInfo.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.GetActive: Boolean;
|
|
begin
|
|
Result := GridView.ActiveDataLevel = FDataLevel;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.GetDataLevelObject: TcxGridChartDataGroup;
|
|
begin
|
|
Result := GridView.DataLevelObjects[FDataLevel];
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.CalculateActiveValueViewInfoBounds: TRect;
|
|
begin
|
|
Result := ClientBounds;
|
|
Result.Left := Result.Right - FActiveValueViewInfo.CalculateWidth;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.CalculateContentBounds: TRect;
|
|
begin
|
|
Result := inherited CalculateContentBounds;
|
|
if FActiveValueViewInfo <> nil then
|
|
Dec(Result.Right, FActiveValueViewInfo.CalculateWidth);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.CalculateHeight: Integer;
|
|
begin
|
|
Result := TextHeightWithOffset;
|
|
if FActiveValueViewInfo <> nil then
|
|
Result := Max(Result, FActiveValueViewInfo.CalculateHeight);
|
|
Inc(Result, BorderSize[bTop] + BorderSize[bBottom]);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.CalculateWidth: Integer;
|
|
begin
|
|
Result := BorderSize[bLeft] + 2 * cxTextOffset + TextWidthWithOffset + BorderSize[bRight];
|
|
if FActiveValueViewInfo <> nil then
|
|
Inc(Result, FActiveValueViewInfo.CalculateWidth);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.GetActiveValueViewInfoClass: TcxGridChartToolBoxDataLevelActiveValueViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartToolBoxDataLevelActiveValueViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.GetAlignmentHorz: TAlignment;
|
|
begin
|
|
Result := taCenter;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.GetAlignmentVert: TcxAlignmentVert;
|
|
begin
|
|
Result := vaCenter;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.GetBorderColor(AIndex: TcxBorder): TColor;
|
|
begin
|
|
Result := LookAndFeelPainter.DefaultChartToolBoxDataLevelInfoBorderColor;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.GetBorders: TcxBorders;
|
|
begin
|
|
Result := cxBordersAll;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.GetBorderWidth(AIndex: TcxBorder): Integer;
|
|
begin
|
|
Result := LookAndFeelPainter.ChartToolBoxDataLevelInfoBorderSize;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.GetDesignObject: TPersistent;
|
|
begin
|
|
if DataLevelObject = nil then
|
|
Result := GridView.Categories
|
|
else
|
|
Result := DataLevelObject;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
|
|
begin
|
|
Result := TcxGridChartDataLevelInfoHitTest;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.GetIsDesignSelected: Boolean;
|
|
begin
|
|
Result := GridView.IsDesigning and
|
|
GridView.Controller.DesignController.IsObjectSelected(GetDesignObject);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartToolBoxDataLevelInfoPainter;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.GetText: string;
|
|
begin
|
|
if DataLevelObject = nil then
|
|
Result := GridView.Categories.GetDisplayText
|
|
else
|
|
Result := DataLevelObject.GetDisplayText;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxDataLevelInfoViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
GridView.Styles.GetDataLevelInfoParams(DataLevel, AParams);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.HasActiveValue: Boolean;
|
|
begin
|
|
Result := DataLevelObject <> nil;
|
|
if Result then
|
|
if GridView.Controller.MayDataDrillDown(False) then
|
|
Result := GridView.CanActivateDataLevel(DataLevel)
|
|
else
|
|
Result := DataLevelObject.HasActiveValue;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxDataLevelInfoViewInfo.InitHitTest(AHitTest: TcxCustomGridHitTest);
|
|
begin
|
|
inherited;
|
|
with TcxGridChartDataLevelInfoHitTest(AHitTest) do
|
|
begin
|
|
DataLevel := Self.DataLevel;
|
|
DataLevelObjectContainerKind := ckToolBox;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxDataLevelInfoViewInfo.Calculate(ALeftBound, ATopBound: Integer;
|
|
AWidth: Integer = -1; AHeight: Integer = -1);
|
|
begin
|
|
inherited;
|
|
if FActiveValueViewInfo <> nil then
|
|
FActiveValueViewInfo.Calculate(CalculateActiveValueViewInfoBounds);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
|
|
var
|
|
AHitTest: TcxCustomGridHitTest;
|
|
begin
|
|
Result := inherited GetHitTest(P);
|
|
if (Result <> nil) and not GridView.IsDesigning and (FActiveValueViewInfo <> nil) then
|
|
begin
|
|
AHitTest := FActiveValueViewInfo.GetHitTest(P);
|
|
if AHitTest <> nil then Result := AHitTest;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDataLevelInfoViewInfo.MouseDown(AHitTest: TcxCustomGridHitTest;
|
|
AButton: TMouseButton; AShift: TShiftState): Boolean;
|
|
begin
|
|
Result := inherited MouseDown(AHitTest, AButton, AShift);
|
|
if (AButton = mbLeft) and not (ssDouble in AShift) then
|
|
if GridView.IsDesigning then
|
|
begin
|
|
GridView.Controller.DesignController.SelectObject(GetDesignObject, not (ssShift in AShift));
|
|
Result := True;
|
|
end
|
|
else
|
|
if GridView.Controller.MayDataDrillDown then
|
|
GridView.ActiveDataLevel := DataLevel;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxDataLevelInfoViewInfo.Paint(ACanvas: TcxCanvas);
|
|
begin
|
|
if FActiveValueViewInfo <> nil then
|
|
FActiveValueViewInfo.Paint(ACanvas);
|
|
inherited;
|
|
end;
|
|
|
|
{ TcxGridChartToolBoxCustomizeButtonViewInfo }
|
|
|
|
function TcxGridChartToolBoxCustomizeButtonViewInfo.GetChecked: Boolean;
|
|
begin
|
|
Result := GridView.Controller.Customization;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxCustomizeButtonViewInfo.SetChecked(Value: Boolean);
|
|
begin
|
|
GridView.Controller.Customization := Value;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxCustomizeButtonViewInfo.CalculateHeight: Integer;
|
|
begin
|
|
Result := BorderWidth[bTop] + 2 * LookAndFeelPainter.ButtonTextOffset +
|
|
TextHeightWithOffset + BorderWidth[bBottom];
|
|
end;
|
|
|
|
function TcxGridChartToolBoxCustomizeButtonViewInfo.CalculateWidth: Integer;
|
|
begin
|
|
Result := BorderWidth[bLeft] + 2 * LookAndFeelPainter.ButtonTextOffset +
|
|
TextWidthWithOffset + BorderWidth[bRight];
|
|
end;
|
|
|
|
function TcxGridChartToolBoxCustomizeButtonViewInfo.CaptureMouseOnPress: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxCustomizeButtonViewInfo.Click;
|
|
begin
|
|
inherited;
|
|
Checked := not Checked;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxCustomizeButtonViewInfo.GetActualState: TcxGridCellState;
|
|
begin
|
|
if Checked then
|
|
Result := gcsPressed
|
|
else
|
|
Result := inherited GetActualState;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxCustomizeButtonViewInfo.GetBorders: TcxBorders;
|
|
begin
|
|
Result := cxBordersAll;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxCustomizeButtonViewInfo.GetBorderWidth(AIndex: TcxBorder): Integer;
|
|
begin
|
|
Result := LookAndFeelPainter.ButtonBorderSize;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxCustomizeButtonViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
|
|
begin
|
|
Result := TcxGridChartCustomizeButtonHitTest;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxCustomizeButtonViewInfo.GetHotTrack: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxCustomizeButtonViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartToolBoxCustomizeButtonPainter;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxCustomizeButtonViewInfo.GetText: string;
|
|
begin
|
|
Result := cxGetResourceString(@scxGridChartToolBoxCustomizeButtonCaption);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxCustomizeButtonViewInfo.HasBackground: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
{ TcxGridChartToolBoxDiagramSelectorViewInfo }
|
|
|
|
constructor TcxGridChartToolBoxDiagramSelectorViewInfo.Create(AContainer: TcxGridChartToolBoxViewInfo;
|
|
AAlignment: TcxGridChartToolBoxItemAlignment);
|
|
begin
|
|
inherited;
|
|
FCanShowDropDownWindow := CalculateCanShowDropDownWindow;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorViewInfo.GetDropDownWindowValue: TcxGridChartDiagramSelectorPopup;
|
|
begin
|
|
Result := TcxGridChartDiagramSelectorPopup(inherited DropDownWindow);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorViewInfo.CalculateHeight: Integer;
|
|
begin
|
|
Result := Max(ImageHeight, TextHeightWithOffset);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorViewInfo.CalculateWidth: Integer;
|
|
begin
|
|
Result := ImageWidth + ToolBoxDiagramImageOffset + TextWidthWithOffset;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorViewInfo.GetAlignmentVert: TcxAlignmentVert;
|
|
begin
|
|
Result := vaCenter;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
|
|
begin
|
|
Result := TcxGridChartDiagramSelectorHitTest;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorViewInfo.GetImageBounds: TRect;
|
|
begin
|
|
Result := ContentBounds;
|
|
Result.Right := Result.Left + ImageWidth;
|
|
AlignRect(Result, 0, ImageHeight, False, cpaCenter);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorViewInfo.GetImageHeight: Integer;
|
|
begin
|
|
Result := cxGridChartDiagramImages.Height;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorViewInfo.GetImageIndex: Integer;
|
|
begin
|
|
if GridView.ActiveDiagram = nil then
|
|
Result := -1
|
|
else
|
|
Result := GridView.ActiveDiagram.ImageIndex;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorViewInfo.GetImageWidth: Integer;
|
|
begin
|
|
Result := cxGridChartDiagramImages.Width;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartToolBoxDiagramSelectorPainter;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorViewInfo.GetText: string;
|
|
begin
|
|
if GridView.ActiveDiagram = nil then
|
|
Result := cxGetResourceString(@scxGridChartNoneDiagramDisplayText)
|
|
else
|
|
Result := GridView.ActiveDiagram.DisplayText;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorViewInfo.GetTextAreaBounds: TRect;
|
|
begin
|
|
Result := inherited GetTextAreaBounds;
|
|
Inc(Result.Left, ImageWidth + ToolBoxDiagramImageOffset);
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxDiagramSelectorViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
GridView.Styles.GetViewParams(vsDiagramSelector, nil, nil, AParams);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorViewInfo.HasBackground: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxDiagramSelectorViewInfo.InitHitTest(AHitTest: TcxCustomGridHitTest);
|
|
begin
|
|
inherited;
|
|
TcxGridChartDiagramSelectorHitTest(AHitTest).CanDropDown := CanShowDropDownWindow;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorViewInfo.CalculateCanShowDropDownWindow: Boolean;
|
|
begin
|
|
Result := GridView.AvailableDiagramCount > 1;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorViewInfo.DropDownWindowExists: Boolean;
|
|
begin
|
|
Result := CanShowDropDownWindow and GridView.Controller.HasDiagramSelectorPopup;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorViewInfo.GetDropDownWindow: TcxCustomGridPopup;
|
|
begin
|
|
if CanShowDropDownWindow then
|
|
Result := GridView.Controller.DiagramSelectorPopup
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxDiagramSelectorViewInfo.GetDropDownWindowOwnerBounds: TRect;
|
|
begin
|
|
Result := Bounds;
|
|
Dec(Result.Left, DropDownWindow.BorderWidths[bLeft] + DropDownWindow.ImageOffset);
|
|
end;
|
|
|
|
{ TcxGridChartToolBoxViewInfo }
|
|
|
|
constructor TcxGridChartToolBoxViewInfo.Create(AGridViewInfo: TcxCustomGridViewInfo);
|
|
begin
|
|
inherited;
|
|
FDataLevelInfos := TList.Create;
|
|
FItems := TList.Create;
|
|
CreateItems;
|
|
end;
|
|
|
|
destructor TcxGridChartToolBoxViewInfo.Destroy;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to Count - 1 do Items[I].Free;
|
|
FItems.Free;
|
|
FDataLevelInfos.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetCount: Integer;
|
|
begin
|
|
Result := FItems.Count;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetDataLevelInfoConnectorCount: Integer;
|
|
begin
|
|
Result := DataLevelInfoCount - 1;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetDataLevelInfo(AIndex: Integer): TcxGridChartToolBoxDataLevelInfoViewInfo;
|
|
begin
|
|
Result := TcxGridChartToolBoxDataLevelInfoViewInfo(FDataLevelInfos[AIndex]);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetDataLevelInfoCount: Integer;
|
|
begin
|
|
Result := FDataLevelInfos.Count;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetItem(AIndex: Integer): TcxGridChartToolBoxItemViewInfo;
|
|
begin
|
|
Result := TcxGridChartToolBoxItemViewInfo(FItems[AIndex]);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.CalculateHeight: Integer;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
CalculateParams;
|
|
Result := 0;
|
|
for I := 0 to Count - 1 do
|
|
Result := Max(Result, Items[I].CalculateHeight);
|
|
Inc(Result, BorderSize[bTop] + 2 * ToolBoxItemOffset + BorderSize[bBottom]);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.CalculateWidth: Integer;
|
|
begin
|
|
Result := 0;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.CalculateContentBounds: TRect;
|
|
begin
|
|
Result := inherited CalculateContentBounds;
|
|
InflateRect(Result, -ToolBoxItemOffset, -ToolBoxItemOffset);
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxViewInfo.CalculateItems;
|
|
|
|
function GetItemBounds(AItem: TcxGridChartToolBoxItemViewInfo; var ARestSpace: TRect): TRect;
|
|
begin
|
|
PositionRect(Result, ARestSpace, AItem.CalculateWidth, 0, ToolBoxItemOffset,
|
|
AItem.Alignment);
|
|
if IsSeparator(AItem) then
|
|
begin
|
|
Result.Top := ClientBounds.Top;
|
|
Result.Bottom := ClientBounds.Bottom;
|
|
end
|
|
else
|
|
AlignRect(Result, 0, AItem.CalculateHeight, False, cpaCenter);
|
|
end;
|
|
|
|
var
|
|
ARestSpace, R: TRect;
|
|
I, J, ARestWidth, AOffset: Integer;
|
|
AItem: TcxGridChartToolBoxItemViewInfo;
|
|
begin
|
|
ARestSpace := ItemsAreaBounds;
|
|
for I := 0 to Count - 1 do
|
|
begin
|
|
AItem := Items[I];
|
|
if AItem.Alignment = cppLeft then
|
|
AItem.Calculate(GetItemBounds(AItem, ARestSpace));
|
|
end;
|
|
for I := Count - 1 downto 0 do
|
|
begin
|
|
AItem := Items[I];
|
|
if AItem.Alignment = cppRight then
|
|
begin
|
|
R := GetItemBounds(AItem, ARestSpace);
|
|
ARestWidth := ARestSpace.Right - ARestSpace.Left + ToolBoxItemOffset;
|
|
if ARestWidth < 0 then
|
|
begin
|
|
AOffset := -ARestWidth;
|
|
Inc(ARestSpace.Right, AOffset);
|
|
OffsetRect(R, AOffset, 0);
|
|
for J := I + 1 to Count - 1 do
|
|
if Items[J].Alignment = cppRight then
|
|
Items[J].Offset(AOffset, 0);
|
|
end;
|
|
AItem.Calculate(R);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetAlignment: TcxGridChartPartAlignment;
|
|
begin
|
|
Result := cpaDefault;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetAlignmentVert: TcxAlignmentVert;
|
|
begin
|
|
Result := vaCenter;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetBorderColor(AIndex: TcxBorder): TColor;
|
|
begin
|
|
Result := Params.TextColor;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetBorders: TcxBorders;
|
|
begin
|
|
if GridView.ToolBox.Border = tbSingle then
|
|
Result := cxBordersAll
|
|
else
|
|
Result := [];
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetBorderWidth(AIndex: TcxBorder): Integer;
|
|
begin
|
|
Result := 1;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetDataGroupInsertionAreaBounds: TRect;
|
|
begin
|
|
Result := ClientBounds;
|
|
if GetFirstSeparator <> nil then
|
|
Result.Right := GetFirstSeparator.Bounds.Left;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetDataLevelInfoConnector(AIndex: Integer): TRect;
|
|
begin
|
|
Result := DataLevelInfos[AIndex].Bounds;
|
|
Result.Left := Result.Right;
|
|
Result.Right := DataLevelInfos[AIndex + 1].Bounds.Left;
|
|
Result.Top := (Result.Top + Result.Bottom - ToolBoxDataLevelInfoConnectorWidth) div 2;
|
|
Result.Bottom := Result.Top + ToolBoxDataLevelInfoConnectorWidth;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetDataLevelInfoConnectorColor: TColor;
|
|
begin
|
|
Result := LookAndFeelPainter.DefaultChartToolBoxDataLevelInfoBorderColor;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetFirstSeparator: TcxGridChartToolBoxItemViewInfo;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to Count - 1 do
|
|
begin
|
|
Result := Items[I];
|
|
if IsSeparator(Result) then Exit;
|
|
end;
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
|
|
begin
|
|
Result := TcxGridChartToolBoxHitTest;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetItemsAreaBounds: TRect;
|
|
begin
|
|
Result := ContentBounds;
|
|
if Text <> '' then
|
|
Inc(Result.Left, TextWidthWithOffset + ToolBoxItemOffset);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetOrientation: TcxGridChartPartOrientation;
|
|
begin
|
|
Result := cpoHorizontal;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridChartToolBoxPainter;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetPosition: TcxGridChartPartPosition;
|
|
begin
|
|
if GridView.ToolBox.Position = tpTop then
|
|
Result := cppTop
|
|
else
|
|
Result := cppBottom;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetText: string;
|
|
begin
|
|
if IsDataLevelsInfoVisible then
|
|
Result := cxGetResourceString(@scxGridChartToolBoxDataLevels)
|
|
else
|
|
Result := '';
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
GridView.Styles.GetViewParams(vsToolBox, nil, nil, AParams);
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetVisible: Boolean;
|
|
begin
|
|
Result := GridView.ToolBox.GetVisible;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.AddItem(AItem: TcxGridChartToolBoxItemViewInfo): TcxGridChartToolBoxItemViewInfo;
|
|
begin
|
|
Result := AItem;
|
|
FItems.Add(AItem);
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxViewInfo.AddSeparator(AAlignment: TcxGridChartToolBoxItemAlignment);
|
|
begin
|
|
if Count <> 0 then
|
|
AddItem(GetItemSeparatorClass.Create(Self, AAlignment));
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxViewInfo.CreateItems;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
if IsDataLevelsInfoVisible then
|
|
for I := 0 to GridView.DataLevelCount - 1 do
|
|
FDataLevelInfos.Add(AddItem(GetDataLevelInfoClass.Create(Self, cppLeft, I)));
|
|
if IsCustomizeButtonVisible then
|
|
begin
|
|
AddSeparator(cppRight);
|
|
FCustomizeButton := GetCustomizeButtonClass.Create(Self, cppRight);
|
|
AddItem(FCustomizeButton);
|
|
end;
|
|
if IsDiagramSelectorVisible then
|
|
begin
|
|
AddSeparator(cppRight);
|
|
FDiagramSelector := GetDiagramSelectorClass.Create(Self, cppRight);
|
|
AddItem(FDiagramSelector);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetCustomizeButtonClass: TcxGridChartToolBoxCustomizeButtonViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartToolBoxCustomizeButtonViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetDataLevelInfoClass: TcxGridChartToolBoxDataLevelInfoViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartToolBoxDataLevelInfoViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetDiagramSelectorClass: TcxGridChartToolBoxDiagramSelectorViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartToolBoxDiagramSelectorViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetItemSeparatorClass: TcxGridChartToolBoxItemSeparatorViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartToolBoxItemSeparatorViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.IsCustomizeButtonVisible: Boolean;
|
|
begin
|
|
Result := not GridViewInfo.IsImage and GridView.ToolBox.CustomizeButton;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.IsDataLevelsInfoVisible: Boolean;
|
|
begin
|
|
Result := GridView.ToolBox.GetDataLevelsInfoVisible;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.IsDiagramSelectorVisible: Boolean;
|
|
begin
|
|
Result := not GridViewInfo.IsImage and GridView.ToolBox.DiagramSelector;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.IsSeparator(AItem: TcxGridChartToolBoxItemViewInfo): Boolean;
|
|
begin
|
|
Result := AItem is GetItemSeparatorClass;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxViewInfo.Calculate(ALeftBound, ATopBound, AWidth,
|
|
AHeight: Integer);
|
|
begin
|
|
inherited;
|
|
CalculateItems;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetDataGroupInsertionBounds(AIndex: Integer): TRect;
|
|
begin
|
|
if DataLevelInfoCount = 0 then
|
|
Result := ItemsAreaBounds
|
|
else
|
|
begin
|
|
Result := DataLevelInfos[AIndex].Bounds;
|
|
Dec(Result.Left, MulDiv(ToolBoxItemOffset, 1, 2));
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetDataGroupInsertionIndex(const P: TPoint): Integer;
|
|
var
|
|
R: TRect;
|
|
begin
|
|
Result := -1;
|
|
if not PtInRect(GetDataGroupInsertionAreaBounds, P) then Exit;
|
|
for Result := 0 to DataLevelInfoCount - 1 do
|
|
if DataLevelInfos[Result].DataLevelObject <> nil then
|
|
begin
|
|
R := DataLevelInfos[Result].Bounds;
|
|
if P.X < GetRangeCenter(R.Left, R.Right) then Exit;
|
|
end;
|
|
Result := GridView.VisibleDataGroupCount;
|
|
end;
|
|
|
|
function TcxGridChartToolBoxViewInfo.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
|
|
var
|
|
I: Integer;
|
|
AHitTest: TcxCustomGridHitTest;
|
|
begin
|
|
Result := inherited GetHitTest(P);
|
|
if Result <> nil then
|
|
for I := 0 to Count - 1 do
|
|
begin
|
|
AHitTest := Items[I].GetHitTest(P);
|
|
if AHitTest <> nil then
|
|
begin
|
|
Result := AHitTest;
|
|
Break;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBoxViewInfo.InvalidateCustomizeButton;
|
|
begin
|
|
if CustomizeButton <> nil then
|
|
CustomizeButton.Invalidate;
|
|
end;
|
|
|
|
{ TcxGridChartTitleViewInfo }
|
|
|
|
function TcxGridChartTitleViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
|
|
begin
|
|
Result := TcxGridChartTitleHitTest;
|
|
end;
|
|
|
|
procedure TcxGridChartTitleViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
GridView.Styles.GetViewParams(vsTitle, nil, nil, AParams);
|
|
end;
|
|
|
|
{ TcxGridChartViewInfo }
|
|
|
|
function TcxGridChartViewInfo.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
procedure TcxGridChartViewInfo.CreateViewInfos;
|
|
var
|
|
ADiagram: TcxGridChartDiagram;
|
|
begin
|
|
inherited;
|
|
ADiagram := GridView.ActiveDiagram;
|
|
if ADiagram <> nil then
|
|
begin
|
|
FDiagramViewInfo := ADiagram.GetViewInfoClass.Create(Self, ADiagram);
|
|
FLegendViewInfo := ADiagram.GetLegendViewInfoClass.Create(Self, ADiagram);
|
|
end;
|
|
FTitleViewInfo := GetTitleViewInfoClass.Create(Self, GridView.Title);
|
|
FToolBoxViewInfo := GetToolBoxViewInfoClass.Create(Self);
|
|
end;
|
|
|
|
procedure TcxGridChartViewInfo.DestroyViewInfos(AIsRecreating: Boolean);
|
|
begin
|
|
FreeAndNil(FToolBoxViewInfo);
|
|
FreeAndNil(FTitleViewInfo);
|
|
FreeAndNil(FLegendViewInfo);
|
|
FreeAndNil(FDiagramViewInfo);
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartViewInfo.GetTitleViewInfoClass: TcxGridChartTitleViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartTitleViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartViewInfo.GetToolBoxViewInfoClass: TcxGridChartToolBoxViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartToolBoxViewInfo;
|
|
end;
|
|
|
|
procedure TcxGridChartViewInfo.Calculate;
|
|
var
|
|
ADiagramBounds, ALegendBounds, ATitleBounds, AToolBoxBounds: TRect;
|
|
begin
|
|
RecreateViewInfos;
|
|
inherited;
|
|
CalculatePartsBounds(ADiagramBounds, ALegendBounds, ATitleBounds, AToolBoxBounds);
|
|
if FDiagramViewInfo <> nil then
|
|
FDiagramViewInfo.Calculate(ADiagramBounds);
|
|
if FLegendViewInfo <> nil then
|
|
FLegendViewInfo.Calculate(ALegendBounds);
|
|
FTitleViewInfo.Calculate(ATitleBounds);
|
|
if FToolBoxViewInfo.Visible then
|
|
FToolBoxViewInfo.Calculate(AToolBoxBounds);
|
|
end;
|
|
|
|
function TcxGridChartViewInfo.CalculateClientBounds: TRect;
|
|
begin
|
|
Result := inherited CalculateClientBounds;
|
|
InflateRect(Result, -ChartPartOffset, -ChartPartOffset);
|
|
end;
|
|
|
|
procedure TcxGridChartViewInfo.CalculateHeight(const AMaxSize: TPoint;
|
|
var AHeight: Integer; var AFullyVisible: Boolean);
|
|
begin
|
|
AHeight := MaxInt div 2;
|
|
AFullyVisible := False;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartViewInfo.CalculatePartBounds(APart: TcxCustomGridChartPartViewInfo;
|
|
var ABounds, APartBounds: TRect);
|
|
begin
|
|
if APart.Visible then
|
|
begin
|
|
PositionRect(APartBounds, ABounds, APart.Width, APart.Height, ChartPartOffset, APart.Position);
|
|
AlignRect(APartBounds, APart.Width, APart.Height,
|
|
APart.Position in [cppTop, cppBottom], APart.Alignment);
|
|
end
|
|
else
|
|
SetRectEmpty(APartBounds);
|
|
end;
|
|
|
|
procedure TcxGridChartViewInfo.CalculatePartsBounds(out ADiagramBounds, ALegendBounds,
|
|
ATitleBounds, AToolBoxBounds: TRect);
|
|
begin
|
|
ADiagramBounds := ClientBounds;
|
|
CalculatePartBounds(FToolBoxViewInfo, ADiagramBounds, AToolBoxBounds);
|
|
CalculatePartBounds(FTitleViewInfo, ADiagramBounds, ATitleBounds);
|
|
if FLegendViewInfo <> nil then
|
|
CalculatePartBounds(FLegendViewInfo, ADiagramBounds, ALegendBounds);
|
|
end;
|
|
|
|
function TcxGridChartViewInfo.DoGetHitTest(const P: TPoint): TcxCustomGridHitTest;
|
|
begin
|
|
if FDiagramViewInfo <> nil then
|
|
Result := FDiagramViewInfo.GetHitTest(P)
|
|
else
|
|
Result := nil;
|
|
if Result = nil then
|
|
begin
|
|
Result := FToolBoxViewInfo.GetHitTest(P);
|
|
if Result = nil then
|
|
begin
|
|
if FLegendViewInfo <> nil then
|
|
Result := FLegendViewInfo.GetHitTest(P);
|
|
if Result = nil then
|
|
begin
|
|
Result := FTitleViewInfo.GetHitTest(P);
|
|
if Result = nil then
|
|
Result := inherited DoGetHitTest(P);
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TcxCustomGridChartTitle }
|
|
|
|
procedure TcxCustomGridChartTitle.SetAlignment(Value: TcxGridChartPartAlignment);
|
|
begin
|
|
if FAlignment <> Value then
|
|
begin
|
|
FAlignment := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridChartTitle.SetPosition(Value: TcxGridChartPartPosition);
|
|
begin
|
|
if FPosition <> Value then
|
|
begin
|
|
FPosition := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridChartTitle.SetText(Value: string);
|
|
begin
|
|
if FText <> Value then
|
|
begin
|
|
FText := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridChartTitle.GetStoredProperties(AProperties: TStrings);
|
|
begin
|
|
AProperties.Add('Title.Alignment');
|
|
AProperties.Add('Title.Position');
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxCustomGridChartTitle.GetStoredPropertyValue(const AName: string;
|
|
var AValue: Variant);
|
|
begin
|
|
if AName = 'Title.Alignment' then
|
|
AValue := Variant(Alignment)
|
|
else
|
|
if AName = 'Title.Position' then
|
|
AValue := Variant(Position);
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxCustomGridChartTitle.SetStoredPropertyValue(const AName: string;
|
|
const AValue: Variant);
|
|
begin
|
|
if AName = 'Title.Alignment' then
|
|
Alignment := TcxGridChartPartAlignment((AValue))
|
|
else
|
|
if AName = 'Title.Position' then
|
|
Position := TcxGridChartPartPosition((AValue));
|
|
inherited;
|
|
end;
|
|
|
|
function TcxCustomGridChartTitle.GetDefaultAlignment: TcxGridChartPartAlignment;
|
|
begin
|
|
Result := cpaCenter;
|
|
end;
|
|
|
|
function TcxCustomGridChartTitle.GetDefaultOrientation: TcxGridChartPartOrientation;
|
|
begin
|
|
if GetPosition in [cppTop, cppBottom] then
|
|
Result := cpoHorizontal
|
|
else
|
|
Result := cpoVertical;
|
|
end;
|
|
|
|
function TcxCustomGridChartTitle.GetDefaultText: string;
|
|
begin
|
|
Result := '';
|
|
end;
|
|
|
|
procedure TcxCustomGridChartTitle.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxCustomGridChartTitle then
|
|
with TcxCustomGridChartTitle(Source) do
|
|
begin
|
|
Self.Alignment := Alignment;
|
|
Self.Position := Position;
|
|
Self.Text := Text;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxCustomGridChartTitle.GetAlignment: TcxGridChartPartAlignment;
|
|
begin
|
|
Result := FAlignment;
|
|
if Result = cpaDefault then
|
|
Result := GetDefaultAlignment;
|
|
end;
|
|
|
|
function TcxCustomGridChartTitle.GetOrientation: TcxGridChartPartOrientation;
|
|
begin
|
|
Result := GetDefaultOrientation;
|
|
end;
|
|
|
|
function TcxCustomGridChartTitle.GetPosition: TcxGridChartPartPosition;
|
|
begin
|
|
if GetText = '' then
|
|
Result := cppNone
|
|
else
|
|
begin
|
|
Result := FPosition;
|
|
if Result = cppDefault then
|
|
Result := GetDefaultPosition;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridChartTitle.GetText: string;
|
|
begin
|
|
Result := FText;
|
|
if Result = '' then
|
|
Result := GetDefaultText;
|
|
end;
|
|
|
|
{ TcxGridChartLegend }
|
|
|
|
procedure TcxGridChartLegend.SetAlignment(Value: TcxGridChartPartAlignment);
|
|
begin
|
|
if FAlignment <> Value then
|
|
begin
|
|
FAlignment := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartLegend.SetBorder(Value: TcxGridChartLegendBorder);
|
|
begin
|
|
if FBorder <> Value then
|
|
begin
|
|
FBorder := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartLegend.SetKeyBorder(Value: TcxGridChartLegendBorder);
|
|
begin
|
|
if FKeyBorder <> Value then
|
|
begin
|
|
FKeyBorder := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartLegend.SetOrientation(Value: TcxGridChartPartOrientation);
|
|
begin
|
|
if FOrientation <> Value then
|
|
begin
|
|
FOrientation := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartLegend.SetPosition(Value: TcxGridChartPartPosition);
|
|
begin
|
|
if FPosition <> Value then
|
|
begin
|
|
FPosition := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartLegend.GetStoredProperties(AProperties: TStrings);
|
|
begin
|
|
AProperties.Add('Legend.Alignment');
|
|
AProperties.Add('Legend.Border');
|
|
AProperties.Add('Legend.KeyBorder');
|
|
AProperties.Add('Legend.Orientation');
|
|
AProperties.Add('Legend.Position');
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartLegend.GetStoredPropertyValue(const AName: string;
|
|
var AValue: Variant);
|
|
begin
|
|
if AName = 'Legend.Alignment' then
|
|
AValue := Variant(Alignment)
|
|
else
|
|
if AName = 'Legend.Border' then
|
|
AValue := Variant(Border)
|
|
else
|
|
if AName = 'Legend.KeyBorder' then
|
|
AValue := Variant(KeyBorder)
|
|
else
|
|
if AName = 'Legend.Orientation' then
|
|
AValue := Variant(Orientation)
|
|
else
|
|
if AName = 'Legend.Position' then
|
|
AValue := Variant(Position);
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartLegend.SetStoredPropertyValue(const AName: string;
|
|
const AValue: Variant);
|
|
begin
|
|
if AName = 'Legend.Alignment' then
|
|
Alignment := TcxGridChartPartAlignment((AValue))
|
|
else
|
|
if AName = 'Legend.Border' then
|
|
Border := TcxGridChartLegendBorder((AValue))
|
|
else
|
|
if AName = 'Legend.KeyBorder' then
|
|
KeyBorder := TcxGridChartLegendBorder((AValue))
|
|
else
|
|
if AName = 'Legend.Orientation' then
|
|
Orientation := TcxGridChartPartOrientation((AValue))
|
|
else
|
|
if AName = 'Legend.Position' then
|
|
Position := TcxGridChartPartPosition((AValue));
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartLegend.GetDefaultAlignment: TcxGridChartPartAlignment;
|
|
begin
|
|
Result := cpaCenter;
|
|
end;
|
|
|
|
function TcxGridChartLegend.GetDefaultBorder: TcxGridChartLegendBorder;
|
|
begin
|
|
Result := lbNone;
|
|
end;
|
|
|
|
function TcxGridChartLegend.GetDefaultKeyBorder: TcxGridChartLegendBorder;
|
|
begin
|
|
Result := lbSingle;
|
|
end;
|
|
|
|
function TcxGridChartLegend.GetDefaultOrientation(APosition: TcxGridChartPartPosition): TcxGridChartPartOrientation;
|
|
begin
|
|
if APosition in [cppTop, cppBottom] then
|
|
Result := cpoHorizontal
|
|
else
|
|
Result := cpoVertical;
|
|
end;
|
|
|
|
function TcxGridChartLegend.GetDefaultPosition: TcxGridChartPartPosition;
|
|
begin
|
|
Result := cppRight;
|
|
end;
|
|
|
|
procedure TcxGridChartLegend.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxGridChartLegend then
|
|
with TcxGridChartLegend(Source) do
|
|
begin
|
|
Self.Alignment := Alignment;
|
|
Self.Border := Border;
|
|
Self.KeyBorder := KeyBorder;
|
|
Self.Orientation := Orientation;
|
|
Self.Position := Position;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartLegend.GetAlignment: TcxGridChartPartAlignment;
|
|
begin
|
|
Result := FAlignment;
|
|
if Result = cpaDefault then
|
|
if Parent = nil then
|
|
Result := GetDefaultAlignment
|
|
else
|
|
Result := Parent.GetAlignment;
|
|
end;
|
|
|
|
function TcxGridChartLegend.GetBorder: TcxGridChartLegendBorder;
|
|
begin
|
|
Result := FBorder;
|
|
if Result = lbDefault then
|
|
if Parent = nil then
|
|
Result := GetDefaultBorder
|
|
else
|
|
Result := Parent.GetBorder;
|
|
end;
|
|
|
|
function TcxGridChartLegend.GetKeyBorder: TcxGridChartLegendBorder;
|
|
begin
|
|
Result := FKeyBorder;
|
|
if Result = lbDefault then
|
|
if Parent = nil then
|
|
Result := GetDefaultKeyBorder
|
|
else
|
|
Result := Parent.GetKeyBorder;
|
|
end;
|
|
|
|
function TcxGridChartLegend.GetOrientation(APosition: TcxGridChartPartPosition = cppDefault): TcxGridChartPartOrientation;
|
|
begin
|
|
Result := FOrientation;
|
|
if Result = cpoDefault then
|
|
if Parent = nil then
|
|
Result := GetDefaultOrientation(APosition)
|
|
else
|
|
begin
|
|
if APosition = cppDefault then
|
|
APosition := GetPosition;
|
|
Result := Parent.GetOrientation(APosition);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartLegend.GetPosition: TcxGridChartPartPosition;
|
|
begin
|
|
Result := FPosition;
|
|
if Result = cppDefault then
|
|
if Parent = nil then
|
|
Result := GetDefaultPosition
|
|
else
|
|
Result := Parent.GetPosition;
|
|
end;
|
|
|
|
{ TcxCustomGridChartDiagramOptions }
|
|
|
|
constructor TcxCustomGridChartDiagramOptions.Create(ADiagram: TcxGridChartDiagram);
|
|
begin
|
|
inherited Create;
|
|
FDiagram := ADiagram;
|
|
end;
|
|
|
|
function TcxCustomGridChartDiagramOptions.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := FDiagram.GridView;
|
|
end;
|
|
|
|
function TcxCustomGridChartDiagramOptions.GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
|
|
begin
|
|
Result := FDiagram.GridView.LookAndFeelPainter;
|
|
end;
|
|
|
|
procedure TcxCustomGridChartDiagramOptions.Changed(AChange: TcxGridDiagramChange = dcLayout);
|
|
begin
|
|
FDiagram.Changed(AChange);
|
|
end;
|
|
|
|
procedure TcxCustomGridChartDiagramOptions.Assign(Source: TPersistent);
|
|
begin
|
|
if not (Source is TcxCustomGridChartDiagramOptions) then
|
|
inherited;
|
|
end;
|
|
|
|
{ TcxGridChartDiagramValueData }
|
|
|
|
type
|
|
TcxGridChartDiagramValueData = class
|
|
ValueIndex: Integer;
|
|
VisibleSeriesIndex: Integer;
|
|
end;
|
|
|
|
{ TcxGridChartDiagramStyles }
|
|
|
|
constructor TcxGridChartDiagramStyles.Create(AOwner: TPersistent);
|
|
begin
|
|
inherited;
|
|
BitmapInViewParams := True;
|
|
end;
|
|
|
|
function TcxGridChartDiagramStyles.GetDiagram: TcxGridChartDiagram;
|
|
begin
|
|
Result := TcxGridChartDiagram(Owner);
|
|
end;
|
|
|
|
function TcxGridChartDiagramStyles.GetGridViewValue: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramStyles.GetDefaultViewParams(Index: Integer; AData: TObject;
|
|
out AParams: TcxViewParams);
|
|
begin
|
|
inherited;
|
|
with AParams, LookAndFeelPainter do
|
|
case Index of
|
|
dsLegend:
|
|
GridView.Styles.GetViewParams(vsLegend, AData, nil, AParams);
|
|
dsValueCaptions:
|
|
TextColor := DefaultChartDiagramValueCaptionTextColor;
|
|
dsValues:
|
|
with TcxGridChartDiagramValueData(AData) do
|
|
if VisibleSeriesIndex <> -1 then
|
|
GridView.VisibleSeries[VisibleSeriesIndex].Styles.GetValueParams(ValueIndex,
|
|
GetVaryColorsByCategory, AParams)
|
|
else
|
|
begin
|
|
Color := GetDefaultValueColor(ValueIndex);
|
|
TextColor := DefaultChartDiagramValueBorderColor;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartDiagramStyles.GetGridView: TcxCustomGridView;
|
|
begin
|
|
Result := Diagram.GridView;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramStyles.GetBackgroundParams(out AParams: TcxViewParams);
|
|
begin
|
|
GridView.Styles.GetViewParams(vsBackground, nil, nil, AParams);
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramStyles.GetValueParams(AVisibleSeriesIndex, AValueIndex: Integer;
|
|
out AParams: TcxViewParams);
|
|
var
|
|
AData: TcxGridChartDiagramValueData;
|
|
begin
|
|
AData := TcxGridChartDiagramValueData.Create;
|
|
try
|
|
AData.VisibleSeriesIndex := AVisibleSeriesIndex;
|
|
AData.ValueIndex := AValueIndex;
|
|
GetViewParams(dsValues, AData, nil, AParams);
|
|
finally
|
|
AData.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagramStyles.Assign(Source: TPersistent);
|
|
begin
|
|
inherited;
|
|
if Source is TcxGridChartDiagramStyles then
|
|
with TcxGridChartDiagramStyles(Source) do
|
|
begin
|
|
Self.Legend := Legend;
|
|
Self.ValueCaptions := ValueCaptions;
|
|
Self.Values := Values;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartDiagram }
|
|
|
|
constructor TcxGridChartDiagram.Create(AGridView: TcxGridChartView);
|
|
begin
|
|
inherited Create;
|
|
FEnabled := True;
|
|
CreateSubObjects(AGridView);
|
|
AGridView.AddDiagram(Self);
|
|
end;
|
|
|
|
destructor TcxGridChartDiagram.Destroy;
|
|
begin
|
|
FGridView.RemoveDiagram(Self);
|
|
DestroySubObjects;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartDiagram.GetActive: Boolean;
|
|
begin
|
|
Result := FGridView.ActiveDiagram = Self;
|
|
end;
|
|
|
|
function TcxGridChartDiagram.GetID: string;
|
|
begin
|
|
Result := ClassName;
|
|
Delete(Result, 1, Length('TcxGridChart'));
|
|
Insert(' ', Result, Pos('Diagram', Result));
|
|
end;
|
|
|
|
procedure TcxGridChartDiagram.SetActive(Value: Boolean);
|
|
begin
|
|
if Value then
|
|
FGridView.ActiveDiagram := Self;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagram.SetEnabled(Value: Boolean);
|
|
begin
|
|
if FEnabled <> Value then
|
|
begin
|
|
FEnabled := Value;
|
|
FGridView.RefreshAvailableDiagramList;
|
|
if IsAvailable then
|
|
if FGridView.ActiveDiagram = nil then
|
|
Active := True
|
|
else
|
|
else
|
|
if Active then
|
|
FGridView.ActiveDiagram := nil;
|
|
Changed(dcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagram.SetLegend(Value: TcxGridChartLegend);
|
|
begin
|
|
FLegend.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartDiagram.SetStyles(Value: TcxGridChartDiagramStyles);
|
|
begin
|
|
FStyles.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartDiagram.SetOnCustomDrawLegend(Value: TcxGridChartDiagramLegendCustomDrawEvent);
|
|
begin
|
|
if @FOnCustomDrawLegend <> @Value then
|
|
begin
|
|
FOnCustomDrawLegend := Value;
|
|
Changed(dcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagram.SetOnCustomDrawLegendItem(Value: TcxGridChartDiagramLegendItemCustomDrawEvent);
|
|
begin
|
|
if @FOnCustomDrawLegendItem <> @Value then
|
|
begin
|
|
FOnCustomDrawLegendItem := Value;
|
|
Changed(dcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagram.SetOnCustomDrawValue(Value: TcxGridChartDiagramValueCustomDrawEvent);
|
|
begin
|
|
if @FOnCustomDrawValue <> @Value then
|
|
begin
|
|
FOnCustomDrawValue := Value;
|
|
Changed(dcProperty);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartDiagram.GetOwner: TPersistent;
|
|
begin
|
|
Result := FGridView;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagram.CreateSubObjects(AGridView: TcxGridChartView);
|
|
begin
|
|
FLegend := AGridView.GetLegendClass.Create(AGridView);
|
|
FLegend.Parent := AGridView.Legend;
|
|
FStyles := GetStylesClass.Create(Self);
|
|
end;
|
|
|
|
procedure TcxGridChartDiagram.DestroySubObjects;
|
|
begin
|
|
FreeAndNil(FStyles);
|
|
FreeAndNil(FLegend);
|
|
end;
|
|
|
|
procedure TcxGridChartDiagram.SetGridView(Value: TcxGridChartView);
|
|
begin
|
|
FGridView := Value;
|
|
end;
|
|
|
|
function TcxGridChartDiagram.GetStylesClass: TcxGridChartDiagramStylesClass;
|
|
begin
|
|
Result := TcxGridChartDiagramStyles;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagram.Changed(AChange: TcxGridDiagramChange = dcLayout);
|
|
begin
|
|
//if FGridView <> nil then
|
|
FGridView.Changed(TcxGridViewChangeKind(AChange));
|
|
end;
|
|
|
|
function TcxGridChartDiagram.GetDisplayText: string;
|
|
begin
|
|
Result := ID;
|
|
end;
|
|
|
|
function TcxGridChartDiagram.GetImageIndex: Integer;
|
|
begin
|
|
Result := -1;
|
|
end;
|
|
|
|
function TcxGridChartDiagram.HorizontalPaging: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TcxGridChartDiagram.PagingInOppositeDirection: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxGridChartDiagram.SupportsPaging: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxGridChartDiagram.SupportsValueHotTrack: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TcxGridChartDiagram.DoCustomDrawLegend(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxGridChartLegendViewInfo; var ADone: Boolean);
|
|
begin
|
|
if HasCustomDrawLegend then
|
|
FOnCustomDrawLegend(Self, ACanvas, AViewInfo, ADone);
|
|
end;
|
|
|
|
procedure TcxGridChartDiagram.DoCustomDrawLegendItem(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxGridChartLegendItemViewInfo; var ADone: Boolean);
|
|
begin
|
|
if HasCustomDrawLegendItem then
|
|
FOnCustomDrawLegendItem(Self, ACanvas, AViewInfo, ADone);
|
|
end;
|
|
|
|
procedure TcxGridChartDiagram.DoCustomDrawValue(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxGridChartDiagramValueViewInfo; var ADone: Boolean);
|
|
begin
|
|
if HasCustomDrawValue then
|
|
FOnCustomDrawValue(Self, ACanvas, AViewInfo, ADone);
|
|
end;
|
|
|
|
function TcxGridChartDiagram.HasCustomDrawLegend: Boolean;
|
|
begin
|
|
Result := Assigned(FOnCustomDrawLegend);
|
|
end;
|
|
|
|
function TcxGridChartDiagram.HasCustomDrawLegendItem: Boolean;
|
|
begin
|
|
Result := Assigned(FOnCustomDrawLegendItem);
|
|
end;
|
|
|
|
function TcxGridChartDiagram.HasCustomDrawValue: Boolean;
|
|
begin
|
|
Result := Assigned(FOnCustomDrawValue);
|
|
end;
|
|
|
|
procedure TcxGridChartDiagram.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxGridChartDiagram then
|
|
with TcxGridChartDiagram(Source) do
|
|
begin
|
|
Self.Enabled := Enabled; // must be assigned before Active
|
|
Self.Active := Active;
|
|
Self.Legend := Legend;
|
|
Self.Styles := Styles;
|
|
Self.OnCustomDrawLegend := OnCustomDrawLegend;
|
|
Self.OnCustomDrawLegendItem := OnCustomDrawLegendItem;
|
|
Self.OnCustomDrawValue := OnCustomDrawValue;
|
|
end
|
|
else
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartDiagram.GetNamePath: string;
|
|
begin
|
|
Result := FGridView.GetDiagramNamePath(Self);
|
|
end;
|
|
|
|
function TcxGridChartDiagram.GetValueCaption(ASeries: TcxGridChartSeries;
|
|
AValueIndex: Integer): string;
|
|
begin
|
|
Result := ASeries.VisibleDisplayTexts[AValueIndex];
|
|
end;
|
|
|
|
function TcxGridChartDiagram.IsAvailable: Boolean;
|
|
begin
|
|
Result := FEnabled;
|
|
end;
|
|
|
|
{ TcxGridChartHistogramAxisTitle }
|
|
|
|
constructor TcxGridChartHistogramAxisTitle.Create(AAxis: TcxGridChartHistogramAxis);
|
|
begin
|
|
FAxis := AAxis;
|
|
inherited Create(nil);
|
|
end;
|
|
|
|
function TcxGridChartHistogramAxisTitle.GetDefaultPosition: TcxGridChartPartPosition;
|
|
begin
|
|
Result := FAxis.GetPosition;
|
|
end;
|
|
|
|
function TcxGridChartHistogramAxisTitle.GetDefaultText: string;
|
|
begin
|
|
Result := inherited GetDefaultText;
|
|
if Result = '' then
|
|
Result := FAxis.GetTitleDefaultText;
|
|
end;
|
|
|
|
function TcxGridChartHistogramAxisTitle.GetGridViewValue: TcxCustomGridView;
|
|
begin
|
|
Result := FAxis.GridView;
|
|
end;
|
|
|
|
{ TcxGridChartHistogramAxis }
|
|
|
|
constructor TcxGridChartHistogramAxis.Create(ADiagram: TcxGridChartDiagram);
|
|
begin
|
|
inherited;
|
|
FGridLines := True;
|
|
FTickMarkKind := tmkOutside;
|
|
FTickMarkLabels := True;
|
|
FTitle := GetTitleClass.Create(Self);
|
|
FVisible := True;
|
|
end;
|
|
|
|
destructor TcxGridChartHistogramAxis.Destroy;
|
|
begin
|
|
FreeAndNil(FTitle);
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartHistogramAxis.GetDiagram: TcxGridChartHistogram;
|
|
begin
|
|
Result := TcxGridChartHistogram(inherited Diagram);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramAxis.SetGridLines(Value: Boolean);
|
|
begin
|
|
if FGridLines <> Value then
|
|
begin
|
|
FGridLines := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramAxis.SetTickMarkKind(Value: TcxGridChartHistogramTickMarkKind);
|
|
begin
|
|
if FTickMarkKind <> Value then
|
|
begin
|
|
FTickMarkKind := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramAxis.SetTickMarkLabels(Value: Boolean);
|
|
begin
|
|
if FTickMarkLabels <> Value then
|
|
begin
|
|
FTickMarkLabels := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramAxis.SetTitle(Value: TcxGridChartHistogramAxisTitle);
|
|
begin
|
|
FTitle.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramAxis.SetVisible(Value: Boolean);
|
|
begin
|
|
if FVisible <> Value then
|
|
begin
|
|
FVisible := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartHistogramAxis.GetTitleClass: TcxGridChartHistogramAxisTitleClass;
|
|
begin
|
|
Result := TcxGridChartHistogramAxisTitle;
|
|
end;
|
|
|
|
function TcxGridChartHistogramAxis.GetTitleDefaultText: string;
|
|
begin
|
|
Result := '';
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramAxis.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxGridChartHistogramAxis then
|
|
with TcxGridChartHistogramAxis(Source) do
|
|
begin
|
|
Self.GridLines := GridLines;
|
|
Self.TickMarkKind := TickMarkKind;
|
|
Self.TickMarkLabels := TickMarkLabels;
|
|
Self.Title := Title;
|
|
Self.Visible := Visible;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
{ TcxGridChartHistogramAxisCategory }
|
|
|
|
constructor TcxGridChartHistogramAxisCategory.Create(ADiagram: TcxGridChartDiagram);
|
|
begin
|
|
inherited;
|
|
FValueAxisBetweenCategories := GetDefaultValueAxisBetweenCategories;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramAxisCategory.SetCategoriesInReverseOrder(Value: Boolean);
|
|
begin
|
|
if FCategoriesInReverseOrder <> Value then
|
|
begin
|
|
FCategoriesInReverseOrder := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramAxisCategory.SetValueAxisAtMaxCategory(Value: Boolean);
|
|
begin
|
|
if FValueAxisAtMaxCategory <> Value then
|
|
begin
|
|
FValueAxisAtMaxCategory := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramAxisCategory.SetValueAxisBetweenCategories(Value: Boolean);
|
|
begin
|
|
if FValueAxisBetweenCategories <> Value then
|
|
begin
|
|
FValueAxisBetweenCategories := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartHistogramAxisCategory.GetDefaultValueAxisBetweenCategories: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TcxGridChartHistogramAxisCategory.GetTitleDefaultText: string;
|
|
begin
|
|
Result := inherited GetTitleDefaultText;
|
|
if Result = '' then
|
|
if GridView.ViewData.IsSummaryLevel then
|
|
Result := GridView.ActiveDataGroup.DisplayText
|
|
else
|
|
Result := GridView.Categories.DisplayText;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramAxisCategory.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxGridChartHistogramAxisCategory then
|
|
with TcxGridChartHistogramAxisCategory(Source) do
|
|
begin
|
|
Self.CategoriesInReverseOrder := CategoriesInReverseOrder;
|
|
Self.ValueAxisAtMaxCategory := ValueAxisAtMaxCategory;
|
|
Self.ValueAxisBetweenCategories := ValueAxisBetweenCategories;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartHistogramAxisCategory.GetPosition: TcxGridChartAxisPosition;
|
|
begin
|
|
Result := Diagram.GetCategoryAxisPosition;
|
|
end;
|
|
|
|
{ TcxGridChartHistogramAxisValue }
|
|
|
|
procedure TcxGridChartHistogramAxisValue.SetMaxValue(const Value: Extended);
|
|
begin
|
|
if FMaxValue <> Value then
|
|
begin
|
|
FMaxValue := Value;
|
|
if not GridView.IsLoading and (FMaxValue <> 0) then
|
|
MinMaxValues := mmvCustom;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramAxisValue.SetMinMaxValues(Value: TcxGridChartHistogramMinMaxValues);
|
|
begin
|
|
if FMinMaxValues <> Value then
|
|
begin
|
|
FMinMaxValues := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramAxisValue.SetMinValue(const Value: Extended);
|
|
begin
|
|
if FMinValue <> Value then
|
|
begin
|
|
FMinValue := Value;
|
|
if not GridView.IsLoading and (FMinValue <> 0) then
|
|
MinMaxValues := mmvCustom;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramAxisValue.SetTickMarkLabelFormat(const Value: string);
|
|
begin
|
|
if FTickMarkLabelFormat <> Value then
|
|
begin
|
|
FTickMarkLabelFormat := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartHistogramAxisValue.GetTitleDefaultText: string;
|
|
begin
|
|
Result := inherited GetTitleDefaultText;
|
|
if (Result = '') and (GridView.VisibleSeriesCount = 1) then
|
|
Result := GridView.VisibleSeries[0].DisplayText;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramAxisValue.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxGridChartHistogramAxisValue then
|
|
with TcxGridChartHistogramAxisValue(Source) do
|
|
begin
|
|
Self.MinValue := MinValue;
|
|
Self.MaxValue := MaxValue;
|
|
Self.MinMaxValues := MinMaxValues; // should be after Min/MaxValue
|
|
Self.TickMarkLabelFormat := TickMarkLabelFormat;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartHistogramAxisValue.GetPosition: TcxGridChartAxisPosition;
|
|
begin
|
|
Result := Diagram.GetValueAxisPosition;
|
|
end;
|
|
|
|
function TcxGridChartHistogramAxisValue.GetTickMarkLabel(const ATickMarkValue: Variant): string;
|
|
var
|
|
ATickMarkLabelFormat: string;
|
|
begin
|
|
ATickMarkLabelFormat := GetTickMarkLabelFormat(False);
|
|
if ATickMarkLabelFormat = '' then
|
|
case GridView.VisibleSeriesCount of
|
|
0: Result := ATickMarkValue;
|
|
1: Result := GridView.VisibleSeries[0].GetValueDisplayText(ATickMarkValue);
|
|
else
|
|
ATickMarkLabelFormat := GetTickMarkLabelFormat(True);
|
|
if ATickMarkLabelFormat = '' then
|
|
Result := GridView.VisibleSeries[0].DataBinding.GetValueDisplayText(ATickMarkValue)
|
|
else
|
|
Result := FormatFloat(ATickMarkLabelFormat, ATickMarkValue);
|
|
end
|
|
else
|
|
Result := FormatFloat(ATickMarkLabelFormat, ATickMarkValue);
|
|
end;
|
|
|
|
function TcxGridChartHistogramAxisValue.GetTickMarkLabelFormat(AConsiderSeriesFormat: Boolean): string;
|
|
var
|
|
I: Integer;
|
|
AValueCaptionFormat: string;
|
|
begin
|
|
if Diagram.Values.Stacking = vs100Percent then
|
|
Result := cxGetResourceString(@scxGridChartPercentValueTickMarkLabelFormat)
|
|
else
|
|
begin
|
|
Result := TickMarkLabelFormat;
|
|
if (Result = '') and AConsiderSeriesFormat then
|
|
for I := 0 to GridView.VisibleSeriesCount - 1 do
|
|
begin
|
|
AValueCaptionFormat := GridView.VisibleSeries[I].ValueCaptionFormat;
|
|
if (I <> 0) and (AValueCaptionFormat <> Result) then
|
|
begin
|
|
Result := '';
|
|
Break;
|
|
end;
|
|
Result := AValueCaptionFormat;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartHistogramStyles }
|
|
|
|
procedure TcxGridChartHistogramStyles.GetDefaultViewParams(Index: Integer;
|
|
AData: TObject; out AParams: TcxViewParams);
|
|
begin
|
|
inherited;
|
|
with AParams, LookAndFeelPainter do
|
|
case Index of
|
|
dsAxis:
|
|
begin
|
|
Color := DefaultChartHistogramAxisColor;
|
|
TextColor := DefaultContentTextColor;
|
|
end;
|
|
dsCategoryAxis, dsValueAxis:
|
|
GetViewParams(dsAxis, nil, nil, AParams);
|
|
dsAxisTitle:
|
|
TextColor := DefaultContentTextColor;
|
|
dsCategoryAxisTitle, dsValueAxisTitle:
|
|
GetViewParams(dsAxisTitle, nil, nil, AParams);
|
|
dsGridLines:
|
|
Color := DefaultChartHistogramGridLineColor;
|
|
dsCategoryGridLines, dsValueGridLines:
|
|
GetViewParams(dsGridLines, nil, nil, AParams);
|
|
dsPlot:
|
|
Color := DefaultChartHistogramPlotColor;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartHistogramStyles.GetVaryColorsByCategory: Boolean;
|
|
begin
|
|
Result := TcxGridChartColumnDiagram(Diagram).Values.GetVaryColorsByCategory;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramStyles.Assign(Source: TPersistent);
|
|
begin
|
|
inherited;
|
|
if Source is TcxGridChartHistogramStyles then
|
|
with TcxGridChartHistogramStyles(Source) do
|
|
begin
|
|
Self.Axis := Axis;
|
|
Self.AxisTitle := AxisTitle;
|
|
Self.CategoryAxis := CategoryAxis;
|
|
Self.CategoryAxisTitle := CategoryAxisTitle;
|
|
Self.CategoryGridLines := CategoryGridLines;
|
|
Self.GridLines := GridLines;
|
|
Self.Plot := Plot;
|
|
Self.ValueAxis := ValueAxis;
|
|
Self.ValueAxisTitle := ValueAxisTitle;
|
|
Self.ValueGridLines := ValueGridLines;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartHistogramValues }
|
|
|
|
procedure TcxGridChartHistogramValues.SetStacking(Value: TcxGridChartValuesStacking);
|
|
begin
|
|
if FStacking <> Value then
|
|
begin
|
|
FStacking := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramValues.SetVaryColorsByCategory(Value: Boolean);
|
|
begin
|
|
if FVaryColorsByCategory <> Value then
|
|
begin
|
|
FVaryColorsByCategory := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogramValues.Assign(Source: TPersistent);
|
|
begin
|
|
inherited;
|
|
if Source is TcxGridChartHistogramValues then
|
|
with TcxGridChartHistogramValues(Source) do
|
|
begin
|
|
Self.Stacking := Stacking;
|
|
Self.VaryColorsByCategory := VaryColorsByCategory;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartHistogramValues.GetVaryColorsByCategory: Boolean;
|
|
begin
|
|
Result := (GridView.VisibleSeriesCount = 1) and FVaryColorsByCategory;
|
|
end;
|
|
|
|
{ TcxGridChartHistogram }
|
|
|
|
function TcxGridChartHistogram.GetStyles: TcxGridChartHistogramStyles;
|
|
begin
|
|
Result := TcxGridChartHistogramStyles(inherited Styles);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogram.SetAxisCategory(Value: TcxGridChartHistogramAxisCategory);
|
|
begin
|
|
FAxisCategory.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogram.SetAxisValue(Value: TcxGridChartHistogramAxisValue);
|
|
begin
|
|
FAxisValue.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogram.SetStyles(Value: TcxGridChartHistogramStyles);
|
|
begin
|
|
inherited Styles := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogram.SetValues(Value: TcxGridChartHistogramValues);
|
|
begin
|
|
FValues.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogram.SetOnCustomDrawPlot(Value: TcxGridChartHistogramPlotCustomDrawEvent);
|
|
begin
|
|
if @FOnCustomDrawPlot <> @Value then
|
|
begin
|
|
FOnCustomDrawPlot := Value;
|
|
Changed(dcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogram.CreateSubObjects(AGridView: TcxGridChartView);
|
|
begin
|
|
inherited;
|
|
FAxisCategory := GetAxisCategoryClass.Create(Self);
|
|
FAxisValue := GetAxisValueClass.Create(Self);
|
|
FValues := GetValuesClass.Create(Self);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogram.DestroySubObjects;
|
|
begin
|
|
FreeAndNil(FValues);
|
|
FreeAndNil(FAxisValue);
|
|
FreeAndNil(FAxisCategory);
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartHistogram.GetAxisCategoryClass: TcxGridChartHistogramAxisCategoryClass;
|
|
begin
|
|
Result := TcxGridChartHistogramAxisCategory;
|
|
end;
|
|
|
|
function TcxGridChartHistogram.GetAxisValueClass: TcxGridChartHistogramAxisValueClass;
|
|
begin
|
|
Result := TcxGridChartHistogramAxisValue;
|
|
end;
|
|
|
|
function TcxGridChartHistogram.GetStylesClass: TcxGridChartDiagramStylesClass;
|
|
begin
|
|
Result := TcxGridChartHistogramStyles;
|
|
end;
|
|
|
|
function TcxGridChartHistogram.GetValuesClass: TcxGridChartHistogramValuesClass;
|
|
begin
|
|
Result := TcxGridChartHistogramValues;
|
|
end;
|
|
|
|
function TcxGridChartHistogram.GetLegendViewInfoClass: TcxGridChartLegendViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartHistogramLegendViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartHistogram.PagingInOppositeDirection: Boolean;
|
|
begin
|
|
Result := AxisCategory.CategoriesInReverseOrder;
|
|
end;
|
|
|
|
function TcxGridChartHistogram.SupportsPaging: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TcxGridChartHistogram.DoCustomDrawPlot(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxGridChartHistogramViewInfo; const ABounds: TRect; var ADone: Boolean);
|
|
begin
|
|
if HasCustomDrawPlot then
|
|
FOnCustomDrawPlot(Self, ACanvas, AViewInfo, ABounds, ADone);
|
|
end;
|
|
|
|
function TcxGridChartHistogram.HasCustomDrawPlot: Boolean;
|
|
begin
|
|
Result := Assigned(FOnCustomDrawPlot);
|
|
end;
|
|
|
|
procedure TcxGridChartHistogram.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxGridChartHistogram then
|
|
with TcxGridChartHistogram(Source) do
|
|
begin
|
|
Self.AxisCategory := AxisCategory;
|
|
Self.AxisValue := AxisValue;
|
|
Self.Values := Values;
|
|
Self.OnCustomDrawPlot := OnCustomDrawPlot;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartHistogram.GetCategoryAxisPosition: TcxGridChartAxisPosition;
|
|
begin
|
|
Result := cppBottom;
|
|
end;
|
|
|
|
function TcxGridChartHistogram.GetValueAxisPosition: TcxGridChartAxisPosition;
|
|
begin
|
|
if AxisCategory.ValueAxisAtMaxCategory xor AxisCategory.CategoriesInReverseOrder then
|
|
Result := cppRight
|
|
else
|
|
Result := cppLeft;
|
|
end;
|
|
|
|
{ TcxGridChartColumnDiagramValues }
|
|
|
|
constructor TcxGridChartColumnDiagramValues.Create(ADiagram: TcxGridChartDiagram);
|
|
begin
|
|
inherited;
|
|
FBorderWidth := cxGridChartColumnDiagramDefaultBorderWidth;
|
|
end;
|
|
|
|
procedure TcxGridChartColumnDiagramValues.SetBorderWidth(Value: Integer);
|
|
begin
|
|
if Value < 0 then Value := 0;
|
|
if FBorderWidth <> Value then
|
|
begin
|
|
FBorderWidth := Value;
|
|
Changed;
|
|
end
|
|
end;
|
|
|
|
procedure TcxGridChartColumnDiagramValues.SetCaptionPosition(Value: TcxGridChartColumnDiagramValueCaptionPosition);
|
|
begin
|
|
if FCaptionPosition <> Value then
|
|
begin
|
|
FCaptionPosition := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartColumnDiagramValues.Assign(Source: TPersistent);
|
|
begin
|
|
inherited;
|
|
if Source is TcxGridChartColumnDiagramValues then
|
|
with TcxGridChartColumnDiagramValues(Source) do
|
|
begin
|
|
Self.BorderWidth := BorderWidth;
|
|
Self.CaptionPosition := CaptionPosition;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartColumnDiagram }
|
|
|
|
function TcxGridChartColumnDiagram.GetValues: TcxGridChartColumnDiagramValues;
|
|
begin
|
|
Result := TcxGridChartColumnDiagramValues(inherited Values);
|
|
end;
|
|
|
|
procedure TcxGridChartColumnDiagram.SetValues(Value: TcxGridChartColumnDiagramValues);
|
|
begin
|
|
inherited Values := Value;
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagram.GetLegendViewInfoClass: TcxGridChartLegendViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartColumnDiagramLegendViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagram.GetValuesClass: TcxGridChartHistogramValuesClass;
|
|
begin
|
|
Result := TcxGridChartColumnDiagramValues;
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagram.GetViewInfoClass: TcxGridChartDiagramViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartColumnDiagramViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagram.GetDisplayText: string;
|
|
begin
|
|
Result := cxGetResourceString(@scxGridChartColumnDiagramDisplayText);
|
|
end;
|
|
|
|
function TcxGridChartColumnDiagram.GetImageIndex: Integer;
|
|
begin
|
|
Result := 2;
|
|
end;
|
|
|
|
{ TcxGridChartBarDiagram }
|
|
|
|
function TcxGridChartBarDiagram.GetDisplayText: string;
|
|
begin
|
|
Result := cxGetResourceString(@scxGridChartBarDiagramDisplayText);
|
|
end;
|
|
|
|
function TcxGridChartBarDiagram.GetImageIndex: Integer;
|
|
begin
|
|
Result := 1;
|
|
end;
|
|
|
|
function TcxGridChartBarDiagram.HorizontalPaging: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxGridChartBarDiagram.PagingInOppositeDirection: Boolean;
|
|
begin
|
|
Result := not inherited PagingInOppositeDirection;
|
|
end;
|
|
|
|
function TcxGridChartBarDiagram.GetCategoryAxisPosition: TcxGridChartAxisPosition;
|
|
begin
|
|
Result := cppLeft;
|
|
end;
|
|
|
|
function TcxGridChartBarDiagram.GetValueAxisPosition: TcxGridChartAxisPosition;
|
|
begin
|
|
if AxisCategory.ValueAxisAtMaxCategory xor AxisCategory.CategoriesInReverseOrder then
|
|
Result := cppTop
|
|
else
|
|
Result := cppBottom;
|
|
end;
|
|
|
|
{ TcxGridChartLineDiagramAxisCategory }
|
|
|
|
function TcxGridChartLineDiagramAxisCategory.GetDefaultValueAxisBetweenCategories: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
{ TcxGridChartLineDiagramStyles }
|
|
|
|
procedure TcxGridChartLineDiagramStyles.GetDefaultViewParams(Index: Integer;
|
|
AData: TObject; out AParams: TcxViewParams);
|
|
begin
|
|
inherited;
|
|
if Index = dsValueMarkers then
|
|
begin
|
|
with TcxGridChartDiagramValueData(AData) do
|
|
GetValueParams(VisibleSeriesIndex, ValueIndex, AParams);
|
|
if not ValueMarkerHasBorderByDefault then
|
|
AParams.TextColor := AParams.Color;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramStyles.ValueMarkerHasBorderByDefault: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramStyles.Assign(Source: TPersistent);
|
|
begin
|
|
inherited;
|
|
if Source is TcxGridChartLineDiagramStyles then
|
|
ValueMarkers := TcxGridChartLineDiagramStyles(Source).ValueMarkers;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramStyles.GetValueMarkerParams(AVisibleSeriesIndex, AValueIndex: Integer;
|
|
out AParams: TcxViewParams);
|
|
var
|
|
AData: TcxGridChartDiagramValueData;
|
|
begin
|
|
AData := TcxGridChartDiagramValueData.Create;
|
|
try
|
|
AData.VisibleSeriesIndex := AVisibleSeriesIndex;
|
|
AData.ValueIndex := AValueIndex;
|
|
GetViewParams(dsValueMarkers, AData, nil, AParams);
|
|
finally
|
|
AData.Free;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartLineDiagramValues }
|
|
|
|
constructor TcxGridChartLineDiagramValues.Create(ADiagram: TcxGridChartDiagram);
|
|
begin
|
|
inherited;
|
|
FHotSpotSize := cxGridChartLineDiagramDefaultHotSpotSize;
|
|
FLineStyle := clsSolid;
|
|
FLineWidth := cxGridChartLineDiagramDefaultLineWidth;
|
|
FMarkerSize := cxGridChartLineDiagramDefaultMarkerSize;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValues.GetDiagram: TcxGridChartLineDiagram;
|
|
begin
|
|
Result := TcxGridChartLineDiagram(inherited Diagram);
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValues.SetCaptionPosition(Value: TcxGridChartLineDiagramValueCaptionPosition);
|
|
begin
|
|
if FCaptionPosition <> Value then
|
|
begin
|
|
FCaptionPosition := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValues.SetHotSpotSize(Value: Integer);
|
|
begin
|
|
if Value < 0 then Value := 0;
|
|
if FHotSpotSize <> Value then
|
|
begin
|
|
FHotSpotSize := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValues.SetLineStyle(Value: TcxGridChartLineStyle);
|
|
begin
|
|
if FLineStyle <> Value then
|
|
begin
|
|
FLineStyle := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValues.SetLineWidth(Value: Integer);
|
|
begin
|
|
if Value < 1 then Value := 1;
|
|
if FLineWidth <> Value then
|
|
begin
|
|
FLineWidth := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValues.SetMarkerSize(Value: Integer);
|
|
begin
|
|
if Value < 3 then Value := 3;
|
|
if FMarkerSize <> Value then
|
|
begin
|
|
FMarkerSize := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValues.SetMarkerStyle(Value: TcxGridChartMarkerStyle);
|
|
begin
|
|
if FMarkerStyle <> Value then
|
|
begin
|
|
FMarkerStyle := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValues.SetOnGetLineStyle(Value: TcxGridChartLineDiagramGetLineStyleEvent);
|
|
begin
|
|
if @FOnGetLineStyle <> @Value then
|
|
begin
|
|
FOnGetLineStyle := Value;
|
|
Changed(dcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValues.SetOnGetMarkerStyle(Value: TcxGridChartLineDiagramGetMarkerStyleEvent);
|
|
begin
|
|
if @FOnGetMarkerStyle <> @Value then
|
|
begin
|
|
FOnGetMarkerStyle := Value;
|
|
Changed(dcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValues.DoGetLineStyle(ASeries: TcxGridChartSeries;
|
|
var AStyle: TcxGridChartLineStyle);
|
|
begin
|
|
if Assigned(FOnGetLineStyle) then FOnGetLineStyle(Diagram, ASeries, AStyle);
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValues.DoGetMarkerStyle(ASeries: TcxGridChartSeries;
|
|
var AStyle: TcxGridChartMarkerStyle);
|
|
begin
|
|
if Assigned(FOnGetMarkerStyle) then FOnGetMarkerStyle(Diagram, ASeries, AStyle);
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagramValues.Assign(Source: TPersistent);
|
|
begin
|
|
inherited;
|
|
if Source is TcxGridChartLineDiagramValues then
|
|
with TcxGridChartLineDiagramValues(Source) do
|
|
begin
|
|
Self.CaptionPosition := CaptionPosition;
|
|
Self.HotSpotSize := HotSpotSize;
|
|
Self.LineStyle := LineStyle;
|
|
Self.LineWidth := LineWidth;
|
|
Self.MarkerSize := MarkerSize;
|
|
Self.MarkerStyle := MarkerStyle;
|
|
Self.OnGetLineStyle := OnGetLineStyle;
|
|
Self.OnGetMarkerStyle := OnGetMarkerStyle;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValues.GetHotSpotSize: Integer;
|
|
begin
|
|
Result := FHotSpotSize;
|
|
if MarkerStyle <> cmsNone then
|
|
Result := Max(Result, MarkerSize);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValues.GetLineStyle(ASeries: TcxGridChartSeries): TcxGridChartLineStyle;
|
|
begin
|
|
Result := FLineStyle;
|
|
DoGetLineStyle(ASeries, Result);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagramValues.GetMarkerStyle(ASeries: TcxGridChartSeries): TcxGridChartMarkerStyle;
|
|
begin
|
|
Result := FMarkerStyle;
|
|
DoGetMarkerStyle(ASeries, Result);
|
|
end;
|
|
|
|
{ TcxGridChartLineDiagram }
|
|
|
|
function TcxGridChartLineDiagram.GetAxisCategory: TcxGridChartLineDiagramAxisCategory;
|
|
begin
|
|
Result := TcxGridChartLineDiagramAxisCategory(inherited AxisCategory);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagram.GetStyles: TcxGridChartLineDiagramStyles;
|
|
begin
|
|
Result := TcxGridChartLineDiagramStyles(inherited Styles);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagram.GetValues: TcxGridChartLineDiagramValues;
|
|
begin
|
|
Result := TcxGridChartLineDiagramValues(inherited Values);
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagram.SetAxisCategory(Value: TcxGridChartLineDiagramAxisCategory);
|
|
begin
|
|
inherited AxisCategory := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagram.SetStyles(Value: TcxGridChartLineDiagramStyles);
|
|
begin
|
|
inherited Styles := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartLineDiagram.SetValues(Value: TcxGridChartLineDiagramValues);
|
|
begin
|
|
inherited Values := Value;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagram.GetAxisCategoryClass: TcxGridChartHistogramAxisCategoryClass;
|
|
begin
|
|
Result := TcxGridChartLineDiagramAxisCategory;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagram.GetLegendViewInfoClass: TcxGridChartLegendViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartLineDiagramLegendViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagram.GetStylesClass: TcxGridChartDiagramStylesClass;
|
|
begin
|
|
Result := TcxGridChartLineDiagramStyles;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagram.GetValuesClass: TcxGridChartHistogramValuesClass;
|
|
begin
|
|
Result := TcxGridChartLineDiagramValues;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagram.GetViewInfoClass: TcxGridChartDiagramViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartLineDiagramViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagram.GetDisplayText: string;
|
|
begin
|
|
Result := cxGetResourceString(@scxGridChartLineDiagramDisplayText);
|
|
end;
|
|
|
|
function TcxGridChartLineDiagram.GetImageIndex: Integer;
|
|
begin
|
|
Result := 3;
|
|
end;
|
|
|
|
function TcxGridChartLineDiagram.SupportsValueHotTrack: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
{ TcxGridChartAreaDiagramStyles }
|
|
|
|
function TcxGridChartAreaDiagramStyles.ValueMarkerHasBorderByDefault: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
{ TcxGridChartAreaDiagram }
|
|
|
|
function TcxGridChartAreaDiagram.GetStyles: TcxGridChartAreaDiagramStyles;
|
|
begin
|
|
Result := TcxGridChartAreaDiagramStyles(inherited Styles);
|
|
end;
|
|
|
|
procedure TcxGridChartAreaDiagram.SetStyles(Value: TcxGridChartAreaDiagramStyles);
|
|
begin
|
|
inherited Styles := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartAreaDiagram.SetOnCustomDrawValueArea(Value: TcxGridChartAreaDiagramValueAreaCustomDrawEvent);
|
|
begin
|
|
if @FOnCustomDrawValueArea <> @Value then
|
|
begin
|
|
FOnCustomDrawValueArea := Value;
|
|
Changed(dcProperty);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagram.GetLegendViewInfoClass: TcxGridChartLegendViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartAreaDiagramLegendViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagram.GetStylesClass: TcxGridChartDiagramStylesClass;
|
|
begin
|
|
Result := TcxGridChartAreaDiagramStyles;
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagram.GetViewInfoClass: TcxGridChartDiagramViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartAreaDiagramViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagram.GetDisplayText: string;
|
|
begin
|
|
Result := cxGetResourceString(@scxGridChartAreaDiagramDisplayText);
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagram.GetImageIndex: Integer;
|
|
begin
|
|
Result := 0;
|
|
end;
|
|
|
|
procedure TcxGridChartAreaDiagram.DoCustomDrawValueArea(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxGridChartAreaDiagramValueViewInfo; var ADone: Boolean);
|
|
begin
|
|
if HasCustomDrawValueArea then
|
|
FOnCustomDrawValueArea(Self, ACanvas, AViewInfo, ADone);
|
|
end;
|
|
|
|
function TcxGridChartAreaDiagram.HasCustomDrawValueArea: Boolean;
|
|
begin
|
|
Result := Assigned(FOnCustomDrawValueArea);
|
|
end;
|
|
|
|
procedure TcxGridChartAreaDiagram.Assign(Source: TPersistent);
|
|
begin
|
|
inherited;
|
|
if Source is TcxGridChartAreaDiagram then
|
|
OnCustomDrawValueArea := TcxGridChartAreaDiagram(Source).OnCustomDrawValueArea;
|
|
end;
|
|
|
|
{ TcxGridChartPieDiagramStyles }
|
|
|
|
procedure TcxGridChartPieDiagramStyles.GetDefaultViewParams(Index: Integer;
|
|
AData: TObject; out AParams: TcxViewParams);
|
|
begin
|
|
inherited;
|
|
with AParams, LookAndFeelPainter do
|
|
case Index of
|
|
dsSeriesSiteCaptions:
|
|
begin
|
|
Color := DefaultChartPieDiagramSeriesSiteCaptionColor;
|
|
TextColor := DefaultChartPieDiagramSeriesSiteCaptionTextColor;
|
|
end;
|
|
dsSeriesSites:
|
|
begin
|
|
Color := DefaultContentColor;
|
|
TextColor := DefaultChartPieDiagramSeriesSiteBorderColor;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramStyles.GetVaryColorsByCategory: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramStyles.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxGridChartPieDiagramStyles then
|
|
with TcxGridChartPieDiagramStyles(Source) do
|
|
begin
|
|
Self.SeriesSiteCaptions := SeriesSiteCaptions;
|
|
Self.SeriesSites := SeriesSites;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
{ TcxGridChartPieDiagramValues }
|
|
|
|
constructor TcxGridChartPieDiagramValues.Create(ADiagram: TcxGridChartDiagram);
|
|
begin
|
|
inherited;
|
|
FCaptionItems := [pdvciValue];
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramValues.SetAngleOfFirstSlice(Value: Integer);
|
|
begin
|
|
if Value < 0 then Value := 0;
|
|
if Value > 360 then Value := 360;
|
|
if FAngleOfFirstSlice <> Value then
|
|
begin
|
|
FAngleOfFirstSlice := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramValues.SetCaptionItems(Value: TcxGridChartPieDiagramValueCaptionItems);
|
|
begin
|
|
if FCaptionItems <> Value then
|
|
begin
|
|
FCaptionItems := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramValues.SetCaptionItemSeparator(const Value: string);
|
|
begin
|
|
if FCaptionItemSeparator <> Value then
|
|
begin
|
|
FCaptionItemSeparator := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramValues.SetCaptionPosition(Value: TcxGridChartPieDiagramValueCaptionPosition);
|
|
begin
|
|
if FCaptionPosition <> Value then
|
|
begin
|
|
FCaptionPosition := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramValues.SetPercentageCaptionFormat(const Value: string);
|
|
begin
|
|
if FPercentageCaptionFormat <> Value then
|
|
begin
|
|
FPercentageCaptionFormat := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramValues.GetDefaultCaptionItemSeparator: string;
|
|
begin
|
|
Result := '; ';
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramValues.GetDefaultPercentageCaptionFormat: string;
|
|
begin
|
|
Result := '0%';
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagramValues.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxGridChartPieDiagramValues then
|
|
with TcxGridChartPieDiagramValues(Source) do
|
|
begin
|
|
Self.AngleOfFirstSlice := AngleOfFirstSlice;
|
|
Self.CaptionItems := CaptionItems;
|
|
Self.CaptionItemSeparator := CaptionItemSeparator;
|
|
Self.CaptionPosition := CaptionPosition;
|
|
Self.PercentageCaptionFormat := PercentageCaptionFormat;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramValues.GetCaptionItemSeparator: string;
|
|
begin
|
|
Result := FCaptionItemSeparator;
|
|
if Result = '' then
|
|
Result := GetDefaultCaptionItemSeparator;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramValues.GetCaptionPosition: TcxGridChartPieDiagramValueCaptionPosition;
|
|
begin
|
|
if FCaptionItems = [] then
|
|
Result := pdvcpNone
|
|
else
|
|
Result := FCaptionPosition;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagramValues.GetPercentageCaptionFormat: string;
|
|
begin
|
|
Result := FPercentageCaptionFormat;
|
|
if Result = '' then
|
|
Result := GetDefaultPercentageCaptionFormat;
|
|
end;
|
|
|
|
{ TcxGridChartPieDiagram }
|
|
|
|
constructor TcxGridChartPieDiagram.Create(AGridView: TcxGridChartView);
|
|
begin
|
|
inherited;
|
|
FSeriesCaptions := True;
|
|
end;
|
|
|
|
destructor TcxGridChartPieDiagram.Destroy;
|
|
begin
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagram.GetStyles: TcxGridChartPieDiagramStyles;
|
|
begin
|
|
Result := TcxGridChartPieDiagramStyles(inherited Styles);
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagram.SetSeriesCaptions(Value: Boolean);
|
|
begin
|
|
if FSeriesCaptions <> Value then
|
|
begin
|
|
FSeriesCaptions := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagram.SetSeriesColumnCount(Value: Integer);
|
|
begin
|
|
if Value < 0 then Value := 0;
|
|
if FSeriesColumnCount <> Value then
|
|
begin
|
|
FSeriesColumnCount := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagram.SetSeriesSites(Value: Boolean);
|
|
begin
|
|
if FSeriesSites <> Value then
|
|
begin
|
|
FSeriesSites := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagram.SetStyles(Value: TcxGridChartPieDiagramStyles);
|
|
begin
|
|
inherited Styles := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagram.SetValues(Value: TcxGridChartPieDiagramValues);
|
|
begin
|
|
FValues.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagram.SetOnCustomDrawSeriesSite(Value: TcxGridChartPieDiagramSeriesSiteCustomDrawEvent);
|
|
begin
|
|
if @FOnCustomDrawSeriesSite <> @Value then
|
|
begin
|
|
FOnCustomDrawSeriesSite := Value;
|
|
Changed(dcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagram.SetOnCustomDrawSeriesSiteCaption(Value: TcxGridChartPieDiagramSeriesSiteCaptionCustomDrawEvent);
|
|
begin
|
|
if @FOnCustomDrawSeriesSiteCaption <> @Value then
|
|
begin
|
|
FOnCustomDrawSeriesSiteCaption := Value;
|
|
Changed(dcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagram.CreateSubObjects(AGridView: TcxGridChartView);
|
|
begin
|
|
inherited;
|
|
FValues := GetValuesClass.Create(Self);
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagram.DestroySubObjects;
|
|
begin
|
|
FreeAndNil(FValues);
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagram.GetStylesClass: TcxGridChartDiagramStylesClass;
|
|
begin
|
|
Result := TcxGridChartPieDiagramStyles;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagram.GetValuesClass: TcxGridChartPieDiagramValuesClass;
|
|
begin
|
|
Result := TcxGridChartPieDiagramValues;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagram.GetLegendViewInfoClass: TcxGridChartLegendViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartPieDiagramLegendViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagram.GetViewInfoClass: TcxGridChartDiagramViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartPieDiagramViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagram.GetDisplayText: string;
|
|
begin
|
|
Result := cxGetResourceString(@scxGridChartPieDiagramDisplayText);
|
|
end;
|
|
|
|
function TcxGridChartPieDiagram.GetImageIndex: Integer;
|
|
begin
|
|
Result := 4;
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagram.DoCustomDrawSeriesSite(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxGridChartPieSeriesSiteViewInfo; var ADone: Boolean);
|
|
begin
|
|
if HasCustomDrawSeriesSite then
|
|
FOnCustomDrawSeriesSite(Self, ACanvas, AViewInfo, ADone);
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagram.DoCustomDrawSeriesSiteCaption(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxGridChartPieSeriesSiteCaptionViewInfo; var ADone: Boolean);
|
|
begin
|
|
if HasCustomDrawSeriesSiteCaption then
|
|
FOnCustomDrawSeriesSiteCaption(Self, ACanvas, AViewInfo, ADone);
|
|
end;
|
|
|
|
function TcxGridChartPieDiagram.HasCustomDrawSeriesSite: Boolean;
|
|
begin
|
|
Result := Assigned(FOnCustomDrawSeriesSite);
|
|
end;
|
|
|
|
function TcxGridChartPieDiagram.HasCustomDrawSeriesSiteCaption: Boolean;
|
|
begin
|
|
Result := Assigned(FOnCustomDrawSeriesSiteCaption);
|
|
end;
|
|
|
|
procedure TcxGridChartPieDiagram.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxGridChartPieDiagram then
|
|
with TcxGridChartPieDiagram(Source) do
|
|
begin
|
|
Self.SeriesCaptions := SeriesCaptions;
|
|
Self.SeriesColumnCount := SeriesColumnCount;
|
|
Self.SeriesSites := SeriesSites;
|
|
Self.Values := Values;
|
|
Self.OnCustomDrawSeriesSite := OnCustomDrawSeriesSite;
|
|
Self.OnCustomDrawSeriesSiteCaption := OnCustomDrawSeriesSiteCaption;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagram.GetSeriesColumnCount: Integer;
|
|
begin
|
|
Result := SeriesColumnCount;
|
|
if (Result = 0) or (Result > GridView.VisibleSeriesCount) then
|
|
Result := GridView.VisibleSeriesCount;
|
|
end;
|
|
|
|
function TcxGridChartPieDiagram.GetValueCaption(ASeries: TcxGridChartSeries;
|
|
AValueIndex: Integer): string;
|
|
|
|
function GetItemText(AItem: TcxGridChartPieDiagramValueCaptionItem): string;
|
|
var
|
|
AValue: Variant;
|
|
begin
|
|
case AItem of
|
|
pdvciCategory:
|
|
Result := GridView.Categories.VisibleDisplayTexts[AValueIndex];
|
|
pdvciValue:
|
|
Result := ASeries.VisibleDisplayTexts[AValueIndex];
|
|
pdvciPercentage:
|
|
begin
|
|
if ASeries.SumOfValues = 0 then
|
|
AValue := 100
|
|
else
|
|
AValue := Abs(100 * ASeries.VisibleValues[AValueIndex] / ASeries.SumOfValues);
|
|
Result := FormatFloat(Values.GetPercentageCaptionFormat, AValue);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
var
|
|
ACaptionItem: TcxGridChartPieDiagramValueCaptionItem;
|
|
begin
|
|
Result := '';
|
|
for ACaptionItem := Low(ACaptionItem) to High(ACaptionItem) do
|
|
if ACaptionItem in Values.CaptionItems then
|
|
if Result = '' then
|
|
Result := GetItemText(ACaptionItem)
|
|
else
|
|
Result := Result + Values.GetCaptionItemSeparator + GetItemText(ACaptionItem);
|
|
end;
|
|
|
|
{ TcxGridChartItemDataBinding }
|
|
|
|
constructor TcxGridChartItemDataBinding.Create(AGridView: TcxGridChartView;
|
|
AIsValue: Boolean; ADefaultValueTypeClass: TcxValueTypeClass);
|
|
begin
|
|
inherited Create(nil);
|
|
FGridView := AGridView;
|
|
FIsValue := AIsValue;
|
|
FDefaultValueTypeClass := ADefaultValueTypeClass;
|
|
FDefaultValuesProvider := GetDefaultValuesProviderClass.Create(Self);
|
|
end;
|
|
|
|
destructor TcxGridChartItemDataBinding.Destroy;
|
|
begin
|
|
FDefaultValuesProvider.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetDataController: TcxCustomDataController;
|
|
begin
|
|
Result := FDataField.DataController;
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetDataIndex: Integer;
|
|
begin
|
|
Result := FDataField.Index;
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetDataItem: TObject;
|
|
begin
|
|
Result := FDataField.Item;
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetDefaultProperties: TcxCustomEditProperties;
|
|
begin
|
|
Result := FDefaultRepositoryItem.Properties;
|
|
with Result do
|
|
begin
|
|
LockUpdate(True);
|
|
IDefaultValuesProvider := Self.DefaultValuesProvider;
|
|
LockUpdate(False);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetDefaultValuesProvider: TcxCustomEditDefaultValuesProvider;
|
|
begin
|
|
Result := FDefaultValuesProvider;
|
|
InitDefaultValuesProvider(Result);
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetGroupIndex: Integer;
|
|
begin
|
|
Result := DataController.Groups.ItemGroupIndex[DataIndex];
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetSortIndex: Integer;
|
|
begin
|
|
Result := DataController.GetItemSortingIndex(DataIndex);
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetSortOrder: TcxDataSortOrder;
|
|
begin
|
|
Result := DataController.GetItemSortOrder(DataIndex);
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetSummaryIndex: Integer;
|
|
begin
|
|
Result := FSummaryItem.Index;
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetSummaryKind: TcxSummaryKind;
|
|
begin
|
|
Result := FSummaryItem.Kind;
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetValueType: string;
|
|
begin
|
|
if ValueTypeClass = nil then
|
|
Result := ''
|
|
else
|
|
Result := ValueTypeClass.Caption;
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetValueTypeClass: TcxValueTypeClass;
|
|
begin
|
|
Result := DataController.GetItemValueTypeClass(DataIndex);
|
|
end;
|
|
|
|
procedure TcxGridChartItemDataBinding.SetData(Value: TObject);
|
|
begin
|
|
if FData <> Value then
|
|
begin
|
|
FData := Value;
|
|
FGridView.Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartItemDataBinding.SetDataField(Value: TcxCustomDataField);
|
|
begin
|
|
if FDataField <> Value then
|
|
begin
|
|
FDataField := Value;
|
|
if FDataField <> nil then
|
|
begin
|
|
ValueTypeClass := GetDefaultValueTypeClass;
|
|
if IsValue then
|
|
CreateSummaryItem(FSummaryItem);
|
|
end
|
|
else
|
|
FreeAndNil(FSummaryItem);
|
|
UpdateDefaultRepositoryItemValue;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartItemDataBinding.SetGroupIndex(Value: Integer);
|
|
begin
|
|
DataController.Groups.ChangeGrouping(DataIndex, Value);
|
|
end;
|
|
|
|
procedure TcxGridChartItemDataBinding.SetSortIndex(Value: Integer);
|
|
begin
|
|
DataController.ChangeItemSortingIndex(DataIndex, Value);
|
|
end;
|
|
|
|
procedure TcxGridChartItemDataBinding.SetSortOrder(Value: TcxDataSortOrder);
|
|
begin
|
|
if SortOrder <> Value then
|
|
begin
|
|
GridView.BeginUpdate;
|
|
try
|
|
GridView.DataSortingChanging(DataItem);
|
|
DataController.ChangeSorting(DataIndex, Value);
|
|
GridView.DataSortingChanged(DataItem);
|
|
finally
|
|
GridView.EndUpdate;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartItemDataBinding.SetSummaryKind(Value: TcxSummaryKind);
|
|
begin
|
|
FSummaryItem.Kind := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartItemDataBinding.SetValueType(const Value: string);
|
|
begin
|
|
if ValueType <> Value then
|
|
ValueTypeClass := cxValueTypeClassList.ItemByCaption(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartItemDataBinding.SetValueTypeClass(Value: TcxValueTypeClass);
|
|
begin
|
|
DataController.ChangeValueTypeClass(DataIndex, Value);
|
|
end;
|
|
|
|
procedure TcxGridChartItemDataBinding.ItemRemoved(Sender: TcxEditRepositoryItem);
|
|
begin
|
|
UpdateDefaultRepositoryItemValue;
|
|
end;
|
|
|
|
procedure TcxGridChartItemDataBinding.PropertiesChanged(Sender: TcxEditRepositoryItem);
|
|
begin
|
|
if not GridView.IsPattern then GridView.Changed(vcLayout);
|
|
end;
|
|
|
|
procedure TcxGridChartItemDataBinding.CreateSummaryItem(var ASummaryItem: TcxDataSummaryItem);
|
|
begin
|
|
DataController.Summary.DefaultGroupSummaryItems.BeginUpdate;
|
|
try
|
|
ASummaryItem := DataController.Summary.DefaultGroupSummaryItems.Add;
|
|
ASummaryItem.Kind := cxGridChartItemDefaultSummaryKind;
|
|
ASummaryItem.Position := spGroup;
|
|
ASummaryItem.ItemLink := DataItem;
|
|
finally
|
|
DataController.Summary.DefaultGroupSummaryItems.EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetDefaultDisplayText: string;
|
|
begin
|
|
Result := '';
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetDefaultValuesProviderClass: TcxCustomEditDefaultValuesProviderClass;
|
|
begin
|
|
Result := TcxCustomEditDefaultValuesProvider;
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetDefaultValueTypeClass: TcxValueTypeClass;
|
|
begin
|
|
Result := FDefaultValueTypeClass;
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetSummaryItem: TcxDataSummaryItem;
|
|
begin
|
|
Result := DataController.Summary.DefaultGroupSummaryItems.ItemOfItemLink(DataItem);
|
|
end;
|
|
|
|
procedure TcxGridChartItemDataBinding.InitDefaultValuesProvider(ADefaultValuesProvider: TcxCustomEditDefaultValuesProvider);
|
|
begin
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.IsValueTypeInteger: Boolean;
|
|
begin
|
|
Result := (ValueTypeClass = nil) or IsValueTypeValid(ValueTypeClass.GetVarType, True);
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.IsValueTypeStored: Boolean;
|
|
begin
|
|
Result := ValueTypeClass <> GetDefaultValueTypeClass;
|
|
end;
|
|
|
|
procedure TcxGridChartItemDataBinding.UpdateSummaryItemValue;
|
|
begin
|
|
if IsValue then
|
|
FSummaryItem := GetSummaryItem;
|
|
end;
|
|
|
|
procedure TcxGridChartItemDataBinding.ValueTypeClassChanged;
|
|
begin
|
|
UpdateDefaultRepositoryItemValue;
|
|
GridView.Changed(vcLayout);
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetDefaultRepositoryItem: TcxEditRepositoryItem;
|
|
begin
|
|
Result := GetDefaultEditDataRepositoryItems.GetItem(ValueTypeClass);
|
|
end;
|
|
|
|
procedure TcxGridChartItemDataBinding.UpdateDefaultRepositoryItemValue;
|
|
begin
|
|
if FDefaultRepositoryItem <> nil then
|
|
FDefaultRepositoryItem.RemoveListener(Self);
|
|
if FDataField = nil then
|
|
FDefaultRepositoryItem := nil
|
|
else
|
|
FDefaultRepositoryItem := GetDefaultRepositoryItem;
|
|
if FDefaultRepositoryItem <> nil then
|
|
FDefaultRepositoryItem.AddListener(Self);
|
|
end;
|
|
|
|
procedure TcxGridChartItemDataBinding.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxGridChartItemDataBinding then
|
|
with TcxGridChartItemDataBinding(Source) do
|
|
begin
|
|
Self.Data := Data;
|
|
Self.ValueTypeClass := ValueTypeClass;
|
|
end
|
|
else
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.GetValueDisplayText(const AValue: Variant): string;
|
|
begin
|
|
Result := DefaultProperties.GetDisplayText(AValue);
|
|
end;
|
|
|
|
function TcxGridChartItemDataBinding.IsValueTypeClassValid(AValueTypeClass: TcxValueTypeClass): Boolean;
|
|
begin
|
|
if IsValue then
|
|
Result := cxGridChartView.IsValueTypeClassValid(AValueTypeClass)
|
|
else
|
|
Result := True;
|
|
end;
|
|
|
|
{ TcxGridChartItem }
|
|
|
|
constructor TcxGridChartItem.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FVisible := True;
|
|
FVisibleForCustomization := True;
|
|
FVisibleIndex := -1;
|
|
end;
|
|
|
|
destructor TcxGridChartItem.Destroy;
|
|
begin
|
|
if not GridView.IsDestroying and GridView.IsDesigning then
|
|
GridView.Controller.DesignController.UnselectObject(Self);
|
|
FGridView.RemoveItem(Self);
|
|
FDataBinding.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartItem.GetID: Integer;
|
|
begin
|
|
Result := FDataBinding.ID;
|
|
end;
|
|
|
|
function TcxGridChartItem.GetIndex: Integer;
|
|
begin
|
|
Result := FGridView.GetItemIndex(Self);
|
|
end;
|
|
|
|
function TcxGridChartItem.GetSortOrder: TcxDataSortOrder;
|
|
begin
|
|
Result := FDataBinding.SortOrder;
|
|
end;
|
|
|
|
function TcxGridChartItem.GetTag: TcxTag;
|
|
begin
|
|
Result := inherited Tag;
|
|
end;
|
|
|
|
function TcxGridChartItem.GetVisibleDisplayText(AIndex: Integer): string;
|
|
begin
|
|
Result := GetValueDisplayText(VisibleValues[AIndex]);
|
|
end;
|
|
|
|
procedure TcxGridChartItem.SetDataBinding(Value: TcxGridChartItemDataBinding);
|
|
begin
|
|
FDataBinding.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartItem.SetDisplayText(const Value: string);
|
|
begin
|
|
if FDisplayText <> Value then
|
|
begin
|
|
FDisplayText := Value;
|
|
DisplayTextChanged;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartItem.SetIndex(Value: Integer);
|
|
begin
|
|
FGridView.SetItemIndex(Self, Value);
|
|
end;
|
|
|
|
procedure TcxGridChartItem.SetOnGetStoredProperties(Value: TcxGridChartItemGetStoredPropertiesEvent);
|
|
begin
|
|
if @FOnGetStoredProperties <> @Value then
|
|
begin
|
|
FOnGetStoredProperties := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartItem.SetOnGetStoredPropertyValue(Value: TcxGridChartItemGetStoredPropertyValueEvent);
|
|
begin
|
|
if @FOnGetStoredPropertyValue <> @Value then
|
|
begin
|
|
FOnGetStoredPropertyValue := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartItem.SetOnGetValueDisplayText(Value: TcxGridChartGetValueDisplayTextEvent);
|
|
begin
|
|
if @FOnGetValueDisplayText <> @Value then
|
|
begin
|
|
FOnGetValueDisplayText := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartItem.SetOnSetStoredPropertyValue(Value: TcxGridChartItemSetStoredPropertyValueEvent);
|
|
begin
|
|
if @FOnSetStoredPropertyValue <> @Value then
|
|
begin
|
|
FOnSetStoredPropertyValue := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartItem.SetSortOrder(Value: TcxDataSortOrder);
|
|
begin
|
|
FDataBinding.SortOrder := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartItem.SetTag(Value: TcxTag);
|
|
begin
|
|
if Tag <> Value then
|
|
begin
|
|
inherited Tag := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartItem.SetVisible(Value: Boolean);
|
|
begin
|
|
if FVisible <> Value then
|
|
begin
|
|
FVisible := Value;
|
|
FGridView.ItemVisibilityChanged(Self);
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartItem.SetVisibleForCustomization(Value: Boolean);
|
|
begin
|
|
if FVisibleForCustomization <> Value then
|
|
begin
|
|
FVisibleForCustomization := Value;
|
|
GridView.ItemVisibilityForCustomizationChanged(Self);
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartItem.IsTagStored: Boolean;
|
|
begin
|
|
Result := Tag <> 0;
|
|
end;
|
|
|
|
function TcxGridChartItem.GetObjectName: string;
|
|
begin
|
|
if GridView.IsStoringNameMode then
|
|
Result := IntToStr(ID)
|
|
else
|
|
Result := Name;
|
|
end;
|
|
|
|
function TcxGridChartItem.GetStoredProperties(AProperties: TStrings): Boolean;
|
|
begin
|
|
AProperties.Add('Index');
|
|
AProperties.Add('Visible');
|
|
if Assigned(FOnGetStoredProperties) then
|
|
FOnGetStoredProperties(Self, AProperties);
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TcxGridChartItem.GetPropertyValue(const AName: string; var AValue: Variant);
|
|
begin
|
|
if AName = 'Index' then
|
|
AValue := Index
|
|
else
|
|
if AName = 'Visible' then
|
|
AValue := Visible
|
|
else
|
|
if Assigned(FOnGetStoredPropertyValue) then
|
|
FOnGetStoredPropertyValue(Self, AName, AValue);
|
|
end;
|
|
|
|
procedure TcxGridChartItem.SetPropertyValue(const AName: string; const AValue: Variant);
|
|
begin
|
|
if AName = 'Index' then
|
|
SetRestoredIndex(AValue)
|
|
else
|
|
if AName = 'Visible' then
|
|
Visible := AValue
|
|
else
|
|
if Assigned(FOnSetStoredPropertyValue) then
|
|
FOnSetStoredPropertyValue(Self, AName, AValue);
|
|
end;
|
|
|
|
procedure TcxGridChartItem.DataChanged;
|
|
begin
|
|
if DataBinding.GetDefaultDisplayText <> FLastDataBindingDefaultDisplayText then
|
|
begin
|
|
FLastDataBindingDefaultDisplayText := DataBinding.GetDefaultDisplayText;
|
|
DisplayTextChanged;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartItem.GetDataBinding: TcxGridChartItemDataBinding;
|
|
begin
|
|
Result := FDataBinding;
|
|
end;
|
|
|
|
procedure TcxGridChartItem.ValueTypeClassChanged;
|
|
begin
|
|
FDataBinding.ValueTypeClassChanged;
|
|
end;
|
|
|
|
procedure TcxGridChartItem.Changed(AChange: TcxGridViewChangeKind = vcLayout);
|
|
begin
|
|
FGridView.Changed(AChange);
|
|
end;
|
|
|
|
procedure TcxGridChartItem.DisplayTextChanged;
|
|
begin
|
|
Changed;
|
|
GridView.ItemDisplayTextChanged(Self);
|
|
end;
|
|
|
|
procedure TcxGridChartItem.DoGetValueDisplayText(const AValue: Variant;
|
|
var ADisplayText: string);
|
|
begin
|
|
if Assigned(FOnGetValueDisplayText) then
|
|
FOnGetValueDisplayText(Self, AValue, ADisplayText);
|
|
end;
|
|
|
|
function TcxGridChartItem.GetDefaultDisplayText: string;
|
|
begin
|
|
Result := DataBinding.GetDefaultDisplayText;
|
|
if Result = '' then
|
|
Result := Name;
|
|
if Result = '' then
|
|
Result := DefaultItemDisplayText;
|
|
end;
|
|
|
|
procedure TcxGridChartItem.SetGridView(Value: TcxGridChartView);
|
|
begin
|
|
FGridView := Value;
|
|
if FDataBinding = nil then
|
|
FDataBinding := GridView.GetItemDataBindingClass.Create(GridView, IsValue,
|
|
GetDefaultValueTypeClass);
|
|
end;
|
|
|
|
procedure TcxGridChartItem.SetName(const NewName: TComponentName);
|
|
begin
|
|
inherited;
|
|
DisplayTextChanged;
|
|
end;
|
|
|
|
procedure TcxGridChartItem.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxGridChartItem then
|
|
with TcxGridChartItem(Source) do
|
|
begin
|
|
Self.DataBinding := DataBinding;
|
|
Self.DisplayText := DisplayText;
|
|
Self.SortOrder := SortOrder;
|
|
Self.Tag := Tag;
|
|
Self.Visible := Visible;
|
|
Self.VisibleForCustomization := VisibleForCustomization;
|
|
Self.OnGetStoredProperties := OnGetStoredProperties;
|
|
Self.OnGetStoredPropertyValue := OnGetStoredPropertyValue;
|
|
Self.OnGetValueDisplayText := OnGetValueDisplayText;
|
|
Self.OnSetStoredPropertyValue := OnSetStoredPropertyValue;
|
|
end
|
|
else
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartItem.GetParentComponent: TComponent;
|
|
begin
|
|
Result := FGridView;
|
|
end;
|
|
|
|
function TcxGridChartItem.HasParent: Boolean;
|
|
begin
|
|
Result := FGridView <> nil;
|
|
end;
|
|
|
|
procedure TcxGridChartItem.SetParentComponent(AParent: TComponent);
|
|
begin
|
|
if AParent is TcxGridChartView then
|
|
TcxGridChartView(AParent).AddItem(Self);
|
|
end;
|
|
|
|
function TcxGridChartItem.GetDisplayText: string;
|
|
begin
|
|
Result := DisplayText;
|
|
if Result = '' then
|
|
Result := GetDefaultDisplayText;
|
|
end;
|
|
|
|
function TcxGridChartItem.GetValueDisplayText(const AValue: Variant): string;
|
|
begin
|
|
Result := DataBinding.GetValueDisplayText(AValue);
|
|
DoGetValueDisplayText(AValue, Result);
|
|
end;
|
|
|
|
class function TcxGridChartItem.IsValue: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
{ TcxGridChartCategories }
|
|
|
|
constructor TcxGridChartCategories.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited;
|
|
FDataBinding := GridView.GetItemDataBindingClass.Create(GridView, False,
|
|
GetDefaultValueTypeClass);
|
|
end;
|
|
|
|
destructor TcxGridChartCategories.Destroy;
|
|
begin
|
|
FDataBinding.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartCategories.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
function TcxGridChartCategories.GetID: Integer;
|
|
begin
|
|
Result := FDataBinding.ID;
|
|
end;
|
|
|
|
function TcxGridChartCategories.GetSortOrder: TcxDataSortOrder;
|
|
begin
|
|
Result := FDataBinding.SortOrder;
|
|
end;
|
|
|
|
function TcxGridChartCategories.GetValue(Index: Integer): Variant;
|
|
begin
|
|
Result := GridView.ViewData.Categories[Index];
|
|
end;
|
|
|
|
function TcxGridChartCategories.GetValueCount: Integer;
|
|
begin
|
|
Result := GridView.ViewData.CategoryCount;
|
|
end;
|
|
|
|
function TcxGridChartCategories.GetVisibleDisplayText(Index: Integer): string;
|
|
begin
|
|
Result := GetValueDisplayText(VisibleValues[Index]);
|
|
end;
|
|
|
|
function TcxGridChartCategories.GetVisibleValue(Index: Integer): Variant;
|
|
begin
|
|
Result := GridView.ViewData.VisibleCategories[Index];
|
|
end;
|
|
|
|
function TcxGridChartCategories.GetVisibleValueCount: Integer;
|
|
begin
|
|
Result := GridView.ViewData.VisibleCategoryCount;
|
|
end;
|
|
|
|
procedure TcxGridChartCategories.SetDataBinding(Value: TcxGridChartItemDataBinding);
|
|
begin
|
|
FDataBinding.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartCategories.SetDisplayText(const Value: string);
|
|
begin
|
|
if FDisplayText <> Value then
|
|
begin
|
|
FDisplayText := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartCategories.SetOnGetValueDisplayText(Value: TcxGridChartGetValueDisplayTextEvent);
|
|
begin
|
|
if @FOnGetValueDisplayText <> @Value then
|
|
begin
|
|
FOnGetValueDisplayText := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartCategories.SetSortOrder(Value: TcxDataSortOrder);
|
|
begin
|
|
FDataBinding.SortOrder := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartCategories.SetValue(Index: Integer; const Value: Variant);
|
|
begin
|
|
GridView.ViewData.Categories[Index] := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartCategories.SetValueCount(Value: Integer);
|
|
begin
|
|
GridView.ViewData.CategoryCount := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartCategories.DataChanged;
|
|
begin
|
|
end;
|
|
|
|
function TcxGridChartCategories.GetDataBinding: TcxGridChartItemDataBinding;
|
|
begin
|
|
Result := FDataBinding;
|
|
end;
|
|
|
|
procedure TcxGridChartCategories.ValueTypeClassChanged;
|
|
begin
|
|
FDataBinding.ValueTypeClassChanged;
|
|
end;
|
|
|
|
procedure TcxGridChartCategories.DoGetValueDisplayText(const AValue: Variant;
|
|
var ADisplayText: string);
|
|
begin
|
|
if Assigned(FOnGetValueDisplayText) then
|
|
FOnGetValueDisplayText(Self, AValue, ADisplayText);
|
|
end;
|
|
|
|
function TcxGridChartCategories.GetDefaultDisplayText: string;
|
|
begin
|
|
Result := cxGetResourceString(@scxGridChartCategoriesDisplayText);
|
|
end;
|
|
|
|
function TcxGridChartCategories.GetDefaultValueTypeClass: TcxValueTypeClass;
|
|
begin
|
|
Result := TcxStringValueType;
|
|
end;
|
|
|
|
procedure TcxGridChartCategories.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxGridChartCategories then
|
|
with TcxGridChartCategories(Source) do
|
|
begin
|
|
Self.DataBinding := DataBinding;
|
|
Self.DisplayText := DisplayText;
|
|
Self.SortOrder := SortOrder;
|
|
Self.OnGetValueDisplayText := OnGetValueDisplayText;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartCategories.GetDisplayText: string;
|
|
begin
|
|
Result := FDisplayText;
|
|
if Result = '' then
|
|
Result := GetDefaultDisplayText;
|
|
end;
|
|
|
|
function TcxGridChartCategories.GetNamePath: string;
|
|
begin
|
|
Result := GridView.GetCategoriesNamePath;
|
|
end;
|
|
|
|
function TcxGridChartCategories.GetValueDisplayText(const AValue: Variant): string;
|
|
begin
|
|
if GridView.ActiveDataGroup = nil then
|
|
Result := DataBinding.GetValueDisplayText(AValue)
|
|
else
|
|
Result := GridView.ActiveDataGroup.GetValueDisplayText(AValue);
|
|
DoGetValueDisplayText(AValue, Result);
|
|
end;
|
|
|
|
{ TcxGridChartDataGroup }
|
|
|
|
function TcxGridChartDataGroup.GetActive: Boolean;
|
|
begin
|
|
Result := GridView.ActiveDataGroup = Self;
|
|
end;
|
|
|
|
function TcxGridChartDataGroup.GetActiveValueDisplayText: string;
|
|
begin
|
|
Result := GetValueDisplayText(FActiveValue);
|
|
end;
|
|
|
|
function TcxGridChartDataGroup.GetDataLevel: Integer;
|
|
begin
|
|
Result := GridView.GetDataObjectLevel(Self);
|
|
end;
|
|
|
|
function TcxGridChartDataGroup.GetGroupIndex: Integer;
|
|
begin
|
|
Result := DataBinding.GroupIndex;
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroup.SetActive(Value: Boolean);
|
|
begin
|
|
GridView.ActiveDataGroup := Self;
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroup.SetActiveValue(const Value: Variant);
|
|
begin
|
|
if not VarSameValue(FActiveValue, Value) then
|
|
begin
|
|
FActiveValue := Value;
|
|
GridView.ViewData.DataLevelsChanged;
|
|
GridView.UpdateDataGroupActiveValues;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroup.SetDataLevel(Value: Integer);
|
|
begin
|
|
GridView.SetDataObjectLevel(Self, Value);
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroup.SetGroupIndex(Value: Integer);
|
|
begin
|
|
DataBinding.GroupIndex := Value;
|
|
end;
|
|
|
|
function TcxGridChartDataGroup.GetStoredProperties(AProperties: TStrings): Boolean;
|
|
begin
|
|
AProperties.Add('ActiveValue');
|
|
Result := inherited GetStoredProperties(AProperties);
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroup.GetPropertyValue(const AName: string; var AValue: Variant);
|
|
begin
|
|
if AName = 'ActiveValue' then
|
|
AValue := ActiveValue
|
|
else
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroup.SetPropertyValue(const AName: string; const AValue: Variant);
|
|
begin
|
|
if AName = 'ActiveValue' then
|
|
ActiveValue := AValue
|
|
else
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroup.SetRestoredIndex(AValue: Integer);
|
|
begin
|
|
GridView.RestoringDataGroups[AValue] := Self;
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroup.CheckActiveValue;
|
|
begin
|
|
if HasActiveValue then
|
|
if Visible then
|
|
GridView.ViewData.CheckValueAtLevel(VisibleIndex, FActiveValue)
|
|
else
|
|
FActiveValue := Null;
|
|
end;
|
|
|
|
function TcxGridChartDataGroup.GetDefaultValueTypeClass: TcxValueTypeClass;
|
|
begin
|
|
Result := TcxVariantValueType;
|
|
end;
|
|
|
|
function TcxGridChartDataGroup.GetValue(AIndex: Integer): Variant;
|
|
begin
|
|
Result := GridView.ViewData.GroupValues[Index, AIndex];
|
|
end;
|
|
|
|
function TcxGridChartDataGroup.GetValueCount: Integer;
|
|
begin
|
|
Result := GridView.ViewData.CategoryCount;
|
|
end;
|
|
|
|
function TcxGridChartDataGroup.GetVisibleValue(AIndex: Integer): Variant;
|
|
begin
|
|
Result := GridView.ViewData.VisibleGroupValues[VisibleIndex, AIndex];
|
|
end;
|
|
|
|
function TcxGridChartDataGroup.GetVisibleValueCount: Integer;
|
|
begin
|
|
Result := GridView.ViewData.VisibleGroupValueCount[VisibleIndex];
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroup.SetValue(AIndex: Integer; const Value: Variant);
|
|
begin
|
|
GridView.ViewData.GroupValues[Index, AIndex] := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartDataGroup.SetValueCount(Value: Integer);
|
|
begin
|
|
GridView.ViewData.CategoryCount := Value;
|
|
end;
|
|
|
|
function TcxGridChartDataGroup.CanMove: Boolean;
|
|
begin
|
|
Result := IsDesigning or GridView.OptionsCustomize.DataGroupMoving;
|
|
end;
|
|
|
|
function TcxGridChartDataGroup.HasActiveValue: Boolean;
|
|
begin
|
|
Result := not VarIsEmpty(FActiveValue) and not VarIsNull(FActiveValue);
|
|
end;
|
|
|
|
class function TcxGridChartDataGroup.IsValue: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
{ TcxGridChartSeriesStyles }
|
|
|
|
constructor TcxGridChartSeriesStyles.Create(AOwner: TPersistent);
|
|
begin
|
|
inherited;
|
|
BitmapInViewParams := True;
|
|
end;
|
|
|
|
function TcxGridChartSeriesStyles.GetSeries: TcxGridChartSeries;
|
|
begin
|
|
Result := TcxGridChartSeries(Owner);
|
|
end;
|
|
|
|
procedure TcxGridChartSeriesStyles.SetOnGetValueStyle(Value: TcxGridChartSeriesGetValueStyleEvent);
|
|
begin
|
|
if @FOnGetValueStyle <> @Value then
|
|
begin
|
|
FOnGetValueStyle := Value;
|
|
Series.Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartSeriesStyles.GetDefaultViewParams(Index: Integer;
|
|
AData: TObject; out AParams: TcxViewParams);
|
|
begin
|
|
inherited;
|
|
if Index = ssValues then
|
|
begin
|
|
if Integer(AData) = -1 then
|
|
AParams.Color := GetDefaultValueColor(Series.Order)
|
|
else
|
|
AParams.Color := GetDefaultValueColor(Integer(AData));
|
|
AParams.TextColor := LookAndFeelPainter.DefaultChartDiagramValueBorderColor;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartSeriesStyles.GetGridView: TcxCustomGridView;
|
|
begin
|
|
Result := Series.GridView;
|
|
end;
|
|
|
|
procedure TcxGridChartSeriesStyles.Assign(Source: TPersistent);
|
|
begin
|
|
inherited;
|
|
if Source is TcxGridChartSeriesStyles then
|
|
with TcxGridChartSeriesStyles(Source) do
|
|
begin
|
|
Self.Values := Values;
|
|
Self.OnGetValueStyle := OnGetValueStyle;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartSeriesStyles.GetValueParams(AValueIndex: Integer;
|
|
AVaryColorsByCategory: Boolean; out AParams: TcxViewParams);
|
|
var
|
|
AStyle: TcxStyle;
|
|
begin
|
|
AStyle := nil;
|
|
if (AValueIndex <> -1) and Assigned(FOnGetValueStyle) then
|
|
FOnGetValueStyle(Series, AValueIndex, AStyle);
|
|
if not AVaryColorsByCategory then AValueIndex := -1;
|
|
GetViewParams(ssValues, TObject(AValueIndex), AStyle, AParams);
|
|
end;
|
|
|
|
{ TcxGridChartSeries }
|
|
|
|
constructor TcxGridChartSeries.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FStyles := GetStylesClass.Create(Self);
|
|
end;
|
|
|
|
destructor TcxGridChartSeries.Destroy;
|
|
begin
|
|
FStyles.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartSeries.GetGroupSummaryKind: TcxSummaryKind;
|
|
begin
|
|
Result := DataBinding.SummaryKind;
|
|
end;
|
|
|
|
function TcxGridChartSeries.GetSumOfValues: Variant;
|
|
begin
|
|
Result := GridView.ViewData.SumOfValues[Index];
|
|
end;
|
|
|
|
procedure TcxGridChartSeries.SetGroupSummaryKind(Value: TcxSummaryKind);
|
|
begin
|
|
if IsGroupSummaryKindValid(Value) then
|
|
DataBinding.SummaryKind := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartSeries.SetStyles(Value: TcxGridChartSeriesStyles);
|
|
begin
|
|
FStyles.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartSeries.SetValueCaptionFormat(const Value: string);
|
|
begin
|
|
if FValueCaptionFormat <> Value then
|
|
begin
|
|
FValueCaptionFormat := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartSeries.SetOnCustomDrawValue(Value: TcxGridChartSeriesValueCustomDrawEvent);
|
|
begin
|
|
if @FOnCustomDrawValue <> @Value then
|
|
begin
|
|
FOnCustomDrawValue := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartSeries.SetOnValueClick(Value: TcxGridChartValueClickEvent);
|
|
begin
|
|
if @FOnValueClick <> @Value then
|
|
begin
|
|
FOnValueClick := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartSeries.GetStoredProperties(AProperties: TStrings): Boolean;
|
|
begin
|
|
AProperties.Add('SortOrder');
|
|
Result := inherited GetStoredProperties(AProperties);
|
|
end;
|
|
|
|
procedure TcxGridChartSeries.GetPropertyValue(const AName: string; var AValue: Variant);
|
|
begin
|
|
if AName = 'SortOrder' then
|
|
AValue := Variant(SortOrder)
|
|
else
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartSeries.SetPropertyValue(const AName: string; const AValue: Variant);
|
|
begin
|
|
if AName = 'SortOrder' then
|
|
SortOrder := TcxDataSortOrder((AValue))
|
|
else
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartSeries.SetRestoredIndex(AValue: Integer);
|
|
begin
|
|
GridView.RestoringSeries[AValue] := Self;
|
|
end;
|
|
|
|
procedure TcxGridChartSeries.DoGetValueDisplayText(const AValue: Variant;
|
|
var ADisplayText: string);
|
|
begin
|
|
if (ValueCaptionFormat <> '') and not VarIsNull(AValue) then
|
|
ADisplayText := FormatFloat(ValueCaptionFormat, AValue);
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartSeries.GetDefaultValueTypeClass: TcxValueTypeClass;
|
|
begin
|
|
Result := TcxFloatValueType;
|
|
end;
|
|
|
|
function TcxGridChartSeries.GetStylesClass: TcxGridChartSeriesStylesClass;
|
|
begin
|
|
Result := TcxGridChartSeriesStyles;
|
|
end;
|
|
|
|
function TcxGridChartSeries.IsGroupSummaryKindValid(AValue: TcxSummaryKind): Boolean;
|
|
begin
|
|
Result := AValue <> skNone;
|
|
end;
|
|
|
|
function TcxGridChartSeries.GetValue(AIndex: Integer): Variant;
|
|
begin
|
|
Result := GridView.ViewData.Values[Index, AIndex];
|
|
end;
|
|
|
|
function TcxGridChartSeries.GetValueCount: Integer;
|
|
begin
|
|
Result := GridView.ViewData.CategoryCount;
|
|
end;
|
|
|
|
function TcxGridChartSeries.GetVisibleValue(AIndex: Integer): Variant;
|
|
begin
|
|
Result := GridView.ViewData.VisibleValues[Index, AIndex];
|
|
end;
|
|
|
|
function TcxGridChartSeries.GetVisibleValueCount: Integer;
|
|
begin
|
|
Result := GridView.ViewData.VisibleCategoryCount;
|
|
end;
|
|
|
|
procedure TcxGridChartSeries.SetValue(AIndex: Integer; const Value: Variant);
|
|
begin
|
|
GridView.ViewData.Values[Index, AIndex] := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartSeries.SetValueCount(Value: Integer);
|
|
begin
|
|
GridView.ViewData.CategoryCount := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartSeries.DoCustomDrawValue(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxGridChartDiagramValueViewInfo; var ADone: Boolean);
|
|
begin
|
|
if HasCustomDrawValue then
|
|
FOnCustomDrawValue(Self, ACanvas, AViewInfo, ADone);
|
|
end;
|
|
|
|
function TcxGridChartSeries.DoValueClick(AValueIndex: Integer): Boolean;
|
|
begin
|
|
Result := False;
|
|
if Assigned(FOnValueClick) then
|
|
FOnValueClick(GridView, Self, AValueIndex, Result);
|
|
if not Result then
|
|
Result := GridView.DoValueClick(Self, AValueIndex);
|
|
end;
|
|
|
|
function TcxGridChartSeries.HasCustomDrawValue: Boolean;
|
|
begin
|
|
Result := Assigned(FOnCustomDrawValue);
|
|
end;
|
|
|
|
procedure TcxGridChartSeries.Assign(Source: TPersistent);
|
|
begin
|
|
inherited;
|
|
if Source is TcxGridChartSeries then
|
|
with TcxGridChartSeries(Source) do
|
|
begin
|
|
Self.GroupSummaryKind := GroupSummaryKind;
|
|
Self.Styles := Styles;
|
|
Self.ValueCaptionFormat := ValueCaptionFormat;
|
|
Self.OnCustomDrawValue := OnCustomDrawValue;
|
|
Self.OnValueClick := OnValueClick;
|
|
end
|
|
end;
|
|
|
|
function TcxGridChartSeries.AddValue(const AValue: Variant): Integer;
|
|
begin
|
|
ValueCount := ValueCount + 1;
|
|
Result := ValueCount - 1;
|
|
Values[Result] := AValue;
|
|
end;
|
|
|
|
class function TcxGridChartSeries.IsValue: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
{ TcxGridChartTitle }
|
|
|
|
function TcxGridChartTitle.GetDefaultPosition: TcxGridChartPartPosition;
|
|
begin
|
|
Result := cppTop;
|
|
end;
|
|
|
|
{ TcxGridChartToolBox }
|
|
|
|
constructor TcxGridChartToolBox.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited;
|
|
FBorder := tbSingle;
|
|
FDataLevelActiveValueDropDownCount := cxGridChartDefaultDataLevelActiveValueDropDownCount;
|
|
FDataLevelsInfoVisible := dlivNonEmpty;
|
|
FVisible := tvNonEmpty;
|
|
end;
|
|
|
|
function TcxGridChartToolBox.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
procedure TcxGridChartToolBox.SetBorder(Value: TcxGridChartToolBoxBorder);
|
|
begin
|
|
if FBorder <> Value then
|
|
begin
|
|
FBorder := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBox.SetCustomizeButton(Value: Boolean);
|
|
begin
|
|
if FCustomizeButton <> Value then
|
|
begin
|
|
FCustomizeButton := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBox.SetDataLevelActiveValueDropDownCount(Value: Integer);
|
|
begin
|
|
if Value < 0 then Value := 0;
|
|
if FDataLevelActiveValueDropDownCount <> Value then
|
|
begin
|
|
FDataLevelActiveValueDropDownCount := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBox.SetDataLevelActiveValueDropDownWidth(Value: Integer);
|
|
begin
|
|
if Value < 0 then Value := 0;
|
|
if FDataLevelActiveValueDropDownWidth <> Value then
|
|
begin
|
|
FDataLevelActiveValueDropDownWidth := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBox.SetDataLevelsInfoVisible(Value: TcxGridChartDataLevelsInfoVisible);
|
|
begin
|
|
if FDataLevelsInfoVisible <> Value then
|
|
begin
|
|
FDataLevelsInfoVisible := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBox.SetDiagramSelector(Value: Boolean);
|
|
begin
|
|
if FDiagramSelector <> Value then
|
|
begin
|
|
FDiagramSelector := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBox.SetPosition(Value: TcxGridChartToolBoxPosition);
|
|
begin
|
|
if FPosition <> Value then
|
|
begin
|
|
FPosition := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBox.SetVisible(Value: TcxGridChartToolBoxVisible);
|
|
begin
|
|
if FVisible <> Value then
|
|
begin
|
|
FVisible := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBox.GetStoredProperties(AProperties: TStrings);
|
|
begin
|
|
AProperties.Add('ToolBox.Border');
|
|
AProperties.Add('ToolBox.DiagramSelector');
|
|
AProperties.Add('ToolBox.Position');
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBox.GetStoredPropertyValue(const AName: string;
|
|
var AValue: Variant);
|
|
begin
|
|
if AName = 'ToolBox.Border' then
|
|
AValue := Variant(Border)
|
|
else
|
|
if AName = 'ToolBox.DiagramSelector' then
|
|
AValue := DiagramSelector
|
|
else
|
|
if AName = 'ToolBox.Position' then
|
|
AValue := Variant(Position);
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBox.SetStoredPropertyValue(const AName: string;
|
|
const AValue: Variant);
|
|
begin
|
|
if AName = 'ToolBox.Border' then
|
|
Border := TcxGridChartToolBoxBorder((AValue))
|
|
else
|
|
if AName = 'ToolBox.DiagramSelector' then
|
|
DiagramSelector := AValue
|
|
else
|
|
if AName = 'ToolBox.Position' then
|
|
Position := TcxGridChartToolBoxPosition((AValue));
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartToolBox.IsDataLevelsInfoNonEmpty: Boolean;
|
|
begin
|
|
Result := GridView.IsDataGrouped;
|
|
end;
|
|
|
|
function TcxGridChartToolBox.IsNonEmpty: Boolean;
|
|
begin
|
|
Result := GetDataLevelsInfoVisible or CustomizeButton or DiagramSelector;
|
|
end;
|
|
|
|
procedure TcxGridChartToolBox.Assign(Source: TPersistent);
|
|
begin
|
|
inherited;
|
|
if Source is TcxGridChartToolBox then
|
|
with TcxGridChartToolBox(Source) do
|
|
begin
|
|
Self.Border := Border;
|
|
Self.CustomizeButton := CustomizeButton;
|
|
Self.DataLevelActiveValueDropDownCount := DataLevelActiveValueDropDownCount;
|
|
Self.DataLevelActiveValueDropDownWidth := DataLevelActiveValueDropDownWidth;
|
|
Self.DataLevelsInfoVisible := DataLevelsInfoVisible;
|
|
Self.DiagramSelector := DiagramSelector;
|
|
Self.Position := Position;
|
|
Self.Visible := Visible;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartToolBox.GetDataLevelsInfoVisible: Boolean;
|
|
begin
|
|
Result := (FDataLevelsInfoVisible = dlivAlways) or
|
|
(FDataLevelsInfoVisible = dlivNonEmpty) and IsDataLevelsInfoNonEmpty;
|
|
end;
|
|
|
|
function TcxGridChartToolBox.GetVisible: Boolean;
|
|
begin
|
|
Result := (FVisible = tvAlways) or (FVisible = tvNonEmpty) and IsNonEmpty;
|
|
end;
|
|
|
|
{ TcxGridChartOptionsBehavior }
|
|
|
|
constructor TcxGridChartOptionsBehavior.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited;
|
|
FValueHints := True;
|
|
end;
|
|
|
|
function TcxGridChartOptionsBehavior.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
procedure TcxGridChartOptionsBehavior.SetValueHints(Value: Boolean);
|
|
begin
|
|
if FValueHints <> Value then
|
|
begin
|
|
FValueHints := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartOptionsBehavior.SetValueHotTrack(Value: TcxGridChartValueHotTrack);
|
|
begin
|
|
if FValueHotTrack <> Value then
|
|
begin
|
|
FValueHotTrack := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartOptionsBehavior.GetStoredProperties(AProperties: TStrings);
|
|
begin
|
|
AProperties.Add('OptionsBehavior.ValueHints');
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartOptionsBehavior.GetStoredPropertyValue(const AName: string;
|
|
var AValue: Variant);
|
|
begin
|
|
if AName = 'OptionsBehavior.ValueHints' then
|
|
AValue := ValueHints;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartOptionsBehavior.SetStoredPropertyValue(const AName: string;
|
|
const AValue: Variant);
|
|
begin
|
|
if AName = 'OptionsBehavior.ValueHints' then
|
|
ValueHints := AValue;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartOptionsBehavior.GetDefaultValueHotTrack(AValueIndex: Integer): Boolean;
|
|
begin
|
|
Result := GridView.Controller.IsDataDrillDownPossible(AValueIndex);
|
|
end;
|
|
|
|
procedure TcxGridChartOptionsBehavior.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxGridChartOptionsBehavior then
|
|
with TcxGridChartOptionsBehavior(Source) do
|
|
begin
|
|
Self.ValueHints := ValueHints;
|
|
Self.ValueHotTrack := ValueHotTrack;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartOptionsBehavior.GetValueHotTrack(AValueIndex: Integer): Boolean;
|
|
begin
|
|
Result := GridView.ActiveDiagram.SupportsValueHotTrack and
|
|
((FValueHotTrack = vhAlways) or
|
|
(FValueHotTrack = vhDefault) and GetDefaultValueHotTrack(AValueIndex));
|
|
end;
|
|
|
|
{ TcxGridChartOptionsCustomize }
|
|
|
|
constructor TcxGridChartOptionsCustomize.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited;
|
|
FDataDrillDown := True;
|
|
FDataDrillUpMethod := ddumMouseRightButtonClick;
|
|
FDataGroupMoving := True;
|
|
FOptionsCustomization := True;
|
|
FSeriesCustomization := True;
|
|
end;
|
|
|
|
procedure TcxGridChartOptionsCustomize.SetDataDrillDown(Value: Boolean);
|
|
begin
|
|
if FDataDrillDown <> Value then
|
|
begin
|
|
FDataDrillDown := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartOptionsCustomize.SetDataDrillUpMethod(Value: TcxGridChartDataDrillUpMethod);
|
|
begin
|
|
if FDataDrillUpMethod <> Value then
|
|
begin
|
|
FDataDrillUpMethod := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartOptionsCustomize.SetDataGroupHiding(Value: Boolean);
|
|
begin
|
|
if FDataGroupHiding <> Value then
|
|
begin
|
|
FDataGroupHiding := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartOptionsCustomize.SetDataGroupMoving(Value: Boolean);
|
|
begin
|
|
if FDataGroupMoving <> Value then
|
|
begin
|
|
FDataGroupMoving := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartOptionsCustomize.SetOptionsCustomization(Value: Boolean);
|
|
begin
|
|
if FOptionsCustomization <> Value then
|
|
begin
|
|
FOptionsCustomization := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartOptionsCustomize.SetSeriesCustomization(Value: Boolean);
|
|
begin
|
|
if FSeriesCustomization <> Value then
|
|
begin
|
|
FSeriesCustomization := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartOptionsCustomize.Assign(Source: TPersistent);
|
|
begin
|
|
inherited;
|
|
if Source is TcxGridChartOptionsCustomize then
|
|
with TcxGridChartOptionsCustomize(Source) do
|
|
begin
|
|
Self.DataDrillDown := DataDrillDown;
|
|
Self.DataDrillUpMethod := DataDrillUpMethod;
|
|
Self.DataGroupHiding := DataGroupHiding;
|
|
Self.DataGroupMoving := DataGroupMoving;
|
|
Self.OptionsCustomization := OptionsCustomization;
|
|
Self.SeriesCustomization := SeriesCustomization;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartOptionsView }
|
|
|
|
{constructor TcxGridChartOptionsView.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited;
|
|
end;}
|
|
|
|
function TcxGridChartOptionsView.GetGridView: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
procedure TcxGridChartOptionsView.SetCategoriesPerPage(Value: Integer);
|
|
begin
|
|
if Value < 0 then Value := 0;
|
|
if FCategoriesPerPage <> Value then
|
|
begin
|
|
FCategoriesPerPage := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartOptionsView.Assign(Source: TPersistent);
|
|
begin
|
|
inherited;
|
|
if Source is TcxGridChartOptionsView then
|
|
with TcxGridChartOptionsView(Source) do
|
|
begin
|
|
Self.CategoriesPerPage := CategoriesPerPage;
|
|
end;
|
|
end;
|
|
|
|
{ TcxGridChartViewStyles }
|
|
|
|
constructor TcxGridChartViewStyles.Create(AOwner: TPersistent);
|
|
begin
|
|
inherited;
|
|
BitmapInViewParams := True;
|
|
end;
|
|
|
|
procedure TcxGridChartViewStyles.GetDefaultViewParams(Index: Integer; AData: TObject;
|
|
out AParams: TcxViewParams);
|
|
begin
|
|
inherited;
|
|
with AParams, LookAndFeelPainter do
|
|
case Index of
|
|
vsActiveDataLevelInfo:
|
|
begin
|
|
GetViewParams(vsDataLevelsInfo, nil, nil, AParams);
|
|
Bitmap := nil;
|
|
Color := DefaultSelectionColor;
|
|
TextColor := DefaultSelectionTextColor;
|
|
end;
|
|
vsDataLevelActiveValueInfo:
|
|
begin
|
|
GetViewParams(vsDataLevelsInfo, nil, nil, AParams);
|
|
if GridView.Controller.CanShowDataLevelActiveValuePopup(False) then
|
|
TextColor := DefaultHyperlinkTextColor;
|
|
end;
|
|
vsDataLevelsInfo:
|
|
GetViewParams(vsToolBox, nil, nil, AParams);
|
|
vsDiagramSelector:
|
|
begin
|
|
GetViewParams(vsToolBox, nil, nil, AParams);
|
|
TextColor := DefaultHyperlinkTextColor;
|
|
end;
|
|
vsLegend, vsToolBox:
|
|
begin
|
|
Color := DefaultContentColor;
|
|
TextColor := DefaultContentTextColor;
|
|
end;
|
|
vsTitle:
|
|
TextColor := DefaultContentTextColor;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartViewStyles.GetGridViewValue: TcxGridChartView;
|
|
begin
|
|
Result := TcxGridChartView(inherited GridView);
|
|
end;
|
|
|
|
procedure TcxGridChartViewStyles.Assign(Source: TPersistent);
|
|
begin
|
|
inherited;
|
|
if Source is TcxGridChartViewStyles then
|
|
with TcxGridChartViewStyles(Source) do
|
|
begin
|
|
Self.ActiveDataLevelInfo := ActiveDataLevelInfo;
|
|
Self.DataLevelActiveValueInfo := DataLevelActiveValueInfo;
|
|
Self.DataLevelsInfo := DataLevelsInfo;
|
|
Self.DiagramSelector := DiagramSelector;
|
|
Self.Legend := Legend;
|
|
Self.Title := Title;
|
|
Self.ToolBox := ToolBox;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartViewStyles.GetDataLevelInfoParams(ADataLevel: Integer;
|
|
out AParams: TcxViewParams);
|
|
begin
|
|
if GridView.ActiveDataLevel = ADataLevel then
|
|
GetViewParams(vsActiveDataLevelInfo, nil, nil, AParams)
|
|
else
|
|
GetViewParams(vsDataLevelsInfo, nil, nil, AParams);
|
|
end;
|
|
|
|
{ TcxGridOpenChartItemList }
|
|
|
|
function TcxGridOpenChartItemList.GetItem(Index: Integer): TcxGridChartItem;
|
|
begin
|
|
Result := TcxGridChartItem(inherited Items[Index]);
|
|
end;
|
|
|
|
procedure TcxGridOpenChartItemList.SetItem(Index: Integer; Value: TcxGridChartItem);
|
|
begin
|
|
inherited Items[Index] := Value;
|
|
end;
|
|
|
|
{ TcxGridChartView }
|
|
|
|
function TcxGridChartView.GetActiveDataGroup: TcxGridChartDataGroup;
|
|
begin
|
|
if ActiveDataLevel < DataLevelCount - 1 then
|
|
Result := VisibleDataGroups[ActiveDataLevel]
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxGridChartView.GetAvailableDiagramCount: Integer;
|
|
begin
|
|
Result := FAvailableDiagrams.Count;
|
|
end;
|
|
|
|
function TcxGridChartView.GetAvailableDiagram(Index: Integer): TcxGridChartDiagram;
|
|
begin
|
|
Result := TcxGridChartDiagram(FAvailableDiagrams[Index]);
|
|
end;
|
|
|
|
function TcxGridChartView.GetController: TcxGridChartController;
|
|
begin
|
|
Result := TcxGridChartController(inherited Controller);
|
|
end;
|
|
|
|
function TcxGridChartView.GetDataController: TcxGridChartDataController;
|
|
begin
|
|
Result := TcxGridChartDataController(FDataController);
|
|
end;
|
|
|
|
function TcxGridChartView.GetDataGroup(Index: Integer): TcxGridChartDataGroup;
|
|
begin
|
|
Result := TcxGridChartDataGroup(FDataGroups[Index]);
|
|
end;
|
|
|
|
function TcxGridChartView.GetDataGroupCount: Integer;
|
|
begin
|
|
Result := FDataGroups.Count;
|
|
end;
|
|
|
|
function TcxGridChartView.GetDiagram(Index: Integer): TcxGridChartDiagram;
|
|
begin
|
|
Result := TcxGridChartDiagram(FDiagrams[Index]);
|
|
end;
|
|
|
|
function TcxGridChartView.GetDiagramCount: Integer;
|
|
begin
|
|
Result := FDiagrams.Count;
|
|
end;
|
|
|
|
function TcxGridChartView.GetItem(Index: Integer): IcxGridChartItem;
|
|
begin
|
|
FDataController.GetItem(Index).GetInterface(IcxGridChartItem, Result);
|
|
end;
|
|
|
|
function TcxGridChartView.GetItemCount: Integer;
|
|
begin
|
|
Result := FDataController.ItemCount;
|
|
end;
|
|
|
|
function TcxGridChartView.GetOptionsBehavior: TcxGridChartOptionsBehavior;
|
|
begin
|
|
Result := TcxGridChartOptionsBehavior(inherited OptionsBehavior);
|
|
end;
|
|
|
|
function TcxGridChartView.GetOptionsView: TcxGridChartOptionsView;
|
|
begin
|
|
Result := TcxGridChartOptionsView(inherited OptionsView);
|
|
end;
|
|
|
|
function TcxGridChartView.GetSeries(Index: Integer): TcxGridChartSeries;
|
|
begin
|
|
Result := TcxGridChartSeries(FSeries[Index]);
|
|
end;
|
|
|
|
function TcxGridChartView.GetSeriesCount: Integer;
|
|
begin
|
|
Result := FSeries.Count;
|
|
end;
|
|
|
|
function TcxGridChartView.GetSortedSeries: TcxGridChartSeries;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to SeriesCount - 1 do
|
|
begin
|
|
Result := Series[I];
|
|
if Result.SortOrder <> soNone then Exit;
|
|
end;
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxGridChartView.GetStyles: TcxGridChartViewStyles;
|
|
begin
|
|
Result := TcxGridChartViewStyles(inherited Styles);
|
|
end;
|
|
|
|
function TcxGridChartView.GetViewData: TcxGridChartViewData;
|
|
begin
|
|
Result := TcxGridChartViewData(inherited ViewData);
|
|
end;
|
|
|
|
function TcxGridChartView.GetViewInfo: TcxGridChartViewInfo;
|
|
begin
|
|
Result := TcxGridChartViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
function TcxGridChartView.GetVisibleDataGroup(Index: Integer): TcxGridChartDataGroup;
|
|
begin
|
|
Result := TcxGridChartDataGroup(FVisibleDataGroups[Index]);
|
|
end;
|
|
|
|
function TcxGridChartView.GetVisibleDataGroupCount: Integer;
|
|
begin
|
|
Result := FVisibleDataGroups.Count;
|
|
end;
|
|
|
|
function TcxGridChartView.GetVisibleSeries(Index: Integer): TcxGridChartSeries;
|
|
begin
|
|
Result := TcxGridChartSeries(FVisibleSeries[Index]);
|
|
end;
|
|
|
|
function TcxGridChartView.GetVisibleSeriesCount: Integer;
|
|
begin
|
|
Result := FVisibleSeries.Count;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetActiveDataGroup(Value: TcxGridChartDataGroup);
|
|
begin
|
|
if Value = nil then
|
|
ActiveDataLevel := DataLevelCount - 1
|
|
else
|
|
if Value.Visible then
|
|
ActiveDataLevel := Value.VisibleIndex;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetActiveDataLevel(Value: Integer);
|
|
var
|
|
APrevActiveDataLevel: Integer;
|
|
begin
|
|
if Value < 0 then Value := 0;
|
|
if Value > DataLevelCount - 1 then Value := DataLevelCount - 1;
|
|
Value := GetAvailableDataLevel(Value);
|
|
if FActiveDataLevel <> Value then
|
|
begin
|
|
APrevActiveDataLevel := FActiveDataLevel;
|
|
FActiveDataLevel := Value;
|
|
ViewData.DataLevelsChanged;
|
|
Changed(vcLayout);
|
|
ActiveDataLevelChanged(APrevActiveDataLevel);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetActiveDiagram(Value: TcxGridChartDiagram);
|
|
begin
|
|
if Value = nil then
|
|
Value := GetFirstAvailableDiagram;
|
|
if (FActiveDiagram <> Value) and ((Value = nil) or Value.IsAvailable) then
|
|
begin
|
|
FActiveDiagram := Value;
|
|
Changed(vcLayout);
|
|
ActiveDiagramChanged(FActiveDiagram);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetCategories(Value: TcxGridChartCategories);
|
|
begin
|
|
FCategories.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetDataController(Value: TcxGridChartDataController);
|
|
begin
|
|
FDataController.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetDataGroup(Index: Integer; Value: TcxGridChartDataGroup);
|
|
begin
|
|
DataGroups[Index].Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetDiagramArea(Value: TcxGridChartAreaDiagram);
|
|
begin
|
|
FDiagramArea.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetDiagramBar(Value: TcxGridChartBarDiagram);
|
|
begin
|
|
FDiagramBar.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetDiagramColumn(Value: TcxGridChartColumnDiagram);
|
|
begin
|
|
FDiagramColumn.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetDiagramLine(Value: TcxGridChartLineDiagram);
|
|
begin
|
|
FDiagramLine.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetDiagramPie(Value: TcxGridChartPieDiagram);
|
|
begin
|
|
FDiagramPie.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetLegend(Value: TcxGridChartLegend);
|
|
begin
|
|
FLegend.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetOptionsBehavior(Value: TcxGridChartOptionsBehavior);
|
|
begin
|
|
inherited OptionsBehavior := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetOptionsCustomize(Value: TcxGridChartOptionsCustomize);
|
|
begin
|
|
FOptionsCustomize.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetOptionsView(Value: TcxGridChartOptionsView);
|
|
begin
|
|
inherited OptionsView := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetSeries(Index: Integer; Value: TcxGridChartSeries);
|
|
begin
|
|
Series[Index].Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetSortedSeries(Value: TcxGridChartSeries);
|
|
begin
|
|
if SortedSeries <> Value then
|
|
if Value = nil then
|
|
SortedSeries.SortOrder := soNone
|
|
else
|
|
Value.SortOrder := soAscending;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetStyles(Value: TcxGridChartViewStyles);
|
|
begin
|
|
inherited Styles := Value;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetTitle(Value: TcxGridChartTitle);
|
|
begin
|
|
FTitle.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetToolBox(Value: TcxGridChartToolBox);
|
|
begin
|
|
FToolBox.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetOnActiveDataLevelChanged(Value: TNotifyEvent);
|
|
begin
|
|
if @FOnActiveDataLevelChanged <> @Value then
|
|
begin
|
|
FOnActiveDataLevelChanged := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetOnActiveDiagramChanged(Value: TcxGridChartDiagramEvent);
|
|
begin
|
|
if @FOnActiveDiagramChanged <> @Value then
|
|
begin
|
|
FOnActiveDiagramChanged := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetOnCustomDrawLegend(Value: TcxGridChartLegendCustomDrawEvent);
|
|
begin
|
|
if @FOnCustomDrawLegend <> @Value then
|
|
begin
|
|
FOnCustomDrawLegend := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetOnCustomDrawLegendItem(Value: TcxGridChartLegendItemCustomDrawEvent);
|
|
begin
|
|
if @FOnCustomDrawLegendItem <> @Value then
|
|
begin
|
|
FOnCustomDrawLegendItem := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetOnDataGroupPosChanged(Value: TcxGridChartDataGroupEvent);
|
|
begin
|
|
if @FOnDataGroupPosChanged <> @Value then
|
|
begin
|
|
FOnDataGroupPosChanged := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetOnFirstVisibleCategoryIndexChanged(Value: TNotifyEvent);
|
|
begin
|
|
if @FOnFirstVisibleCategoryIndexChanged <> @Value then
|
|
begin
|
|
FOnFirstVisibleCategoryIndexChanged := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetOnGetValueHint(Value: TcxGridChartGetValueHintEvent);
|
|
begin
|
|
if @FOnGetValueHint <> @Value then
|
|
begin
|
|
FOnGetValueHint := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetOnSeriesPosChanged(Value: TcxGridChartSeriesEvent);
|
|
begin
|
|
if @FOnSeriesPosChanged <> @Value then
|
|
begin
|
|
FOnSeriesPosChanged := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetOnValueClick(Value: TcxGridChartValueClickEvent);
|
|
begin
|
|
if @FOnValueClick <> @Value then
|
|
begin
|
|
FOnValueClick := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartView.GetProperties(AProperties: TStrings): Boolean;
|
|
begin
|
|
AProperties.Add('ActiveDataLevel');
|
|
AProperties.Add('ActiveDiagram');
|
|
Legend.GetStoredProperties(AProperties);
|
|
OptionsBehavior.GetStoredProperties(AProperties);
|
|
Title.GetStoredProperties(AProperties);
|
|
ToolBox.GetStoredProperties(AProperties);
|
|
Result := inherited GetProperties(AProperties);
|
|
end;
|
|
|
|
procedure TcxGridChartView.GetPropertyValue(const AName: string; var AValue: Variant);
|
|
begin
|
|
if AName = 'ActiveDataLevel' then
|
|
AValue := ActiveDataLevel
|
|
else
|
|
if AName = 'ActiveDiagram' then
|
|
if ActiveDiagram = nil then
|
|
AValue := ''
|
|
else
|
|
AValue := ActiveDiagram.ID
|
|
else
|
|
begin
|
|
Legend.GetStoredPropertyValue(AName, AValue);
|
|
OptionsBehavior.GetStoredPropertyValue(AName, AValue);
|
|
Title.GetStoredPropertyValue(AName, AValue);
|
|
ToolBox.GetStoredPropertyValue(AName, AValue);
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetPropertyValue(const AName: string; const AValue: Variant);
|
|
var
|
|
ADiagram: TcxGridChartDiagram;
|
|
begin
|
|
if AName = 'ActiveDataLevel' then
|
|
FRestoredActiveDataLevel := AValue
|
|
else
|
|
if AName = 'ActiveDiagram' then
|
|
begin
|
|
ADiagram := FindDiagramByID(AValue);
|
|
if ADiagram <> nil then
|
|
ADiagram.Active := True;
|
|
end
|
|
else
|
|
begin
|
|
Legend.SetStoredPropertyValue(AName, AValue);
|
|
OptionsBehavior.SetStoredPropertyValue(AName, AValue);
|
|
Title.SetStoredPropertyValue(AName, AValue);
|
|
ToolBox.SetStoredPropertyValue(AName, AValue);
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartView.CreateStoredObject(const AObjectName, AClassName: string): TObject;
|
|
begin
|
|
if AClassName = GetDataGroupClass.ClassName then
|
|
Result := CreateDataGroup
|
|
else
|
|
if AClassName = GetSeriesClass.ClassName then
|
|
Result := CreateSeries
|
|
else
|
|
Result := inherited CreateStoredObject(AObjectName, AClassName);
|
|
end;
|
|
|
|
procedure TcxGridChartView.GetStoredChildren(AChildren: TStringList);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to DataGroupCount - 1 do
|
|
AChildren.AddObject('', DataGroups[I]);
|
|
for I := 0 to SeriesCount - 1 do
|
|
AChildren.AddObject('', Series[I]);
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartView.AssignLayout(ALayoutView: TcxCustomGridView);
|
|
begin
|
|
inherited;
|
|
Assign(ALayoutView);
|
|
end;
|
|
|
|
function TcxGridChartView.GetLayoutCustomizationFormButtonCaption: string;
|
|
begin
|
|
Result := 'Chart customization';
|
|
end;
|
|
|
|
function TcxGridChartView.HasLayoutCustomizationForm: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TcxGridChartView.CreateHandlers;
|
|
begin
|
|
FCategories := GetCategoriesClass.Create(Self);
|
|
FDiagrams := TList.Create;
|
|
FAvailableDiagrams := TList.Create;
|
|
FDataGroups := TList.Create;
|
|
FSeries := TList.Create;
|
|
FVisibleDataGroups := TList.Create;
|
|
FVisibleSeries := TList.Create;
|
|
CreateDiagrams;
|
|
inherited;
|
|
UpdateDataController(FCategories, FCategories.DataBinding, True);
|
|
end;
|
|
|
|
procedure TcxGridChartView.DestroyHandlers;
|
|
begin
|
|
ClearDiagrams;
|
|
ClearDataGroups;
|
|
ClearSeries;
|
|
UpdateDataController(FCategories, FCategories.DataBinding, False);
|
|
inherited;
|
|
FreeAndNil(FVisibleSeries);
|
|
FreeAndNil(FVisibleDataGroups);
|
|
FreeAndNil(FSeries);
|
|
FreeAndNil(FDataGroups);
|
|
FreeAndNil(FAvailableDiagrams);
|
|
FreeAndNil(FDiagrams);
|
|
FreeAndNil(FCategories);
|
|
end;
|
|
|
|
procedure TcxGridChartView.CreateOptions;
|
|
begin
|
|
inherited;
|
|
FLegend := GetLegendClass.Create(Self);
|
|
FOptionsCustomize := GetOptionsCustomizeClass.Create(Self);
|
|
FTitle := GetTitleClass.Create(Self);
|
|
FToolBox := GetToolBoxClass.Create(Self);
|
|
end;
|
|
|
|
procedure TcxGridChartView.DestroyOptions;
|
|
begin
|
|
FreeAndNil(FToolBox);
|
|
FreeAndNil(FTitle);
|
|
FreeAndNil(FOptionsCustomize);
|
|
FreeAndNil(FLegend);
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartView.ActiveDataLevelChanged(APrevActiveDataLevel: Integer);
|
|
begin
|
|
if IsDestroying then Exit;
|
|
DoActiveDataLevelChanged;
|
|
Controller.ActiveDataLevelChanged(APrevActiveDataLevel, ActiveDataLevel);
|
|
end;
|
|
|
|
procedure TcxGridChartView.ActiveDiagramChanged(ADiagram: TcxGridChartDiagram);
|
|
begin
|
|
if IsDestroying then Exit;
|
|
DoActiveDiagramChanged(ADiagram);
|
|
if Controller <> nil then
|
|
Controller.ActiveDiagramChanged(ADiagram);
|
|
end;
|
|
|
|
procedure TcxGridChartView.BeforeAssign(ASource: TcxCustomGridView);
|
|
begin
|
|
inherited;
|
|
UpdateSummaryItemValues;
|
|
end;
|
|
|
|
procedure TcxGridChartView.AfterAssign(ASource: TcxCustomGridView);
|
|
begin
|
|
inherited;
|
|
UpdateSummaryItemValues;
|
|
end;
|
|
|
|
procedure TcxGridChartView.DoAssign(ASource: TcxCustomGridView);
|
|
|
|
procedure AssignItems(ASource: TcxGridChartView; AItemClass: TcxGridChartItemClass);
|
|
var
|
|
ASourceItems, AItems: TList;
|
|
I: Integer;
|
|
ASourceItem, AItem: TcxGridChartItem;
|
|
begin
|
|
ASourceItems := ASource.GetItemList(AItemClass);
|
|
for I := 0 to ASourceItems.Count - 1 do
|
|
begin
|
|
ASourceItem := TcxGridChartItem(ASourceItems[I]);
|
|
AItem := FindItemByID(AItemClass, ASourceItem.ID);
|
|
if AItem = nil then
|
|
begin
|
|
AItem := CreateItem(AItemClass);
|
|
AItem.DataBinding.ID := ASourceItem.ID;
|
|
end;
|
|
AItem.FOrder := ASourceItem.Order;
|
|
AItem.Index := I;
|
|
AItem.Assign(ASourceItem);
|
|
end;
|
|
AItems := GetItemList(AItemClass);
|
|
for I := AItems.Count - 1 downto ASourceItems.Count do
|
|
TcxGridChartItem(AItems[I]).Free;
|
|
end;
|
|
|
|
begin
|
|
if ASource is TcxGridChartView then
|
|
begin
|
|
if not AssigningSettings then
|
|
begin
|
|
Categories := TcxGridChartView(ASource).Categories;
|
|
Categories.DataBinding.ID := TcxGridChartView(ASource).Categories.ID;
|
|
AssignItems(TcxGridChartView(ASource), GetDataGroupClass);
|
|
AssignItems(TcxGridChartView(ASource), GetSeriesClass);
|
|
end;
|
|
with TcxGridChartView(ASource) do
|
|
begin
|
|
Self.DiagramArea := DiagramArea;
|
|
Self.DiagramBar := DiagramBar;
|
|
Self.DiagramColumn := DiagramColumn;
|
|
Self.DiagramLine := DiagramLine;
|
|
Self.DiagramPie := DiagramPie;
|
|
Self.Legend := Legend;
|
|
Self.OptionsCustomize := OptionsCustomize;
|
|
Self.Title := Title;
|
|
Self.ToolBox := ToolBox;
|
|
Self.OnActiveDataLevelChanged := OnActiveDataLevelChanged;
|
|
Self.OnActiveDiagramChanged := OnActiveDiagramChanged;
|
|
Self.OnCustomDrawLegend := OnCustomDrawLegend;
|
|
Self.OnCustomDrawLegendItem := OnCustomDrawLegendItem;
|
|
Self.OnDataGroupPosChanged := OnDataGroupPosChanged;
|
|
Self.OnFirstVisibleCategoryIndexChanged := OnFirstVisibleCategoryIndexChanged;
|
|
Self.OnGetValueHint := OnGetValueHint;
|
|
Self.OnSeriesPosChanged := OnSeriesPosChanged;
|
|
Self.OnValueClick := OnValueClick;
|
|
end;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridChartView.BeforeRestoring;
|
|
begin
|
|
inherited;
|
|
FRestoringDataGroups := TcxGridOpenChartItemList.Create;
|
|
FRestoringSeries := TcxGridOpenChartItemList.Create;
|
|
end;
|
|
|
|
procedure TcxGridChartView.AfterRestoring;
|
|
|
|
procedure AssignItemIndexes(AItems: TcxGridOpenChartItemList);
|
|
var
|
|
I, J: Integer;
|
|
begin
|
|
J := 0;
|
|
for I := 0 to AItems.Count - 1 do
|
|
if AItems[I] <> nil then
|
|
begin
|
|
AItems[I].Index := J;
|
|
Inc(J);
|
|
end;
|
|
end;
|
|
|
|
begin
|
|
try
|
|
AssignItemIndexes(RestoringDataGroups);
|
|
AssignItemIndexes(RestoringSeries);
|
|
finally
|
|
FRestoringSeries.Free;
|
|
FRestoringDataGroups.Free;
|
|
inherited;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.DataControllerUnlocked;
|
|
begin
|
|
if DataGroupActiveValuesUpdateNeeded then
|
|
UpdateDataGroupActiveValues;
|
|
end;
|
|
|
|
procedure TcxGridChartView.GetChildren(Proc: TGetChildProc; Root: TComponent);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
inherited;
|
|
for I := 0 to DataGroupCount - 1 do
|
|
if DataGroups[I].Owner = Root then Proc(DataGroups[I]);
|
|
for I := 0 to SeriesCount - 1 do
|
|
if Series[I].Owner = Root then Proc(Series[I]);
|
|
end;
|
|
|
|
procedure TcxGridChartView.GetFakeComponentLinks(AList: TList);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
inherited;
|
|
for I := 0 to DiagramCount - 1 do
|
|
Diagrams[I].Styles.GetFakeComponentLinks(AList);
|
|
for I := 0 to SeriesCount - 1 do
|
|
Series[I].Styles.GetFakeComponentLinks(AList);
|
|
end;
|
|
|
|
procedure TcxGridChartView.RestoringComplete;
|
|
begin
|
|
inherited;
|
|
ActiveDataLevel := FRestoredActiveDataLevel;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetChildOrder(Child: TComponent; Order: Integer);
|
|
begin
|
|
inherited;
|
|
if Child is GetDataGroupClass then
|
|
TcxGridChartDataGroup(Child).Index := Order;
|
|
if Child is GetSeriesClass then
|
|
TcxGridChartSeries(Child).Index := Order - DataGroupCount;
|
|
end;
|
|
|
|
function ChartViewGetDataGroup(ACaller: TComponent; Index: Integer): TComponent;
|
|
begin
|
|
Result := TcxGridChartView(ACaller).DataGroups[Index];
|
|
end;
|
|
|
|
function ChartViewGetSeries(ACaller: TComponent; Index: Integer): TComponent;
|
|
begin
|
|
Result := TcxGridChartView(ACaller).Series[Index];
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetName(const NewName: TComponentName);
|
|
var
|
|
AOldName: TComponentName;
|
|
begin
|
|
AOldName := Name;
|
|
inherited;
|
|
if Name <> AOldName then
|
|
begin
|
|
RenameComponents(Self, Owner, Name, AOldName, DataGroupCount, @ChartViewGetDataGroup);
|
|
RenameComponents(Self, Owner, Name, AOldName, SeriesCount, @ChartViewGetSeries);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.UpdateControl(AInfo: TcxUpdateControlInfo);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
ViewData.Update(AInfo);
|
|
if not (IsLoading or IsDestroying) and
|
|
not (AInfo is TcxFocusedRecordChangedInfo) and not (AInfo is TcxFocusedRowChangedInfo) then
|
|
begin
|
|
LayoutChanged;
|
|
if (AInfo is TcxDataChangedInfo) or (AInfo is TcxLayoutChangedInfo) then
|
|
begin
|
|
Synchronize;
|
|
if AInfo is TcxDataChangedInfo then
|
|
for I := 0 to ItemCount - 1 do
|
|
Items[I].DataChanged;
|
|
end;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridChartView.GetControllerClass: TcxCustomGridControllerClass;
|
|
begin
|
|
Result := TcxGridChartController;
|
|
end;
|
|
|
|
function TcxGridChartView.GetDataControllerClass: TcxCustomDataControllerClass;
|
|
begin
|
|
Result := TcxGridChartDataController;
|
|
end;
|
|
|
|
function TcxGridChartView.GetItemDataBindingClass: TcxGridChartItemDataBindingClass;
|
|
begin
|
|
Result := TcxGridChartItemDataBinding;
|
|
end;
|
|
|
|
function TcxGridChartView.GetPainterClass: TcxCustomGridPainterClass;
|
|
begin
|
|
Result := TcxGridChartPainter;
|
|
end;
|
|
|
|
function TcxGridChartView.GetViewDataClass: TcxCustomGridViewDataClass;
|
|
begin
|
|
Result := TcxGridChartViewData;
|
|
end;
|
|
|
|
function TcxGridChartView.GetViewInfoClass: TcxCustomGridViewInfoClass;
|
|
begin
|
|
Result := TcxGridChartViewInfo;
|
|
end;
|
|
|
|
function TcxGridChartView.GetLegendClass: TcxGridChartLegendClass;
|
|
begin
|
|
Result := TcxGridChartLegend;
|
|
end;
|
|
|
|
function TcxGridChartView.GetOptionsBehaviorClass: TcxCustomGridOptionsBehaviorClass;
|
|
begin
|
|
Result := TcxGridChartOptionsBehavior;
|
|
end;
|
|
|
|
function TcxGridChartView.GetOptionsCustomizeClass: TcxGridChartOptionsCustomizeClass;
|
|
begin
|
|
Result := TcxGridChartOptionsCustomize;
|
|
end;
|
|
|
|
function TcxGridChartView.GetOptionsViewClass: TcxCustomGridOptionsViewClass;
|
|
begin
|
|
Result := TcxGridChartOptionsView;
|
|
end;
|
|
|
|
function TcxGridChartView.GetStylesClass: TcxCustomGridViewStylesClass;
|
|
begin
|
|
Result := TcxGridChartViewStyles;
|
|
end;
|
|
|
|
function TcxGridChartView.GetTitleClass: TcxGridChartTitleClass;
|
|
begin
|
|
Result := TcxGridChartTitle;
|
|
end;
|
|
|
|
function TcxGridChartView.GetToolBoxClass: TcxGridChartToolBoxClass;
|
|
begin
|
|
Result := TcxGridChartToolBox;
|
|
end;
|
|
|
|
function TcxGridChartView.GetAreaDiagramClass: TcxGridChartAreaDiagramClass;
|
|
begin
|
|
Result := TcxGridChartAreaDiagram;
|
|
end;
|
|
|
|
function TcxGridChartView.GetBarDiagramClass: TcxGridChartBarDiagramClass;
|
|
begin
|
|
Result := TcxGridChartBarDiagram;
|
|
end;
|
|
|
|
function TcxGridChartView.GetCategoriesClass: TcxGridChartCategoriesClass;
|
|
begin
|
|
Result := TcxGridChartCategories;
|
|
end;
|
|
|
|
function TcxGridChartView.GetColumnDiagramClass: TcxGridChartColumnDiagramClass;
|
|
begin
|
|
Result := TcxGridChartColumnDiagram;
|
|
end;
|
|
|
|
function TcxGridChartView.GetLineDiagramClass: TcxGridChartLineDiagramClass;
|
|
begin
|
|
Result := TcxGridChartLineDiagram;
|
|
end;
|
|
|
|
function TcxGridChartView.GetPieDiagramClass: TcxGridChartPieDiagramClass;
|
|
begin
|
|
Result := TcxGridChartPieDiagram;
|
|
end;
|
|
|
|
function TcxGridChartView.GetCategoriesNamePath: string;
|
|
begin
|
|
Result := Name;
|
|
if Result <> '' then
|
|
Result := Result + '.';
|
|
Result := Result + GetSubobjectName(Self, Categories);
|
|
end;
|
|
|
|
procedure TcxGridChartView.AddDiagram(ADiagram: TcxGridChartDiagram);
|
|
begin
|
|
FDiagrams.Add(ADiagram);
|
|
if ADiagram.IsAvailable then
|
|
FAvailableDiagrams.Add(ADiagram);
|
|
ADiagram.SetGridView(Self);
|
|
if ActiveDiagram = nil then
|
|
ActiveDiagram := GetFirstAvailableDiagram;
|
|
end;
|
|
|
|
procedure TcxGridChartView.RemoveDiagram(ADiagram: TcxGridChartDiagram);
|
|
begin
|
|
ADiagram.SetGridView(nil);
|
|
FAvailableDiagrams.Remove(ADiagram);
|
|
FDiagrams.Remove(ADiagram);
|
|
DiagramRemoved(ADiagram);
|
|
if ActiveDiagram = ADiagram then
|
|
ActiveDiagram := nil;
|
|
end;
|
|
|
|
procedure TcxGridChartView.ClearDiagrams;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := DiagramCount - 1 downto 0 do
|
|
Diagrams[I].Free;
|
|
end;
|
|
|
|
function TcxGridChartView.CreateDiagram(ADiagramClass: TcxGridChartDiagramClass): TcxGridChartDiagram;
|
|
begin
|
|
Result := ADiagramClass.Create(Self);
|
|
end;
|
|
|
|
procedure TcxGridChartView.CreateDiagrams;
|
|
begin
|
|
FDiagramColumn := TcxGridChartColumnDiagram(CreateDiagram(GetColumnDiagramClass)); // should first to be default
|
|
FDiagramBar := TcxGridChartBarDiagram(CreateDiagram(GetBarDiagramClass));
|
|
FDiagramLine := TcxGridChartLineDiagram(CreateDiagram(GetLineDiagramClass));
|
|
FDiagramArea := TcxGridChartAreaDiagram(CreateDiagram(GetAreaDiagramClass));
|
|
FDiagramPie := TcxGridChartPieDiagram(CreateDiagram(GetPieDiagramClass));
|
|
end;
|
|
|
|
procedure TcxGridChartView.DiagramRemoved(ADiagram: TcxGridChartDiagram);
|
|
begin
|
|
if ADiagram = FDiagramArea then
|
|
FDiagramArea := nil;
|
|
if ADiagram = FDiagramBar then
|
|
FDiagramBar := nil;
|
|
if ADiagram = FDiagramColumn then
|
|
FDiagramColumn := nil;
|
|
if ADiagram = FDiagramLine then
|
|
FDiagramLine := nil;
|
|
if ADiagram = FDiagramPie then
|
|
FDiagramPie := nil;
|
|
end;
|
|
|
|
function TcxGridChartView.GetDiagramNamePath(ADiagram: TcxGridChartDiagram): string;
|
|
begin
|
|
Result := Name;
|
|
if Result <> '' then
|
|
Result := Result + '.';
|
|
Result := Result + GetSubobjectName(Self, ADiagram);
|
|
end;
|
|
|
|
function TcxGridChartView.GetFirstAvailableDiagram: TcxGridChartDiagram;
|
|
begin
|
|
if AvailableDiagramCount = 0 then
|
|
Result := nil
|
|
else
|
|
Result := AvailableDiagrams[0];
|
|
end;
|
|
|
|
procedure TcxGridChartView.RefreshAvailableDiagramList;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
FAvailableDiagrams.Clear;
|
|
for I := 0 to DiagramCount - 1 do
|
|
if Diagrams[I].IsAvailable then
|
|
FAvailableDiagrams.Add(Diagrams[I]);
|
|
end;
|
|
|
|
function TcxGridChartView.GetNextID: Integer;
|
|
begin
|
|
if FIDs = nil then
|
|
FIDs := TList.Create;
|
|
Result := FIDs.Add(Pointer(1));
|
|
end;
|
|
|
|
procedure TcxGridChartView.ReleaseID(AID: Integer);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
FIDs[AID] := nil;
|
|
if AID = FIDs.Count - 1 then
|
|
begin
|
|
I := FIDs.Count - 1;
|
|
while (I >= 0) and (FIDs[I] = nil) do
|
|
Dec(I);
|
|
FIDs.Count := I + 1;
|
|
if FIDs.Count = 0 then
|
|
FreeAndNil(FIDs);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.DataSortingChanged(AItem: TObject);
|
|
begin
|
|
if AItem is GetSeriesClass then
|
|
begin
|
|
if TcxGridChartSeries(AItem).SortOrder <> soNone then
|
|
TcxGridChartSeries(AItem).DataBinding.SortIndex := 0;
|
|
UpdateDataSortingBySummary;
|
|
RefreshCustomizationForm;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.DataSortingChanging(AItem: TObject);
|
|
|
|
procedure ClearSeriesSorting;
|
|
var
|
|
I: Integer;
|
|
ASortedItem: TObject;
|
|
begin
|
|
for I := FDataController.GetSortingItemCount - 1 downto 0 do
|
|
begin
|
|
ASortedItem := FDataController.GetItem(FDataController.GetSortingItemIndex(I));
|
|
if ASortedItem is GetSeriesClass then
|
|
TcxGridChartSeries(ASortedItem).SortOrder := soNone;
|
|
end;
|
|
end;
|
|
|
|
begin
|
|
if (AItem is GetSeriesClass) and (TcxGridChartSeries(AItem).SortOrder = soNone) then
|
|
ClearSeriesSorting;
|
|
end;
|
|
|
|
procedure TcxGridChartView.UpdateDataController(AItem: TObject;
|
|
ADataBinding: TcxGridChartItemDataBinding; AAdd: Boolean);
|
|
begin
|
|
BeginUpdate;
|
|
try
|
|
if AAdd then
|
|
begin
|
|
ADataBinding.ID := GetNextID;
|
|
ADataBinding.DataField := FDataController.AddItem(AItem);
|
|
end
|
|
else
|
|
begin
|
|
ReleaseID(ADataBinding.ID);
|
|
ADataBinding.DataField := nil;
|
|
FDataController.RemoveItem(AItem);
|
|
end;
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.UpdateSummaryItemValues;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to ItemCount - 1 do
|
|
Items[I].GetDataBinding.UpdateSummaryItemValue;
|
|
UpdateDataSortingBySummary;
|
|
end;
|
|
|
|
function TcxGridChartView.GetItemList(AItemClass: TcxGridChartItemClass): TList;
|
|
begin
|
|
if AItemClass = GetSeriesClass then
|
|
Result := FSeries
|
|
else
|
|
if AItemClass = GetDataGroupClass then
|
|
Result := FDataGroups
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxGridChartView.GetItemList(AItem: TcxGridChartItem): TList;
|
|
begin
|
|
Result := GetItemList(TcxGridChartItemClass(AItem.ClassType));
|
|
end;
|
|
|
|
function TcxGridChartView.GetVisibleItemList(AItem: TcxGridChartItem): TList;
|
|
begin
|
|
if AItem is GetSeriesClass then
|
|
Result := FVisibleSeries
|
|
else
|
|
if AItem is GetDataGroupClass then
|
|
Result := FVisibleDataGroups
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
procedure TcxGridChartView.AddItem(AItem: TcxGridChartItem);
|
|
begin
|
|
{$IFDEF DELPHI6}
|
|
if csTransient in ComponentStyle then
|
|
AItem.FComponentStyle := AItem.FComponentStyle + [csTransient];
|
|
{$ENDIF}
|
|
BeginUpdate;
|
|
try
|
|
GetItemList(AItem).Add(AItem);
|
|
AItem.SetGridView(Self);
|
|
UpdateDataController(AItem, AItem.DataBinding, True);
|
|
ItemPosChanged(AItem);
|
|
if AItem.Visible then
|
|
ItemVisibilityChanged(AItem);
|
|
Changed(vcLayout);
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
RefreshCustomizationForm;
|
|
end;
|
|
|
|
procedure TcxGridChartView.RemoveItem(AItem: TcxGridChartItem);
|
|
begin
|
|
BeginUpdate;
|
|
try
|
|
AItem.SetGridView(nil);
|
|
GetItemList(AItem).Remove(AItem);
|
|
if AItem.Visible then
|
|
ItemVisibilityChanged(AItem);
|
|
ItemPosChanged(AItem);
|
|
UpdateDataController(AItem, AItem.DataBinding, False);
|
|
Changed(vcLayout);
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
RefreshCustomizationForm;
|
|
end;
|
|
|
|
function TcxGridChartView.GetItemIndex(AItem: TcxGridChartItem): Integer;
|
|
begin
|
|
Result := GetItemList(AItem).IndexOf(AItem);
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetItemIndex(AItem: TcxGridChartItem; AIndex: Integer);
|
|
begin
|
|
if GetItemIndex(AItem) <> AIndex then
|
|
begin
|
|
GetItemList(AItem).Move(GetItemIndex(AItem), AIndex);
|
|
ItemIndexChanged(AItem);
|
|
Changed(vcLayout);
|
|
RefreshCustomizationForm;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.DataGroupVisibilityChanged(ADataGroup: TcxGridChartDataGroup);
|
|
begin
|
|
UpdateDataLevels;
|
|
end;
|
|
|
|
procedure TcxGridChartView.ItemDisplayTextChanged(AItem: TcxGridChartItem);
|
|
begin
|
|
RefreshCustomizationForm;
|
|
end;
|
|
|
|
procedure TcxGridChartView.ItemIndexChanged(AItem: TcxGridChartItem);
|
|
begin
|
|
ItemPosChanged(AItem);
|
|
if AItem.Visible then
|
|
ItemVisibilityChanged(AItem);
|
|
end;
|
|
|
|
procedure TcxGridChartView.ItemPosChanged(AItem: TcxGridChartItem);
|
|
begin
|
|
UpdateItemsOrder(TcxGridChartItemClass(AItem.ClassType));
|
|
if AItem is GetSeriesClass then
|
|
begin
|
|
UpdateDataSortingBySummary;
|
|
ViewData.SeriesPosChanged(TcxGridChartSeries(AItem));
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.ItemVisibilityChanged(AItem: TcxGridChartItem);
|
|
begin
|
|
RefreshVisibleItemsList(GetItemList(AItem), GetVisibleItemList(AItem));
|
|
if AItem is GetDataGroupClass then
|
|
DataGroupVisibilityChanged(TcxGridChartDataGroup(AItem));
|
|
if AItem is GetSeriesClass then
|
|
SeriesVisibilityChanged(TcxGridChartSeries(AItem));
|
|
RefreshCustomizationForm;
|
|
end;
|
|
|
|
procedure TcxGridChartView.ItemVisibilityForCustomizationChanged(AItem: TcxGridChartItem);
|
|
begin
|
|
RefreshCustomizationForm;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SeriesVisibilityChanged(ASeries: TcxGridChartSeries);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxGridChartView.RefreshVisibleItemsList(AItems, AVisibleItems: TList);
|
|
var
|
|
I: Integer;
|
|
AItem: TcxGridChartItem;
|
|
begin
|
|
AVisibleItems.Clear;
|
|
for I := 0 to AItems.Count - 1 do
|
|
begin
|
|
AItem := TcxGridChartItem(AItems[I]);
|
|
if AItem.Visible then
|
|
AItem.FVisibleIndex := AVisibleItems.Add(AItem)
|
|
else
|
|
AItem.FVisibleIndex := -1;
|
|
end;
|
|
end;
|
|
|
|
function CompareItemsByID(Item1, Item2: Pointer): Integer;
|
|
begin
|
|
Result := TcxGridChartItem(Item1).ID - TcxGridChartItem(Item2).ID;
|
|
end;
|
|
|
|
procedure TcxGridChartView.UpdateItemsOrder(AItemClass: TcxGridChartItemClass);
|
|
var
|
|
AItems: TList;
|
|
I: Integer;
|
|
begin
|
|
AItems := TList.Create;
|
|
try
|
|
CopyList(GetItemList(AItemClass), AItems);
|
|
AItems.Sort(CompareItemsByID);
|
|
for I := 0 to AItems.Count - 1 do
|
|
TcxGridChartItem(AItems[I]).FOrder := I;
|
|
finally
|
|
AItems.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.ClearItems(AItemClass: TcxGridChartItemClass);
|
|
var
|
|
AItems: TList;
|
|
I: Integer;
|
|
begin
|
|
AItems := GetItemList(AItemClass);
|
|
BeginUpdate;
|
|
try
|
|
for I := AItems.Count - 1 downto 0 do
|
|
TcxGridChartItem(AItems[I]).Free;
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartView.CreateItem(AItemClass: TcxGridChartItemClass): TcxGridChartItem;
|
|
begin
|
|
Result := AItemClass.Create(Owner);
|
|
AddItem(Result);
|
|
end;
|
|
|
|
function TcxGridChartView.FindItemByID(AItemClass: TcxGridChartItemClass;
|
|
AID: Integer): TcxGridChartItem;
|
|
var
|
|
AItems: TList;
|
|
I: Integer;
|
|
begin
|
|
AItems := GetItemList(AItemClass);
|
|
for I := 0 to AItems.Count - 1 do
|
|
begin
|
|
Result := TcxGridChartItem(AItems[I]);
|
|
if Result.ID = AID then Exit;
|
|
end;
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxGridChartView.FindItemByName(AItemClass: TcxGridChartItemClass;
|
|
const AName: string): TcxGridChartItem;
|
|
var
|
|
AItems: TList;
|
|
I: Integer;
|
|
begin
|
|
AItems := GetItemList(AItemClass);
|
|
for I := 0 to AItems.Count - 1 do
|
|
begin
|
|
Result := TcxGridChartItem(AItems[I]);
|
|
if Result.Name = AName then Exit;
|
|
end;
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxGridChartView.FindItemByTag(AItemClass: TcxGridChartItemClass;
|
|
ATag: TcxTag): TcxGridChartItem;
|
|
var
|
|
AItems: TList;
|
|
I: Integer;
|
|
begin
|
|
AItems := GetItemList(AItemClass);
|
|
for I := 0 to AItems.Count - 1 do
|
|
begin
|
|
Result := TcxGridChartItem(AItems[I]);
|
|
if Result.Tag = ATag then Exit;
|
|
end;
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxGridChartView.GetAvailableDataLevel(ALevel: Integer): Integer;
|
|
begin
|
|
for Result := 0 to ALevel - 1 do
|
|
if not DataLevelObjects[Result].HasActiveValue then Exit;
|
|
Result := ALevel;
|
|
end;
|
|
|
|
function TcxGridChartView.GetDataLevelCount: Integer;
|
|
begin
|
|
Result := VisibleDataGroupCount + 1;
|
|
end;
|
|
|
|
function TcxGridChartView.GetDataLevelObject(Index: Integer): TcxGridChartDataGroup;
|
|
begin
|
|
if Index < VisibleDataGroupCount then
|
|
Result := VisibleDataGroups[Index]
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxGridChartView.GetDataObjectLevel(AObject: TcxGridChartDataGroup): Integer;
|
|
begin
|
|
Result := AObject.VisibleIndex;
|
|
end;
|
|
|
|
procedure TcxGridChartView.SetDataObjectLevel(AObject: TcxGridChartDataGroup; ALevel: Integer);
|
|
begin
|
|
if ALevel = -1 then
|
|
AObject.Visible := False
|
|
else
|
|
if (0 <= ALevel) and (ALevel < VisibleDataGroupCount + Ord(not AObject.Visible)) then
|
|
begin
|
|
BeginUpdate;
|
|
try
|
|
AObject.Visible := True;
|
|
AObject.Index := DataLevelObjects[ALevel].Index;
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridChartView.GetIsDataGrouped: Boolean;
|
|
begin
|
|
Result := VisibleDataGroupCount <> 0;
|
|
end;
|
|
|
|
procedure TcxGridChartView.UpdateDataGroupActiveValues;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
if FDataController.LockCount <> 0 then
|
|
begin
|
|
FDataGroupActiveValuesUpdateNeeded := True;
|
|
Exit;
|
|
end;
|
|
FDataGroupActiveValuesUpdateNeeded := False;
|
|
|
|
for I := 0 to DataGroupCount - 1 do
|
|
DataGroups[I].CheckActiveValue;
|
|
ActiveDataLevel := ActiveDataLevel;
|
|
end;
|
|
|
|
procedure TcxGridChartView.UpdateDataLevels;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
BeginUpdate;
|
|
try
|
|
// ActiveDataLevel := ActiveDataLevel;
|
|
FDataController.Groups.ClearGrouping;
|
|
for I := 0 to VisibleDataGroupCount - 1 do
|
|
VisibleDataGroups[I].GroupIndex := I;
|
|
UpdateDataGroupActiveValues;
|
|
Controller.DataLevelsChanged;
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.UpdateDataSortingBySummary;
|
|
var
|
|
ASeries: TcxGridChartSeries;
|
|
begin
|
|
ASeries := SortedSeries;
|
|
if ASeries = nil then
|
|
FDataController.SortingBySummaryDataItemIndex := -1
|
|
else
|
|
FDataController.SortingBySummaryDataItemIndex := ASeries.DataBinding.DataIndex;
|
|
end;
|
|
|
|
procedure TcxGridChartView.CalculateImageWidth(var AWidth: Integer);
|
|
const
|
|
DefaultWidth = 700;
|
|
begin
|
|
if AWidth = 0 then
|
|
begin
|
|
if Control <> nil then
|
|
AWidth := Control.Width;
|
|
if AWidth = 0 then
|
|
AWidth := DefaultWidth;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.CalculateImageHeight(var AHeight: Integer);
|
|
const
|
|
DefaultHeight = 500;
|
|
begin
|
|
if AHeight = 0 then
|
|
begin
|
|
AHeight := TcxGridLevel(Level).Parent.MaxDetailHeight;
|
|
if AHeight = 0 then
|
|
begin
|
|
if Control <> nil then
|
|
AHeight := Control.Height;
|
|
if AHeight = 0 then
|
|
AHeight := DefaultHeight;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridChartView.DoActiveDataLevelChanged;
|
|
begin
|
|
if Assigned(FOnActiveDataLevelChanged) then FOnActiveDataLevelChanged(Self);
|
|
end;
|
|
|
|
procedure TcxGridChartView.DoActiveDiagramChanged(ADiagram: TcxGridChartDiagram);
|
|
begin
|
|
if Assigned(FOnActiveDiagramChanged) then FOnActiveDiagramChanged(Self, ADiagram);
|
|
end;
|
|
|
|
procedure TcxGridChartView.DoCustomDrawLegend(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxGridChartLegendViewInfo; var ADone: Boolean);
|
|
begin
|
|
if HasCustomDrawLegend then
|
|
FOnCustomDrawLegend(Self, ACanvas, AViewInfo, ADone);
|
|
end;
|
|
|
|
procedure TcxGridChartView.DoCustomDrawLegendItem(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxGridChartLegendItemViewInfo; var ADone: Boolean);
|
|
begin
|
|
if HasCustomDrawLegendItem then
|
|
FOnCustomDrawLegendItem(Self, ACanvas, AViewInfo, ADone);
|
|
end;
|
|
|
|
procedure TcxGridChartView.DoDataGroupPosChanged(ADataGroup: TcxGridChartDataGroup);
|
|
begin
|
|
if Assigned(FOnDataGroupPosChanged) then FOnDataGroupPosChanged(Self, ADataGroup);
|
|
end;
|
|
|
|
procedure TcxGridChartView.DoFirstVisibleCategoryIndexChanged;
|
|
begin
|
|
if Assigned(FOnFirstVisibleCategoryIndexChanged) then
|
|
FOnFirstVisibleCategoryIndexChanged(Self);
|
|
end;
|
|
|
|
procedure TcxGridChartView.DoGetValueHint(ASeries: TcxGridChartSeries; AValueIndex: Integer;
|
|
var AHint: string);
|
|
begin
|
|
if Assigned(FOnGetValueHint) then
|
|
FOnGetValueHint(Self, ASeries, AValueIndex, AHint);
|
|
end;
|
|
|
|
procedure TcxGridChartView.DoSeriesPosChanged(ASeries: TcxGridChartSeries);
|
|
begin
|
|
if Assigned(FOnSeriesPosChanged) then FOnSeriesPosChanged(Self, ASeries);
|
|
end;
|
|
|
|
function TcxGridChartView.DoValueClick(ASeries: TcxGridChartSeries; AValueIndex: Integer): Boolean;
|
|
begin
|
|
Result := False;
|
|
if Assigned(FOnValueClick) then
|
|
FOnValueClick(Self, ASeries, AValueIndex, Result);
|
|
end;
|
|
|
|
function TcxGridChartView.HasCustomDrawLegend: Boolean;
|
|
begin
|
|
Result := Assigned(FOnCustomDrawLegend);
|
|
end;
|
|
|
|
function TcxGridChartView.HasCustomDrawLegendItem: Boolean;
|
|
begin
|
|
Result := Assigned(FOnCustomDrawLegendItem);
|
|
end;
|
|
|
|
{$IFNDEF DELPHI6}
|
|
|
|
type
|
|
TGraphicAccess = class(TGraphic);
|
|
TGraphicAccessClass = class of TGraphicAccess;
|
|
|
|
{$ENDIF}
|
|
|
|
function TcxGridChartView.CreateImage(AGraphicClass: TGraphicClass;
|
|
AWidth: Integer = 0; AHeight: Integer = 0): TGraphic;
|
|
|
|
procedure DrawImage(AImageCanvas: TCanvas);
|
|
var
|
|
AViewInfo: TcxCustomGridViewInfo;
|
|
ACanvas: TcxCanvas;
|
|
begin
|
|
AViewInfo := CreateViewInfo;
|
|
try
|
|
AViewInfo.IsInternalUse := True;
|
|
(AViewInfo as TcxGridChartViewInfo).IsImage := True;
|
|
AViewInfo.MainCalculate(Rect(0, 0, AWidth, AHeight));
|
|
ACanvas := TcxCanvas.Create(AImageCanvas);
|
|
try
|
|
Painter.Paint(ACanvas, AViewInfo);
|
|
finally
|
|
ACanvas.Free;
|
|
end;
|
|
finally
|
|
AViewInfo.Free;
|
|
end;
|
|
end;
|
|
|
|
var
|
|
AMetaFileCanvas: TMetaFileCanvas;
|
|
begin
|
|
if IsPattern or
|
|
not (AGraphicClass.InheritsFrom(TMetafile) or AGraphicClass.InheritsFrom(TBitmap)) then
|
|
begin
|
|
Result := nil;
|
|
Exit;
|
|
end;
|
|
CalculateImageWidth(AWidth);
|
|
CalculateImageHeight(AHeight);
|
|
Result := {$IFNDEF DELPHI6}TGraphicAccessClass{$ENDIF}(AGraphicClass).Create;
|
|
Result.Width := AWidth;
|
|
Result.Height := AHeight;
|
|
if Result is TMetaFile then
|
|
begin
|
|
Result.Transparent := True;
|
|
AMetaFileCanvas := TMetaFileCanvas.Create(TMetaFile(Result), 0);
|
|
try
|
|
DrawImage(AMetaFileCanvas);
|
|
finally
|
|
AMetaFileCanvas.Free;
|
|
end;
|
|
end
|
|
else
|
|
DrawImage(TBitmap(Result).Canvas);
|
|
end;
|
|
|
|
function TcxGridChartView.FindDiagramByDisplayText(const ADisplayText: string): TcxGridChartDiagram;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to DiagramCount - 1 do
|
|
begin
|
|
Result := Diagrams[I];
|
|
if Result.DisplayText = ADisplayText then Exit;
|
|
end;
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxGridChartView.FindDiagramByID(const AID: string): TcxGridChartDiagram;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to DiagramCount - 1 do
|
|
begin
|
|
Result := Diagrams[I];
|
|
if Result.ID = AID then Exit;
|
|
end;
|
|
Result := nil;
|
|
end;
|
|
|
|
procedure TcxGridChartView.ClearSeries;
|
|
begin
|
|
ClearItems(GetSeriesClass);
|
|
end;
|
|
|
|
function TcxGridChartView.CreateSeries: TcxGridChartSeries;
|
|
begin
|
|
Result := TcxGridChartSeries(CreateItem(GetSeriesClass));
|
|
end;
|
|
|
|
function TcxGridChartView.FindSeriesByID(AID: Integer): TcxGridChartSeries;
|
|
begin
|
|
Result := TcxGridChartSeries(FindItemByID(GetSeriesClass, AID));
|
|
end;
|
|
|
|
function TcxGridChartView.FindSeriesByName(const AName: string): TcxGridChartSeries;
|
|
begin
|
|
Result := TcxGridChartSeries(FindItemByName(GetSeriesClass, AName));
|
|
end;
|
|
|
|
function TcxGridChartView.FindSeriesByTag(ATag: TcxTag): TcxGridChartSeries;
|
|
begin
|
|
Result := TcxGridChartSeries(FindItemByTag(GetSeriesClass, ATag));
|
|
end;
|
|
|
|
function TcxGridChartView.GetSeriesClass: TcxGridChartSeriesClass;
|
|
begin
|
|
Result := TcxGridChartSeries;
|
|
end;
|
|
|
|
procedure TcxGridChartView.ClearDataGroups;
|
|
begin
|
|
ClearItems(GetDataGroupClass);
|
|
end;
|
|
|
|
function TcxGridChartView.CreateDataGroup: TcxGridChartDataGroup;
|
|
begin
|
|
Result := TcxGridChartDataGroup(CreateItem(GetDataGroupClass));
|
|
end;
|
|
|
|
function TcxGridChartView.FindDataGroupByID(AID: Integer): TcxGridChartDataGroup;
|
|
begin
|
|
Result := TcxGridChartDataGroup(FindItemByID(GetDataGroupClass, AID));
|
|
end;
|
|
|
|
function TcxGridChartView.FindDataGroupByName(const AName: string): TcxGridChartDataGroup;
|
|
begin
|
|
Result := TcxGridChartDataGroup(FindItemByName(GetDataGroupClass, AName));
|
|
end;
|
|
|
|
function TcxGridChartView.FindDataGroupByTag(ATag: TcxTag): TcxGridChartDataGroup;
|
|
begin
|
|
Result := TcxGridChartDataGroup(FindItemByTag(GetDataGroupClass, ATag));
|
|
end;
|
|
|
|
function TcxGridChartView.GetDataGroupClass: TcxGridChartDataGroupClass;
|
|
begin
|
|
Result := TcxGridChartDataGroup;
|
|
end;
|
|
|
|
function TcxGridChartView.CanActivateDataLevel(ALevel: Integer): Boolean;
|
|
begin
|
|
Result := GetAvailableDataLevel(ALevel) = ALevel;
|
|
end;
|
|
|
|
initialization
|
|
cxGridRegisteredViews.Register(TcxGridChartView, 'Chart');
|
|
Classes.RegisterClasses([TcxGridChartDataGroup, TcxGridChartSeries]);
|
|
|
|
cxGridChartDiagramImages := TImageList.Create(nil);
|
|
cxGridChartDiagramImages_Add('CXGRIDCHARTAREADIAGRAMBITMAP');
|
|
cxGridChartDiagramImages_Add('CXGRIDCHARTBARDIAGRAMBITMAP');
|
|
cxGridChartDiagramImages_Add('CXGRIDCHARTCOLUMNDIAGRAMBITMAP');
|
|
cxGridChartDiagramImages_Add('CXGRIDCHARTLINEDIAGRAMBITMAP');
|
|
cxGridChartDiagramImages_Add('CXGRIDCHARTPIEDIAGRAMBITMAP');
|
|
|
|
Screen.Cursors[crcxGridMagnifier] := LoadCursor(HInstance, 'CXGRIDCHARTMAGNIFIERCURSOR');
|
|
Screen.Cursors[crcxGridDrag] := LoadCursor(HInstance, 'CXGRIDCHARTDRAGCURSOR');
|
|
|
|
finalization
|
|
FreeAndNil(cxGridChartDiagramImages);
|
|
|
|
cxGridRegisteredViews.Unregister(TcxGridChartView);
|
|
|
|
end.
|