roberto
f040ff20cd
git-svn-id: https://192.168.0.254/svn/Componentes.Terceros.DevExpressVCL@63 05c56307-c608-d34a-929d-697000501d7a
8408 lines
246 KiB
ObjectPascal
8408 lines
246 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 cxGridCustomView;
|
|
|
|
{$I cxVer.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
Windows, Messages, Classes, Graphics, Controls, Forms, StdCtrls, Menus,
|
|
cxClasses, cxControls, cxContainer, cxGraphics, cxLookAndFeels, cxLookAndFeelPainters,
|
|
cxStyles, cxStorage, cxGridCommon, cxCustomData, cxData, cxListBox, cxPC;
|
|
|
|
const
|
|
cxGridCustomizationFormDefaultWidth = 180;
|
|
cxGridCustomizationFormDefaultHeight = 300;
|
|
|
|
htError = -1;
|
|
htNone = 0;
|
|
htNavigator = 1;
|
|
htCustomizationForm = 2;
|
|
htDesignSelector = 3;
|
|
|
|
ckNone = 0;
|
|
ckCustomizationForm = 1;
|
|
|
|
bbCustomFirst = 0;
|
|
bbBackground = bbCustomFirst;
|
|
bbCustomLast = bbBackground;
|
|
|
|
vsCustomFirst = 0;
|
|
vsBackground = vsCustomFirst;
|
|
vsCustomLast = vsBackground;
|
|
|
|
StoringVersion = 1;
|
|
|
|
type
|
|
TcxCustomGridDragAndDropObjectClass = class of TcxCustomGridDragAndDropObject;
|
|
TcxCustomGridItemsListBox = class;
|
|
TcxCustomGridCustomizationForm = class;
|
|
TcxGridPopupListBox = class;
|
|
TcxCustomGridController = class;
|
|
TcxCustomGridPainter = class;
|
|
TcxCustomGridViewData = class;
|
|
TcxCustomGridCellViewInfo = class;
|
|
TcxCustomGridViewCellViewInfo = class;
|
|
TcxGridDesignSelectorViewInfo = class;
|
|
TcxCustomGridViewInfo = class;
|
|
TcxCustomGridViewInfoCache = class;
|
|
TcxGridSite = class;
|
|
TcxCustomGridView = class;
|
|
|
|
IcxGridViewLayoutEditorSupport = interface // it is here because of problem in CBuilder
|
|
['{9C5EC9C0-A912-4822-BBD0-87AB45FDCC78}']
|
|
procedure BeforeEditLayout(ALayoutView: TcxCustomGridView);
|
|
procedure DoAssignLayout(ALayoutView: TcxCustomGridView);
|
|
function GetLayoutCustomizationFormButtonCaption: string;
|
|
function HasLayoutCustomizationForm: Boolean;
|
|
function IsLayoutChangeable: Boolean;
|
|
procedure RunLayoutCustomizationForm;
|
|
end;
|
|
|
|
{ change }
|
|
|
|
TcxCustomGridViewChange = class(TcxCustomGridChange)
|
|
private
|
|
FGridView: TcxCustomGridView;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); virtual;
|
|
property GridView: TcxCustomGridView read FGridView write FGridView;
|
|
function IsEqual(AChange: TcxCustomGridChange): Boolean; override;
|
|
end;
|
|
|
|
TcxGridControlFocusChange = class(TcxCustomGridViewChange)
|
|
public
|
|
procedure Execute; override;
|
|
end;
|
|
|
|
{ hit tests }
|
|
|
|
TcxCustomGridHitTestClass = class of TcxCustomGridHitTest;
|
|
|
|
TcxCustomGridHitTest = class
|
|
private
|
|
FPos: TPoint;
|
|
FViewInfo: TcxCustomGridCellViewInfo;
|
|
procedure SetViewInfo(Value: TcxCustomGridCellViewInfo);
|
|
protected
|
|
class function GetHitTestCode: Integer; virtual;
|
|
procedure Init(const APos: TPoint);
|
|
public
|
|
destructor Destroy; override;
|
|
function Cursor: TCursor; virtual;
|
|
function DragAndDropObjectClass: TcxCustomGridDragAndDropObjectClass; virtual;
|
|
class function HitTestCode: Integer;
|
|
class function Instance(const APos: TPoint): TcxCustomGridHitTest;
|
|
property Pos: TPoint read FPos;
|
|
property ViewInfo: TcxCustomGridCellViewInfo read FViewInfo write SetViewInfo;
|
|
end;
|
|
|
|
TcxGridNoneHitTest = class(TcxCustomGridHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
end;
|
|
|
|
TcxCustomGridViewHitTest = class(TcxCustomGridHitTest)
|
|
private
|
|
FGridView: TcxCustomGridView;
|
|
public
|
|
property GridView: TcxCustomGridView read FGridView write FGridView;
|
|
end;
|
|
|
|
TcxGridViewNoneHitTest = class(TcxCustomGridViewHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
end;
|
|
|
|
TcxGridNavigatorHitTest = class(TcxCustomGridViewHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
end;
|
|
|
|
TcxGridCustomizationFormHitTest = class(TcxCustomGridViewHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
end;
|
|
|
|
TcxGridDesignSelectorHitTest = class(TcxCustomGridViewHitTest)
|
|
protected
|
|
class function GetHitTestCode: Integer; override;
|
|
public
|
|
function Cursor: TCursor; override;
|
|
end;
|
|
|
|
{ custom handler }
|
|
|
|
TcxGridViewHandler = class(TcxInterfacedPersistent)
|
|
private
|
|
FGridView: TcxCustomGridView;
|
|
function GetControl: TcxControl;
|
|
function GetController: TcxCustomGridController;
|
|
function GetDataController: TcxCustomDataController;
|
|
function GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
|
|
function GetPainter: TcxCustomGridPainter;
|
|
function GetSite: TcxGridSite;
|
|
function GetViewData: TcxCustomGridViewData;
|
|
function GetViewInfo: TcxCustomGridViewInfo;
|
|
protected
|
|
property Control: TcxControl read GetControl;
|
|
property Controller: TcxCustomGridController read GetController;
|
|
property DataController: TcxCustomDataController read GetDataController;
|
|
property ViewData: TcxCustomGridViewData read GetViewData;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); reintroduce; virtual;
|
|
procedure BeginUpdate;
|
|
procedure EndUpdate;
|
|
property GridView: TcxCustomGridView read FGridView;
|
|
property LookAndFeelPainter: TcxCustomLookAndFeelPainterClass read GetLookAndFeelPainter;
|
|
property Painter: TcxCustomGridPainter read GetPainter;
|
|
property Site: TcxGridSite read GetSite;
|
|
property ViewInfo: TcxCustomGridViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
{ contoller }
|
|
|
|
// drag&drop objects
|
|
|
|
TcxCustomGridDragAndDropObject = class(TcxDragAndDropObject)
|
|
private
|
|
function GetController: TcxCustomGridController;
|
|
function GetGridView: TcxCustomGridView;
|
|
function GetViewInfo: TcxCustomGridViewInfo;
|
|
protected
|
|
procedure AfterDragAndDrop(Accepted: Boolean); override;
|
|
procedure AfterPaint; virtual;
|
|
procedure BeforePaint; virtual;
|
|
property Controller: TcxCustomGridController read GetController;
|
|
property ViewInfo: TcxCustomGridViewInfo read GetViewInfo;
|
|
public
|
|
SourcePoint: TPoint;
|
|
procedure AfterScrolling; virtual;
|
|
procedure BeforeScrolling; virtual;
|
|
procedure AfterViewChange; virtual;
|
|
procedure BeforeViewChange; virtual;
|
|
procedure Init(const P: TPoint; AParams: TcxCustomGridHitTest); virtual;
|
|
property GridView: TcxCustomGridView read GetGridView;
|
|
end;
|
|
|
|
TcxGridArrowNumber = (anFirst, anLast);
|
|
TcxGridArrowPlace = TcxArrowPlace;
|
|
|
|
TcxCustomGridMovingObject = class(TcxCustomGridDragAndDropObject)
|
|
private
|
|
FDragImage: TcxDragImage;
|
|
FSourceItem: TObject;
|
|
function GetArrowPlace(AArrowNumber: TcxGridArrowNumber): TcxGridArrowPlace;
|
|
function GetCustomizationForm: TcxCustomGridCustomizationForm;
|
|
protected
|
|
Arrows: array[TcxGridArrowNumber] of TcxDragAndDropArrow;
|
|
|
|
procedure DirtyChanged; override;
|
|
function GetDragAndDropCursor(Accepted: Boolean): TCursor; override;
|
|
|
|
procedure ChangeArrowsPosition(AVisible: Boolean = True);
|
|
procedure ChangeDragImagePosition(AVisible: Boolean = True);
|
|
|
|
function AreArrowsVertical: Boolean; virtual;
|
|
function CanRemove: Boolean; virtual; abstract;
|
|
function GetArrowAreaBounds(APlace: TcxGridArrowPlace): TRect; virtual; abstract;
|
|
function GetArrowClass: TcxDragAndDropArrowClass; virtual;
|
|
function GetArrowsClientRect: TRect; virtual;
|
|
function GetCustomizationFormListBox: TcxCustomGridItemsListBox; virtual; abstract;
|
|
function GetDragImageClass: TcxDragImageClass; virtual;
|
|
function GetSourceItemBounds: TRect; virtual;
|
|
function GetSourceItemViewInfo: TcxCustomGridCellViewInfo; virtual;
|
|
procedure InitDragImage; virtual;
|
|
procedure InitDragImageUsingCustomizationForm(ACanvas: TcxCanvas;
|
|
const R: TRect; AItem: TObject); virtual;
|
|
function IsSourceCustomizationForm: Boolean; virtual; abstract;
|
|
function IsValidDestination: Boolean; virtual; abstract;
|
|
|
|
procedure BeginDragAndDrop; override;
|
|
procedure DragAndDrop(const P: TPoint; var Accepted: Boolean); override;
|
|
procedure EndDragAndDrop(Accepted: Boolean); override;
|
|
|
|
property ArrowPlaces[AArrowNumber: TcxGridArrowNumber]: TcxGridArrowPlace read GetArrowPlace;
|
|
property ArrowsClientRect: TRect read GetArrowsClientRect;
|
|
property CustomizationForm: TcxCustomGridCustomizationForm read GetCustomizationForm;
|
|
property CustomizationFormListBox: TcxCustomGridItemsListBox read GetCustomizationFormListBox;
|
|
property DragImage: TcxDragImage read FDragImage;
|
|
property SourceItem: TObject read FSourceItem write FSourceItem;
|
|
property SourceItemBounds: TRect read GetSourceItemBounds;
|
|
property SourceItemViewInfo: TcxCustomGridCellViewInfo read GetSourceItemViewInfo;
|
|
public
|
|
procedure AfterScrolling; override;
|
|
end;
|
|
|
|
// customization form
|
|
|
|
TcxCustomGridItemsInnerListBox = class(TcxInnerListBox)
|
|
private
|
|
FDragAndDropItemIndex: Integer;
|
|
FMouseDownPos: TPoint;
|
|
function GetContainer: TcxCustomGridItemsListBox;
|
|
function GetDragAndDropItem: TObject;
|
|
function GetGridView: TcxCustomGridView;
|
|
function GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
|
|
procedure WMCancelMode(var Message: TWMCancelMode); message WM_CANCELMODE;
|
|
procedure WMNCCalcSize(var Message: TWMNCCalcSize); message WM_NCCALCSIZE;
|
|
procedure WMNCPaint(var Message: TWMNCPaint); message WM_NCPAINT;
|
|
protected
|
|
procedure CreateParams(var Params: TCreateParams); override;
|
|
procedure CreateWnd; override;
|
|
procedure DrawItem(Index: Integer; Rect: TRect; State: TOwnerDrawState); override;
|
|
procedure KeyDown(var Key: Word; Shift: TShiftState); override;
|
|
procedure LookAndFeelChanged(Sender: TcxLookAndFeel;
|
|
AChangedValues: TcxLookAndFeelValues); override;
|
|
procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
|
|
procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;
|
|
procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
|
|
|
|
procedure CalculateBorderStyle;
|
|
procedure CalculateItemHeight;
|
|
|
|
property Container: TcxCustomGridItemsListBox read GetContainer;
|
|
property DragAndDropItem: TObject read GetDragAndDropItem;
|
|
property DragAndDropItemIndex: Integer read FDragAndDropItemIndex;
|
|
property GridView: TcxCustomGridView read GetGridView;
|
|
property LookAndFeelPainter: TcxCustomLookAndFeelPainterClass read GetLookAndFeelPainter;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
end;
|
|
|
|
TcxCustomGridItemsListBoxClass = class of TcxCustomGridItemsListBox;
|
|
|
|
TcxCustomGridItemsListBox = class(TcxListBox)
|
|
private
|
|
function GetDragAndDropItem: TObject;
|
|
function GetGridView: TcxCustomGridView;
|
|
function GetInnerListBox: TcxCustomGridItemsInnerListBox;
|
|
protected
|
|
function CalculateItemHeight: Integer; virtual; abstract;
|
|
procedure DoRefreshItems; virtual; abstract;
|
|
function GetInnerListBoxClass: TcxInnerListBoxClass; override;
|
|
function GetDragAndDropParams: TcxCustomGridHitTest; virtual; abstract;
|
|
property DragAndDropItem: TObject read GetDragAndDropItem;
|
|
property GridView: TcxCustomGridView read GetGridView;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
function IndexOfItem(AItem: TObject): Integer;
|
|
procedure PaintDragAndDropItem(ACanvas: TcxCanvas; const R: TRect; AItem: TObject);
|
|
procedure PaintItem(ACanvas: TcxCanvas; R: TRect; AIndex: Integer; AFocused: Boolean); virtual; abstract;
|
|
procedure RefreshItems;
|
|
property InnerListBox: TcxCustomGridItemsInnerListBox read GetInnerListBox;
|
|
end;
|
|
|
|
TcxCustomGridCustomizationFormClass = class of TcxCustomGridCustomizationForm;
|
|
|
|
TcxCustomGridCustomizationForm = class(TForm)
|
|
private
|
|
FController: TcxCustomGridController;
|
|
FHookTimer: TcxTimer;
|
|
FOffset: Integer;
|
|
FPageControl: TcxPageControl;
|
|
function GetGridView: TcxCustomGridView;
|
|
function GetViewInfo: TcxCustomGridViewInfo;
|
|
procedure HookTimerHandler(Sender: TObject);
|
|
protected
|
|
procedure CreateParams(var Params: TCreateParams); override;
|
|
procedure DoClose(var Action: TCloseAction); override;
|
|
procedure DoShow; override;
|
|
|
|
procedure CalculateConsts; virtual;
|
|
procedure CreateControls; virtual;
|
|
function CreatePage(const ACaption: string; AVisible: Boolean): TcxTabSheet;
|
|
procedure GridViewChanged; virtual;
|
|
|
|
function GetContentBounds: TRect; virtual;
|
|
function GetPageControlBounds: TRect; virtual;
|
|
procedure InitPageControl; virtual;
|
|
|
|
property ContentBounds: TRect read GetContentBounds;
|
|
property GridView: TcxCustomGridView read GetGridView;
|
|
property Offset: Integer read FOffset write FOffset;
|
|
property PageControl: TcxPageControl read FPageControl;
|
|
property ViewInfo: TcxCustomGridViewInfo read GetViewInfo;
|
|
public
|
|
constructor Create(AController: TcxCustomGridController); reintroduce; virtual;
|
|
destructor Destroy; override;
|
|
property Controller: TcxCustomGridController read FController;
|
|
procedure ActivatePage(APage: TcxTabSheet);
|
|
procedure RefreshData; virtual;
|
|
end;
|
|
|
|
// popup
|
|
|
|
(*$HPPEMIT 'namespace Cxgridcustomview'}*)
|
|
(*$HPPEMIT '{'}*)
|
|
(*$HPPEMIT '__interface IcxCustomGridPopupOwner;'}*)
|
|
(*$HPPEMIT '}'*)
|
|
|
|
IcxCustomGridPopupOwner = interface
|
|
['{ACF62D23-6871-4735-A4CE-3B0888DB8FC3}']
|
|
function ClosePopupWhenNilOwner: Boolean;
|
|
function GetOwnerBounds: TRect;
|
|
procedure PopupClosed;
|
|
end;
|
|
|
|
TcxCustomGridPopup = class(TcxCustomPopupWindow)
|
|
private
|
|
FGridView: TcxCustomGridView;
|
|
FOwner: IcxCustomGridPopupOwner;
|
|
procedure SetOwner(Value: IcxCustomGridPopupOwner);
|
|
protected
|
|
function CalculateOwnerBounds: TRect; virtual;
|
|
function GetClientMinWidth: Integer; virtual;
|
|
procedure InitPopup; override;
|
|
procedure Paint; override;
|
|
procedure VisibleChanged; override;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); reintroduce; virtual;
|
|
procedure CloseUp; override;
|
|
procedure Popup; reintroduce; virtual;
|
|
property BorderWidths;
|
|
property GridView: TcxCustomGridView read FGridView;
|
|
property ClientMinWidth: Integer read GetClientMinWidth;
|
|
property Owner: IcxCustomGridPopupOwner read FOwner write SetOwner;
|
|
end;
|
|
|
|
TcxGridIndexes = array of Integer;
|
|
|
|
TcxGridPopupListBoxActionEvent = procedure(Sender: TcxGridPopupListBox;
|
|
AItemIndex: Integer) of object;
|
|
|
|
TcxGridPopupListBox = class(TcxListBox)
|
|
private
|
|
FCheckedIndexes: TList;
|
|
FItemTextOffsetLeft: Integer;
|
|
FItemTextOffsetRight: Integer;
|
|
FItemTextOffsetVert: Integer;
|
|
FMinWidth: Integer;
|
|
FPopup: TcxCustomGridPopup;
|
|
FPressedItemIndex: Integer;
|
|
FShowChecks: Boolean;
|
|
FVisibleItemCount: Integer;
|
|
FVisibleWidth: Integer;
|
|
FOnAction: TcxGridPopupListBoxActionEvent;
|
|
function GetChecked(Index: Integer): Boolean;
|
|
function GetCheckedIndexes: TcxGridIndexes;
|
|
function GetGridView: TcxCustomGridView;
|
|
procedure SetChecked(Index: Integer; Value: Boolean);
|
|
procedure SetCheckedIndexes(const Value: TcxGridIndexes);
|
|
procedure SetPressedItemIndex(Value: Integer);
|
|
procedure SetShowChecks(Value: Boolean);
|
|
protected
|
|
function DrawItem(ACanvas: TcxCanvas; AIndex: Integer; const ARect: TRect;
|
|
AState: TOwnerDrawState): Boolean; override;
|
|
procedure KeyDown(var Key: Word; Shift: TShiftState); override;
|
|
procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
|
|
procedure MouseLeave(AControl: TControl); override;
|
|
procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;
|
|
procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
|
|
|
|
function CalculateItemHeight: Integer; virtual;
|
|
procedure DoAction(AItemIndex: Integer); virtual;
|
|
procedure DrawItemCheck(ACanvas: TcxCanvas; AIndex: Integer;
|
|
const ACheckAreaRect: TRect; AState: TOwnerDrawState); virtual;
|
|
procedure DrawItemContent(ACanvas: TcxCanvas; AIndex: Integer; ARect: TRect;
|
|
AState: TOwnerDrawState); virtual;
|
|
function GetVisibleItemCount(AItems: TStrings): Integer; virtual;
|
|
procedure Init; virtual;
|
|
procedure InvalidateItem(AIndex: Integer);
|
|
|
|
function CanHaveCheck(AItemIndex: Integer): Boolean; virtual;
|
|
procedure ChangeChecked(AItemIndex: Integer); virtual;
|
|
function GetCheckAreaHeight: Integer;
|
|
function GetCheckAreaWidth: Integer;
|
|
function HasCheck(AItemIndex: Integer): Boolean; virtual;
|
|
function IsCheck(AItemIndex: Integer): Boolean;
|
|
property Checked[Index: Integer]: Boolean read GetChecked write SetChecked;
|
|
property CheckedIndexes: TcxGridIndexes read GetCheckedIndexes write SetCheckedIndexes;
|
|
property PressedItemIndex: Integer read FPressedItemIndex write SetPressedItemIndex;
|
|
property ShowChecks: Boolean read FShowChecks write SetShowChecks;
|
|
public
|
|
constructor Create(APopup: TcxCustomGridPopup); reintroduce; virtual;
|
|
destructor Destroy; override;
|
|
procedure AdjustBounds(AItems: TStrings = nil); virtual;
|
|
|
|
property GridView: TcxCustomGridView read GetGridView;
|
|
property ItemTextOffsetLeft: Integer read FItemTextOffsetLeft write FItemTextOffsetLeft;
|
|
property ItemTextOffsetRight: Integer read FItemTextOffsetRight write FItemTextOffsetRight;
|
|
property ItemTextOffsetVert: Integer read FItemTextOffsetVert write FItemTextOffsetVert;
|
|
property MinWidth: Integer read FMinWidth write FMinWidth;
|
|
property Popup: TcxCustomGridPopup read FPopup;
|
|
property VisibleItemCount: Integer read FVisibleItemCount write FVisibleItemCount;
|
|
property VisibleWidth: Integer read FVisibleWidth write FVisibleWidth;
|
|
property OnAction: TcxGridPopupListBoxActionEvent read FOnAction write FOnAction;
|
|
end;
|
|
|
|
// controllers
|
|
|
|
TcxCustomGridDesignController = class
|
|
protected
|
|
function GetControl: TcxControl; virtual; abstract;
|
|
function GetDesignObject(AObject: TPersistent): TPersistent; virtual;
|
|
public
|
|
function IsObjectSelected(AObject: TPersistent): Boolean;
|
|
procedure SelectObject(AObject: TPersistent; AClearSelection: Boolean);
|
|
procedure SelectObjects(AObjects: TList);
|
|
procedure UnselectObject(AObject: TPersistent);
|
|
property Control: TcxControl read GetControl; // TcxCustomGrid
|
|
end;
|
|
|
|
TcxGridViewDesignControllerClass = class of TcxGridViewDesignController;
|
|
|
|
TcxGridViewDesignController = class(TcxCustomGridDesignController)
|
|
private
|
|
FController: TcxCustomGridController;
|
|
protected
|
|
function GetControl: TcxControl; override;
|
|
function GetDesignObject(AObject: TPersistent): TPersistent; override;
|
|
public
|
|
constructor Create(AController: TcxCustomGridController); virtual;
|
|
property Controller: TcxCustomGridController read FController;
|
|
end;
|
|
|
|
TcxCustomGridControllerClass = class of TcxCustomGridController;
|
|
|
|
TcxCustomGridController = class(TcxGridViewHandler, IcxMouseTrackingCaller,
|
|
IcxMouseTrackingCaller2)
|
|
private
|
|
FCustomization: Boolean;
|
|
FCustomizationForm: TcxCustomGridCustomizationForm;
|
|
FCustomizationFormBounds: TRect;
|
|
FDesignController: TcxGridViewDesignController;
|
|
FHintAreaBounds: TRect;
|
|
FHintCellViewInfo: TcxCustomGridViewCellViewInfo;
|
|
FHintCheckerTimer: TcxTimer;
|
|
FHintTextRect: TRect;
|
|
FHintWindow: THintWindow;
|
|
FIsCheckingCoordinates: Boolean;
|
|
FIsDblClick: Boolean;
|
|
FIsFocusing: Boolean;
|
|
function GetDesignController: TcxGridViewDesignController;
|
|
function GetDragAndDropObject: TcxCustomGridDragAndDropObject;
|
|
function GetDragAndDropObjectClass: TcxDragAndDropObjectClass;
|
|
function GetDragImages: TcxDragImageList;
|
|
function GetIsDragging: Boolean;
|
|
function GetMouseCaptureViewInfo: TcxCustomGridCellViewInfo;
|
|
procedure SetCustomization(Value: Boolean);
|
|
procedure SetDragAndDropObjectClass(Value: TcxDragAndDropObjectClass);
|
|
procedure SetMouseCaptureViewInfo(Value: TcxCustomGridCellViewInfo);
|
|
procedure HintCheckerTimerHandler(Sender: TObject);
|
|
protected
|
|
{ IcxMouseTrackingCaller2 }
|
|
procedure MouseLeave; virtual;
|
|
function PtInCaller(const P: TPoint): Boolean; virtual;
|
|
|
|
procedure AfterPaint; virtual;
|
|
procedure BeforeKillFocus; virtual;
|
|
procedure BeforePaint; virtual;
|
|
function CanFocusOnClick(X, Y: Integer): Boolean; virtual;
|
|
function CanHandleHitTest(AHitTest: TcxCustomGridHitTest): Boolean; virtual;
|
|
procedure CheckCoordinates; virtual;
|
|
procedure DetailFocused(ADetail: TcxCustomGridView); virtual;
|
|
procedure DoEnter; virtual;
|
|
procedure DoExit; virtual;
|
|
procedure DoSetFocus(ANotifyMaster: Boolean); virtual;
|
|
function GetDesignControllerClass: TcxGridViewDesignControllerClass; virtual;
|
|
function GetDesignHitTest(AHitTest: TcxCustomGridHitTest): Boolean; virtual;
|
|
function GetMouseWheelScrollingKind: TcxMouseWheelScrollingKind; virtual;
|
|
function GetPatternObject(AObject: TPersistent): TPersistent; virtual;
|
|
procedure GridViewChanged; virtual;
|
|
function IsPixelScrollBar(AKind: TScrollBarKind): Boolean; virtual;
|
|
function MayFocus: Boolean; virtual;
|
|
procedure RemoveFocus; virtual;
|
|
procedure SetFocus(ANotifyMaster: Boolean); virtual;
|
|
procedure VisibilityChanged(AVisible: Boolean); virtual;
|
|
|
|
// customization
|
|
procedure CheckCustomizationFormBounds(var R: TRect); virtual;
|
|
procedure CustomizationChanged; virtual;
|
|
function GetCustomizationFormBounds: TRect;
|
|
function GetCustomizationFormClass: TcxCustomGridCustomizationFormClass; virtual;
|
|
function GetCustomizationFormDefaultWidth: Integer; virtual;
|
|
function GetCustomizationFormDefaultHeight: Integer; virtual;
|
|
procedure HideCustomizationForm;
|
|
procedure ShowCustomizationForm;
|
|
|
|
property DragAndDropObject: TcxCustomGridDragAndDropObject read GetDragAndDropObject;
|
|
property IsCheckingCoordinates: Boolean read FIsCheckingCoordinates;
|
|
property IsDragging: Boolean read GetIsDragging;
|
|
property IsFocusing: Boolean read FIsFocusing;
|
|
public
|
|
destructor Destroy; override;
|
|
procedure ControlFocusChanged; virtual;
|
|
procedure DesignerModified;
|
|
procedure DoCancelMode; virtual;
|
|
procedure DoCheckCoordinates;
|
|
procedure DoControlFocusChanged;
|
|
function GetCursor(X, Y: Integer): TCursor; virtual;
|
|
function HasFocusedControls: Boolean; virtual;
|
|
//function CanDrag(X, Y: Integer): Boolean; dynamic;
|
|
//function GetDragObjectClass: TDragControlObjectClass; dynamic;
|
|
|
|
procedure InitScrollBarsParameters; virtual;
|
|
function IsDataFullyVisible(AIsCallFromMaster: Boolean = False): Boolean; virtual;
|
|
procedure Scroll(AScrollBarKind: TScrollBarKind; AScrollCode: TScrollCode;
|
|
var AScrollPos: Integer); virtual;
|
|
procedure SetScrollBarInfo(AScrollBarKind: TScrollBarKind;
|
|
AMin, AMax, AStep, APage, APos: Integer; AAllowShow, AAllowHide: Boolean);
|
|
procedure UpdateScrollBars(AIgnoreUpdateLock: Boolean = False);
|
|
|
|
procedure BeginDragAndDrop; virtual;
|
|
procedure DragAndDrop(const P: TPoint; var Accepted: Boolean); virtual;
|
|
procedure EndDragAndDrop(Accepted: Boolean); virtual;
|
|
function StartDragAndDrop(const P: TPoint): Boolean; virtual;
|
|
|
|
// delphi drag and drop
|
|
procedure BeforeStartDrag; virtual;
|
|
function CanDrag(X, Y: Integer): Boolean; virtual;
|
|
procedure DragDrop(Source: TObject; X, Y: Integer); virtual;
|
|
procedure DragOver(Source: TObject; X, Y: Integer; State: TDragState;
|
|
var Accept: Boolean); virtual;
|
|
procedure DrawDragImage(ACanvas: TcxCanvas; R: TRect); virtual;
|
|
procedure EndDrag(Target: TObject; X, Y: Integer); virtual;
|
|
function GetDragImagesSize: TPoint; virtual;
|
|
function HasDragImages: Boolean; virtual;
|
|
procedure StartDrag(var DragObject: TDragObject); virtual;
|
|
property DragImages: TcxDragImageList read GetDragImages;
|
|
|
|
// hints
|
|
function CanShowHint: Boolean; virtual;
|
|
procedure HideHint;
|
|
function GetHintWindowClass: THintWindowClass; virtual;
|
|
procedure ShowHint(const AHintAreaBounds, ATextRect: TRect; const AText: string;
|
|
AIsHintMultiLine: Boolean; AFont: TFont; AHintCellViewInfo: TcxCustomGridViewCellViewInfo);
|
|
procedure StartHintCheckerTimer;
|
|
procedure StopHintCheckerTimer;
|
|
property HintCellViewInfo: TcxCustomGridViewCellViewInfo read FHintCellViewInfo;
|
|
property HintWindow: THintWindow read FHintWindow;
|
|
|
|
procedure DoKeyDown(var Key: Word; Shift: TShiftState); virtual;
|
|
procedure KeyDown(var Key: Word; Shift: TShiftState); virtual;
|
|
procedure KeyPress(var Key: Char); virtual;
|
|
procedure KeyUp(var Key: Word; Shift: TShiftState); virtual;
|
|
|
|
procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); virtual;
|
|
procedure MouseMove(Shift: TShiftState; X, Y: Integer); virtual;
|
|
procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); virtual;
|
|
|
|
function ProcessDetailDialogChar(ADetail: TcxCustomGridView; ACharCode: Word): Boolean; virtual;
|
|
function ProcessDialogChar(ACharCode: Word): Boolean; virtual;
|
|
|
|
procedure WndProc(var Message: TMessage); virtual;
|
|
|
|
procedure RefreshCustomizationForm;
|
|
|
|
{procedure BeginCellMouseTracking(AViewInfo: TcxCustomGridCellViewInfo);
|
|
procedure EndCellMouseTracking(AViewInfo: TcxCustomGridCellViewInfo);}
|
|
|
|
property Customization: Boolean read FCustomization write SetCustomization;
|
|
property CustomizationForm: TcxCustomGridCustomizationForm read FCustomizationForm;
|
|
property CustomizationFormBounds: TRect read FCustomizationFormBounds
|
|
write FCustomizationFormBounds;
|
|
property DesignController: TcxGridViewDesignController read GetDesignController;
|
|
property DragAndDropObjectClass: TcxDragAndDropObjectClass read GetDragAndDropObjectClass
|
|
write SetDragAndDropObjectClass;
|
|
property IsDblClick: Boolean read FIsDblClick;
|
|
property MouseCaptureViewInfo: TcxCustomGridCellViewInfo read GetMouseCaptureViewInfo
|
|
write SetMouseCaptureViewInfo;
|
|
end;
|
|
|
|
{ datacontroller }
|
|
|
|
// sorting by summary
|
|
|
|
TcxDataGroupNode = class
|
|
private
|
|
FChilds: TList;
|
|
FDataGroupInfo: TcxDataGroupInfo;
|
|
FParent: TcxDataGroupNode;
|
|
function GetChild(Index: Integer): TcxDataGroupNode;
|
|
function GetChildCount: Integer;
|
|
public
|
|
constructor Create(AParent: TcxDataGroupNode; ADataGroupInfo: TcxDataGroupInfo);
|
|
destructor Destroy; override;
|
|
function AddChild(ADataGroupInfo: TcxDataGroupInfo): TcxDataGroupNode;
|
|
|
|
property ChildCount: Integer read GetChildCount;
|
|
property Childs[Index: Integer]: TcxDataGroupNode read GetChild; default;
|
|
property DataGroupInfo: TcxDataGroupInfo read FDataGroupInfo;
|
|
property Parent: TcxDataGroupNode read FParent;
|
|
end;
|
|
|
|
TcxSortingBySummaryInfo = class
|
|
SortOrder: TcxDataSortOrder;
|
|
SummaryItemIndex: Integer;
|
|
end;
|
|
|
|
TcxGridSortingBySummaryEngine = class(TcxSortingBySummaryEngine)
|
|
private
|
|
FInfos: TList;
|
|
FRootNode: TcxDataGroupNode;
|
|
function GetDataGroups: TcxDataGroups;
|
|
function GetInfo(Index: Integer): TcxSortingBySummaryInfo;
|
|
function GetInfoCount: Integer;
|
|
protected
|
|
procedure AddInfo(AInfo: TcxSortingBySummaryInfo);
|
|
procedure BuildNodes(AParentNode: TcxDataGroupNode; ALevel: Integer; var ACurIndex: Integer);
|
|
procedure ClearInfos;
|
|
function CompareGroupsBySummary(AInfo1, AInfo2: Pointer): Integer;
|
|
procedure RebuildDataGroupRecursive(AParentNode: TcxDataGroupNode; var ABeginRecordListIndex: Integer);
|
|
procedure RebuildDataGroups;
|
|
procedure SortNodeRecursive(ANode: TcxDataGroupNode; ALevel: Integer);
|
|
procedure SortNodes;
|
|
|
|
property DataGroups: TcxDataGroups read GetDataGroups;
|
|
property InfoCount: Integer read GetInfoCount;
|
|
property Infos[Index: Integer]: TcxSortingBySummaryInfo read GetInfo;
|
|
public
|
|
constructor Create(ADataControllerInfo: TcxCustomDataControllerInfo); override;
|
|
destructor Destroy; override;
|
|
procedure Sort; override;
|
|
end;
|
|
|
|
// interface to data controller
|
|
|
|
IcxCustomGridDataController = interface
|
|
['{B9ABDC6B-1A4A-4F11-A629-09B6FB9FB4BA}']
|
|
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;
|
|
property GridView: TcxCustomGridView read GetGridView;
|
|
end;
|
|
|
|
{ painters }
|
|
|
|
TcxCustomGridCellPainterClass = class of TcxCustomGridCellPainter;
|
|
|
|
TcxCustomGridCellPainter = class
|
|
private
|
|
FCanvas: TcxCanvas;
|
|
FViewInfo: TcxCustomGridCellViewInfo;
|
|
function GetIsMainCanvasInUseValue: Boolean;
|
|
protected
|
|
procedure AfterPaint; virtual;
|
|
procedure BeforePaint; virtual;
|
|
function CanDrawDesignSelection: Boolean; virtual;
|
|
procedure DoExcludeFromClipRect; virtual;
|
|
procedure DrawBackground; overload; virtual;
|
|
procedure DrawBackground(const R: TRect); overload; virtual;
|
|
function DrawBackgroundHandler(ACanvas: TcxCanvas; const ABounds: TRect): Boolean; virtual;
|
|
procedure DrawBorder(ABorder: TcxBorder); virtual;
|
|
procedure DrawBorders; virtual;
|
|
procedure DrawContent; virtual;
|
|
class procedure DrawDesignSelection(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxCustomGridCellViewInfo); virtual;
|
|
procedure DrawText; virtual;
|
|
function ExcludeFromClipRect: Boolean; virtual;
|
|
class function GetIsMainCanvasInUse(ACanvas: TcxCanvas; AViewInfo: TcxCustomGridCellViewInfo): Boolean;
|
|
function NeedsPainting: Boolean; virtual;
|
|
procedure Paint; virtual;
|
|
procedure PrepareCanvasForDrawText; virtual;
|
|
procedure UnprepareCanvasForDrawText; virtual;
|
|
property Canvas: TcxCanvas read FCanvas;
|
|
property IsMainCanvasInUse: Boolean read GetIsMainCanvasInUseValue;
|
|
property ViewInfo: TcxCustomGridCellViewInfo read FViewInfo;
|
|
public
|
|
constructor Create(ACanvas: TcxCanvas; AViewInfo: TcxCustomGridCellViewInfo); virtual;
|
|
class procedure DoDrawDesignSelection(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxCustomGridCellViewInfo); virtual;
|
|
procedure MainPaint; virtual;
|
|
end;
|
|
|
|
TcxGridDesignSelectorPainter = class(TcxCustomGridCellPainter)
|
|
private
|
|
function GetViewInfo: TcxGridDesignSelectorViewInfo;
|
|
protected
|
|
procedure DoExcludeFromClipRect; override;
|
|
procedure DrawSign(AColor: TColor); virtual;
|
|
function ExcludeFromClipRect: Boolean; override;
|
|
procedure Paint; override;
|
|
property ViewInfo: TcxGridDesignSelectorViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
TcxCustomGridPainterClass = class of TcxCustomGridPainter;
|
|
|
|
TcxCustomGridPainter = class(TcxGridViewHandler)
|
|
private
|
|
FBackgroundRegion: TcxRegion;
|
|
FBeforePaintClipRegion: TcxRegion;
|
|
FCanvas: TcxCanvas;
|
|
FViewInfo: TcxCustomGridViewInfo;
|
|
function GetCanvas: TcxCanvas;
|
|
function GetViewInfo: TcxCustomGridViewInfo;
|
|
protected
|
|
procedure DrawBackground; virtual;
|
|
procedure PaintAfter; virtual;
|
|
procedure PaintBefore; virtual;
|
|
procedure PaintContent; virtual;
|
|
property Canvas: TcxCanvas read GetCanvas write FCanvas;
|
|
property ViewInfo: TcxCustomGridViewInfo read GetViewInfo write FViewInfo;
|
|
public
|
|
procedure DrawFocusRect(const R: TRect; AHideFocusRect: Boolean); virtual;
|
|
procedure ExcludeFromBackground(const R: TRect);
|
|
procedure Paint(ACanvas: TcxCanvas = nil; AViewInfo: TcxCustomGridViewInfo = nil);
|
|
procedure Invalidate; overload;
|
|
procedure Invalidate(const R: TRect); overload;
|
|
procedure Invalidate(ARegion: TcxRegion); overload;
|
|
end;
|
|
|
|
{ viewdata }
|
|
|
|
TcxCustomGridViewDataClass = class of TcxCustomGridViewData;
|
|
|
|
TcxCustomGridViewData = class(TcxGridViewHandler)
|
|
public
|
|
function GetSortingBySummaryEngineClass: TcxSortingBySummaryEngineClass; virtual;
|
|
function IsEmpty: Boolean; virtual;
|
|
function MakeDetailVisible(ADetailLevel: TComponent{TcxGridLevel}): TcxCustomGridView; virtual;
|
|
property DataController;
|
|
end;
|
|
|
|
{ viewinfos }
|
|
|
|
TcxGridSiteClass = class of TcxGridSite;
|
|
|
|
TcxGridSite = class(TcxControl)
|
|
private
|
|
FBoundsChangedTimer: TcxTimer;
|
|
FIgnoreUpdateLock: Boolean;
|
|
FSize: TPoint;
|
|
FViewInfo: TcxCustomGridViewInfo;
|
|
function GetContainer: TcxControl;
|
|
function GetController: TcxCustomGridController;
|
|
function GetGridView: TcxCustomGridView;
|
|
function GetPainter: TcxCustomGridPainter;
|
|
procedure SendKeyDownNotification(var Message: TWMKeyDown);
|
|
procedure CNKeyDown(var Message: TWMKeyDown); message CN_KEYDOWN;
|
|
procedure CNSysKeyDown(var Message: TWMKeyDown); message CN_SYSKEYDOWN;
|
|
procedure BoundsChangedTimerHandler(Sender: TObject);
|
|
protected
|
|
function AllowAutoDragAndDropAtDesignTime(X, Y: Integer;
|
|
Shift: TShiftState): Boolean; override;
|
|
function AllowDragAndDropWithoutFocus: Boolean; override;
|
|
procedure BeforeMouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
|
|
procedure BoundsChanged; override;
|
|
function CanDrag(X, Y: Integer): Boolean; override;
|
|
function CanFocusOnClick(X, Y: Integer): Boolean; override;
|
|
procedure DoCancelMode; override;
|
|
procedure DoContextPopup(MousePos: TPoint; var Handled: Boolean); override;
|
|
procedure DoEnter; override;
|
|
procedure DoExit; override;
|
|
procedure FocusChanged; override;
|
|
function FocusWhenChildIsClicked(AChild: TControl): Boolean; override;
|
|
function GetClientBounds: TRect; override;
|
|
function GetCursor(X, Y: Integer): TCursor; override;
|
|
function GetDesignHitTest(X, Y: Integer; Shift: TShiftState): Boolean; override;
|
|
function GetIsDesigning: Boolean; override;
|
|
function GetIsFocused: Boolean; override;
|
|
function GetMouseWheelScrollingKind: TcxMouseWheelScrollingKind; override;
|
|
function IsPixelScrollBar(AKind: TScrollBarKind): Boolean; override;
|
|
procedure KeyDown(var Key: Word; Shift: TShiftState); override;
|
|
procedure KeyPress(var Key: Char); override;
|
|
procedure KeyUp(var Key: Word; Shift: TShiftState); override;
|
|
function MayFocus: Boolean; override;
|
|
procedure MouseLeave(AControl: TControl); override;
|
|
procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;
|
|
procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
|
|
procedure Paint; override;
|
|
procedure RequestAlign; override;
|
|
procedure SetParent(AParent: TWinControl); override;
|
|
procedure WndProc(var Message: TMessage); override;
|
|
|
|
procedure DoEndDrag(Target: TObject; X, Y: Integer); override;
|
|
procedure DoStartDrag(var DragObject: TDragObject); override;
|
|
procedure DragOver(Source: TObject; X, Y: Integer; State: TDragState; var Accept: Boolean); override;
|
|
procedure DrawDragImage(ACanvas: TcxCanvas; const R: TRect); override;
|
|
function GetDragImagesSize: TPoint; override;
|
|
function HasDragImages: Boolean; override;
|
|
|
|
function GetHScrollBarBounds: TRect; override;
|
|
procedure InitScrollBarsParameters; override;
|
|
procedure Scroll(AScrollBarKind: TScrollBarKind; AScrollCode: TScrollCode;
|
|
var AScrollPos: Integer); override;
|
|
procedure UpdateScrollBars; override;
|
|
|
|
procedure DragAndDrop(const P: TPoint; var Accepted: Boolean); override;
|
|
procedure EndDragAndDrop(Accepted: Boolean); override;
|
|
function StartDragAndDrop(const P: TPoint): Boolean; override;
|
|
|
|
procedure CancelPostBoundsChanged;
|
|
procedure InitTabStop(AParent: TWinControl);
|
|
procedure PostBoundsChanged;
|
|
procedure UpdateSize;
|
|
|
|
property Controller: TcxCustomGridController read GetController;
|
|
property IgnoreUpdateLock: Boolean read FIgnoreUpdateLock write FIgnoreUpdateLock;
|
|
property Painter: TcxCustomGridPainter read GetPainter;
|
|
public
|
|
constructor Create(AViewInfo: TcxCustomGridViewInfo); reintroduce; virtual;
|
|
destructor Destroy; override;
|
|
procedure BeginDragAndDrop; override;
|
|
procedure DragDrop(Source: TObject; X, Y: Integer); override;
|
|
function ExecuteAction(Action: TBasicAction): Boolean; override;
|
|
procedure SetBounds(ALeft, ATop, AWidth, AHeight: Integer); override;
|
|
procedure SetFocus; override;
|
|
function UpdateAction(Action: TBasicAction): Boolean; override;
|
|
|
|
property Container: TcxControl read GetContainer;
|
|
property GridView: TcxCustomGridView read GetGridView;
|
|
property HScrollBar;
|
|
property HScrollBarVisible;
|
|
property Keys; //!!!
|
|
property MouseCapture;
|
|
property ViewInfo: TcxCustomGridViewInfo read FViewInfo;
|
|
property VScrollBar;
|
|
property VScrollBarVisible;
|
|
end;
|
|
|
|
TcxCustomGridCellViewInfoClass = class of TcxCustomGridCellViewInfo;
|
|
|
|
TcxCustomGridCellViewInfo = class(TcxIUnknownObject,
|
|
IcxMouseCaptureObject, IcxMouseTrackingCaller, IcxMouseTrackingCaller2,
|
|
IcxCustomGridPopupOwner)
|
|
private
|
|
FCalculated: Boolean;
|
|
FCalculatingParams: Boolean;
|
|
FAlignmentHorz: TAlignment;
|
|
FAlignmentVert: TcxAlignmentVert;
|
|
FBorders: TcxBorders;
|
|
FIsDestroying: Boolean;
|
|
FLinkedHitTest: TcxCustomGridHitTest;
|
|
FParamsCalculated: Boolean;
|
|
FState: TcxGridCellState;
|
|
FText: string;
|
|
FVisible: Boolean;
|
|
function GetBorderSize(AIndex: TcxBorder): Integer;
|
|
function GetButtonState: TcxButtonState;
|
|
function GetClientBounds: TRect;
|
|
function GetContentBounds: TRect;
|
|
function GetTextBoundsValue: TRect;
|
|
function GetTextHeight: Integer;
|
|
function GetTextHeightWithOffset: Integer;
|
|
function GetTextWidth: Integer;
|
|
function GetTextWidthWithOffset: Integer;
|
|
procedure SetLinkedHitTest(Value: TcxCustomGridHitTest);
|
|
procedure SetState(Value: TcxGridCellState);
|
|
protected
|
|
FClientBounds: TRect;
|
|
FContentBounds: TRect;
|
|
|
|
{ IcxMouseCaptureObject }
|
|
procedure DoCancelMode; virtual;
|
|
{ IcxMouseTrackingCaller2 }
|
|
procedure MouseLeave; virtual;
|
|
function PtInCaller(const P: TPoint): Boolean; virtual;
|
|
{ IcxCustomGridPopupOwner }
|
|
function ClosePopupWhenNilOwner: Boolean;
|
|
function GetOwnerBounds: TRect;
|
|
procedure PopupClosed;
|
|
|
|
procedure AfterCalculateBounds(var ABounds: TRect); virtual;
|
|
procedure AfterCustomDraw(ACanvas: TcxCanvas); virtual;
|
|
procedure BeforeCustomDraw(ACanvas: TcxCanvas); virtual;
|
|
procedure BeforeStateChange; virtual;
|
|
function CalculateClientBounds: TRect; virtual;
|
|
function CalculateContentBounds: TRect; virtual;
|
|
function CalculateTextWidth(AAngle: Integer = 0): Integer;
|
|
function CalculateTextHeight(AForPainting: Boolean; AAngle: Integer = 0): Integer;
|
|
procedure CalculateParams;
|
|
procedure CalculateParamsNeeded;
|
|
function CalculateHeight: Integer; virtual;
|
|
function CalculateWidth: Integer; virtual;
|
|
function CaptureMouseOnPress: Boolean; virtual;
|
|
procedure Click; virtual;
|
|
function CustomDraw(ACanvas: TcxCanvas): Boolean; virtual;
|
|
function CustomDrawBackground(ACanvas: TcxCanvas): Boolean; virtual;
|
|
procedure Destroying;
|
|
procedure DoCalculateParams; virtual;
|
|
procedure DoInvalidate; virtual;
|
|
function DoCustomDraw(ACanvas: TcxCanvas): Boolean; virtual;
|
|
function DoCustomDrawBackground(ACanvas: TcxCanvas): Boolean; virtual;
|
|
function GetActualState: TcxGridCellState; virtual;
|
|
function GetAlignmentHorz: TAlignment; virtual;
|
|
function GetAlignmentVert: TcxAlignmentVert; virtual;
|
|
function GetAreaBounds: TRect; virtual;
|
|
function GetBackgroundBitmap: TBitmap; virtual;
|
|
function GetBorderBounds(AIndex: TcxBorder): TRect; virtual;
|
|
function GetBorderColor(AIndex: TcxBorder): TColor; virtual;
|
|
function GetBorders: TcxBorders; virtual;
|
|
function GetBorderWidth(AIndex: TcxBorder): Integer; virtual;
|
|
function GetBounds: TRect;
|
|
function GetCanvas: TcxCanvas; virtual; abstract;
|
|
class function GetCellHeight(ATextHeight: Integer;
|
|
ALookAndFeelPainter: TcxCustomLookAndFeelPainterClass): Integer; virtual;
|
|
function GetContentHeight: Integer; virtual;
|
|
function GetContentWidth: Integer; virtual;
|
|
function GetControl: TcxControl; virtual;
|
|
function GetDesignSelectionBounds: TRect; virtual;
|
|
function GetDesignSelectionWidth: Integer; virtual;
|
|
function GetHeight: Integer; virtual;
|
|
function GetHitTestClass: TcxCustomGridHitTestClass; virtual; abstract;
|
|
function GetHotTrack: Boolean; virtual;
|
|
function GetIsCheck: Boolean; virtual;
|
|
function GetIsDesignSelected: Boolean; virtual;
|
|
function GetIsVisibleForPainting: Boolean; virtual;
|
|
function GetMouseCapture: Boolean; virtual;
|
|
function GetMultiLine: Boolean; virtual;
|
|
function GetMultiLinePainting: Boolean; virtual;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; virtual;
|
|
function GetShowEndEllipsis: Boolean; virtual;
|
|
function GetText: string; virtual;
|
|
function GetTextAreaBounds: TRect; virtual;
|
|
function GetTextAttributes(AForPainting: Boolean): Integer; virtual;
|
|
function GetTextBounds(AHorizontal, AVertical: Boolean): TRect;
|
|
function GetTextCellHeight(AGridViewInfo: TcxCustomGridViewInfo;
|
|
ALookAndFeelPainter: TcxCustomLookAndFeelPainterClass): Integer; virtual;
|
|
function GetTextForPainting: string; virtual;
|
|
function GetTransparent: Boolean; virtual;
|
|
procedure GetViewParams(var AParams: TcxViewParams); virtual;
|
|
function GetVisible: Boolean; virtual;
|
|
function GetVisibleForHitTest: Boolean; virtual;
|
|
function GetWidth: Integer; virtual;
|
|
function HasBackground: Boolean; virtual;
|
|
function HasCustomDraw: Boolean; virtual;
|
|
function HasCustomDrawBackground: Boolean; virtual;
|
|
function HasHitTestPoint(const P: TPoint): Boolean; virtual;
|
|
function HasMouse(AHitTest: TcxCustomGridHitTest): Boolean; virtual;
|
|
procedure InitHitTest(AHitTest: TcxCustomGridHitTest); virtual;
|
|
function InvalidateOnStateChange: Boolean; virtual;
|
|
procedure Offset(DX, DY: Integer); virtual;
|
|
procedure RestoreParams(const AParams: TcxViewParams); virtual;
|
|
procedure SaveParams(out AParams: TcxViewParams); virtual;
|
|
procedure SetHeight(Value: Integer); virtual;
|
|
procedure SetMouseCapture(Value: Boolean); virtual;
|
|
procedure SetWidth(Value: Integer); virtual;
|
|
procedure StateChanged(APrevState: TcxGridCellState); virtual;
|
|
|
|
procedure DropDown; virtual;
|
|
procedure CloseUp; virtual;
|
|
function CloseDropDownWindowOnDestruction: Boolean; virtual;
|
|
function DropDownWindowExists: Boolean; virtual;
|
|
function GetDropDownWindow: TcxCustomGridPopup; virtual;
|
|
function GetDropDownWindowOwnerBounds: TRect; virtual;
|
|
function IsDropDownWindowOwner: Boolean; virtual;
|
|
property DropDownWindow: TcxCustomGridPopup read GetDropDownWindow;
|
|
|
|
property BorderWidth[AIndex: TcxBorder]: Integer read GetBorderWidth;
|
|
property CalculatingParams: Boolean read FCalculatingParams;
|
|
property Canvas: TcxCanvas read GetCanvas;
|
|
property Control: TcxControl read GetControl;
|
|
property DesignSelectionBounds: TRect read GetDesignSelectionBounds;
|
|
property DesignSelectionWidth: Integer read GetDesignSelectionWidth;
|
|
property HotTrack: Boolean read GetHotTrack;
|
|
property IsCheck: Boolean read GetIsCheck;
|
|
property IsDesignSelected: Boolean read GetIsDesignSelected;
|
|
property IsDestroying: Boolean read FIsDestroying;
|
|
property IsVisibleForPainting: Boolean read GetIsVisibleForPainting;
|
|
property LinkedHitTest: TcxCustomGridHitTest read FLinkedHitTest write SetLinkedHitTest;
|
|
property ShowEndEllipsis: Boolean read GetShowEndEllipsis;
|
|
public
|
|
Bounds: TRect;
|
|
MultiLine: Boolean;
|
|
MultiLinePainting: Boolean;
|
|
Params: TcxViewParams;
|
|
|
|
constructor Create;
|
|
destructor Destroy; override;
|
|
procedure AfterConstruction; override;
|
|
procedure AfterRecalculation; virtual;
|
|
procedure BeforeDestruction; override;
|
|
procedure BeforeRecalculation; virtual;
|
|
procedure Calculate(ALeftBound, ATopBound: Integer; AWidth: Integer = -1;
|
|
AHeight: Integer = -1); overload; virtual;
|
|
procedure Calculate(const ABounds: TRect); overload; virtual;
|
|
function GetAreaBoundsForPainting: TRect; virtual;
|
|
function GetBestFitWidth: Integer; virtual;
|
|
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; virtual;
|
|
function HasPoint(const P: TPoint): Boolean; virtual;
|
|
procedure Invalidate; virtual;
|
|
function MouseDown(AHitTest: TcxCustomGridHitTest; AButton: TMouseButton;
|
|
AShift: TShiftState): Boolean; virtual;
|
|
function MouseMove(AHitTest: TcxCustomGridHitTest; AShift: TShiftState): Boolean; virtual;
|
|
function MouseUp(AHitTest: TcxCustomGridHitTest; AButton: TMouseButton;
|
|
AShift: TShiftState): Boolean; virtual;
|
|
procedure DoOffset(DX, DY: Integer);
|
|
procedure Paint(ACanvas: TcxCanvas = nil); virtual;
|
|
procedure Recalculate;
|
|
procedure ResetContentBounds;
|
|
procedure Update;
|
|
|
|
property ActualState: TcxGridCellState read GetActualState;
|
|
property AlignmentHorz: TAlignment read FAlignmentHorz write FAlignmentHorz;
|
|
property AlignmentVert: TcxAlignmentVert read FAlignmentVert write FAlignmentVert;
|
|
property BackgroundBitmap: TBitmap read GetBackgroundBitmap;
|
|
property BorderBounds[AIndex: TcxBorder]: TRect read GetBorderBounds;
|
|
property BorderColor[AIndex: TcxBorder]: TColor read GetBorderColor;
|
|
property BorderSize[AIndex: TcxBorder]: Integer read GetBorderSize;
|
|
property Borders: TcxBorders read FBorders write FBorders;
|
|
property ButtonState: TcxButtonState read GetButtonState;
|
|
property Calculated: Boolean read FCalculated write FCalculated;
|
|
property ClientBounds: TRect read GetClientBounds;
|
|
property ContentBounds: TRect read GetContentBounds;
|
|
property ContentHeight: Integer read GetContentHeight;
|
|
property ContentWidth: Integer read GetContentWidth;
|
|
property Height: Integer read GetHeight write SetHeight;
|
|
property MouseCapture: Boolean read GetMouseCapture write SetMouseCapture;
|
|
property State: TcxGridCellState read FState write SetState;
|
|
property Text: string read FText write FText;
|
|
property TextBounds: TRect read GetTextBoundsValue;
|
|
property TextForPainting: string read GetTextForPainting;
|
|
property TextHeightWithOffset: Integer read GetTextHeightWithOffset;
|
|
property TextWidthWithOffset: Integer read GetTextWidthWithOffset;
|
|
property TextHeight: Integer read GetTextHeight;
|
|
property TextWidth: Integer read GetTextWidth;
|
|
property TextAreaBounds: TRect read GetTextAreaBounds;
|
|
property Transparent: Boolean read GetTransparent;
|
|
property Visible: Boolean read GetVisible write FVisible;
|
|
property VisibleForHitTest: Boolean read GetVisibleForHitTest;
|
|
property Width: Integer read GetWidth write SetWidth;
|
|
end;
|
|
|
|
TcxCustomGridViewCellViewInfo = class(TcxCustomGridCellViewInfo)
|
|
private
|
|
FGridViewInfo: TcxCustomGridViewInfo;
|
|
function GetController: TcxCustomGridController;
|
|
function GetGridView: TcxCustomGridView;
|
|
function GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
|
|
protected
|
|
procedure AfterCalculateBounds(var ABounds: TRect); override;
|
|
procedure DoInvalidate; override;
|
|
function EmulateMouseMoveAfterCalculate: Boolean; virtual;
|
|
function GetCanvas: TcxCanvas; override;
|
|
function GetControl: TcxControl; override;
|
|
function HasMouse(AHitTest: TcxCustomGridHitTest): Boolean; override;
|
|
procedure InitHitTest(AHitTest: TcxCustomGridHitTest); override;
|
|
|
|
function CanShowHint: Boolean; virtual;
|
|
procedure CheckHint(AHitTest: TcxCustomGridHitTest);
|
|
function GetAreaBoundsForHint: TRect; virtual;
|
|
function GetBoundsForHint: TRect;
|
|
function GetCellBoundsForHint: TRect; virtual;
|
|
function GetHintText: string; virtual;
|
|
function GetHintTextRect(const AMousePos: TPoint): TRect; virtual;
|
|
function HasHintPoint(const P: TPoint): Boolean; virtual;
|
|
procedure InitHint(const AMousePos: TPoint; out AHintText: TCaption;
|
|
out AIsHintMultiLine: Boolean; out ATextRect: TRect); virtual;
|
|
function IsHintForText: Boolean; virtual;
|
|
function IsHintMultiLine: Boolean; virtual;
|
|
function NeedShowHint(const AMousePos: TPoint; out AHintText: TCaption;
|
|
out AIsHintMultiLine: Boolean; out ATextRect: TRect): Boolean; virtual;
|
|
|
|
property Controller: TcxCustomGridController read GetController;
|
|
public
|
|
constructor Create(AGridViewInfo: TcxCustomGridViewInfo); virtual;
|
|
destructor Destroy; override;
|
|
procedure BeforeRecalculation; override;
|
|
procedure Invalidate; override;
|
|
function MouseMove(AHitTest: TcxCustomGridHitTest; AShift: TShiftState): Boolean; override;
|
|
property GridView: TcxCustomGridView read GetGridView;
|
|
property GridViewInfo: TcxCustomGridViewInfo read FGridViewInfo;
|
|
property HintText: string read GetHintText;
|
|
property LookAndFeelPainter: TcxCustomLookAndFeelPainterClass read GetLookAndFeelPainter;
|
|
end;
|
|
|
|
TcxGridDesignSelectorViewInfoClass = class of TcxGridDesignSelectorViewInfo;
|
|
|
|
TcxGridDesignSelectorViewInfo = class(TcxCustomGridViewCellViewInfo)
|
|
private
|
|
FRegion: TcxRegion;
|
|
protected
|
|
function CalculateHeight: Integer; override;
|
|
function CalculateWidth: Integer; override;
|
|
function GetHitTestClass: TcxCustomGridHitTestClass; override;
|
|
function GetHotTrack: Boolean; override;
|
|
function GetPainterClass: TcxCustomGridCellPainterClass; override;
|
|
procedure GetViewParams(var AParams: TcxViewParams); override;
|
|
|
|
procedure CreateRegion;
|
|
procedure DestroyRegion;
|
|
property Region: TcxRegion read FRegion;
|
|
public
|
|
destructor Destroy; override;
|
|
procedure Calculate(ALeftBound, ATopBound: Integer; AWidth: Integer = -1;
|
|
AHeight: Integer = -1); override;
|
|
function HasPoint(const P: TPoint): Boolean; override;
|
|
function MouseDown(AHitTest: TcxCustomGridHitTest; AButton: TMouseButton;
|
|
AShift: TShiftState): Boolean; override;
|
|
end;
|
|
|
|
TcxCustomGridViewInfoClass = class of TcxCustomGridViewInfo;
|
|
|
|
TcxCustomGridViewInfo = class(TcxGridViewHandler)
|
|
private
|
|
FActiveViewInfos: TList;
|
|
FAllowCheckCoordinates: Boolean;
|
|
FAllowHideSite: Boolean;
|
|
FBounds: TRect;
|
|
FClientBounds: TRect;
|
|
FClientBoundsAssigned: Boolean;
|
|
FDesignSelectorViewInfo: TcxGridDesignSelectorViewInfo;
|
|
FIsCalculating: Boolean;
|
|
FIsInternalUse: Boolean;
|
|
FLock: TRTLCriticalSection;
|
|
FMousePos: TPoint;
|
|
FSite: TcxGridSite;
|
|
FSizeCalculating: Boolean;
|
|
FVisibilityChanging: Boolean;
|
|
|
|
function GetCalculated: Boolean;
|
|
function GetCanvas: TcxCanvas;
|
|
function GetClientBounds: TRect;
|
|
function GetClientHeight: Integer;
|
|
function GetClientWidth: Integer;
|
|
//function GetIsCalculating: Boolean;
|
|
function GetIsInternalUseValue: Boolean;
|
|
procedure SetClientBounds(const Value: TRect);
|
|
protected
|
|
procedure CreateViewInfos; virtual;
|
|
procedure DestroyViewInfos(AIsRecreating: Boolean); virtual;
|
|
procedure RecreateViewInfos; virtual;
|
|
function GetDesignSelectorViewInfoClass: TcxGridDesignSelectorViewInfoClass; virtual;
|
|
|
|
function CanHideSite: Boolean; virtual;
|
|
procedure CreateSite;
|
|
procedure DestroySite;
|
|
function GetSiteClass: TcxGridSiteClass; virtual;
|
|
function GetSiteParent: TWinControl;
|
|
|
|
procedure AddActiveViewInfo(AViewInfo: TObject);
|
|
function IsViewInfoActive(AViewInfo: TObject): Boolean;
|
|
procedure RemoveActiveViewInfo(AViewInfo: TObject; ARemoveAll: Boolean = False);
|
|
|
|
procedure AddScrollBarHeight(var AHeight: Integer);
|
|
procedure AdjustClientBounds(var ABounds: TRect); virtual;
|
|
procedure AfterCalculating; virtual;
|
|
procedure BeforeCalculating; virtual;
|
|
procedure Calculate; virtual;
|
|
function CalculateClientBounds: TRect; virtual;
|
|
procedure CalculateHeight(const AMaxSize: TPoint; var AHeight: Integer;
|
|
var AFullyVisible: Boolean); virtual;
|
|
procedure CalculateWidth(const AMaxSize: TPoint; var AWidth: Integer); virtual;
|
|
function CanCheckCoordinates: Boolean; virtual;
|
|
procedure ControlFocusChanged; virtual;
|
|
function DoGetHitTest(const P: TPoint): TcxCustomGridHitTest; virtual;
|
|
function GetAllowBoundsChangedNotification: Boolean; virtual;
|
|
function GetBackgroundBitmap: TBitmap; virtual;
|
|
function GetBackgroundColor: TColor; virtual;
|
|
//function GetContentBounds: TRect; virtual;
|
|
function GetDesignSelectorPos: TPoint; virtual;
|
|
procedure GetHScrollBarBounds(var ABounds: TRect); virtual;
|
|
function GetIsInternalUse: Boolean; virtual;
|
|
function GetVisible: Boolean; virtual;
|
|
procedure InitHitTest(AHitTest: TcxCustomGridHitTest); virtual;
|
|
procedure UpdateMousePos;
|
|
procedure VisibilityChanged(AVisible: Boolean); virtual;
|
|
|
|
property AllowBoundsChangedNotification: Boolean read GetAllowBoundsChangedNotification;
|
|
property AllowCheckCoordinates: Boolean read FAllowCheckCoordinates write FAllowCheckCoordinates;
|
|
property ClientBoundsAssigned: Boolean read FClientBoundsAssigned write FClientBoundsAssigned;
|
|
property SizeCalculating: Boolean read FSizeCalculating;
|
|
property VisibilityChanging: Boolean read FVisibilityChanging;
|
|
property Visible: Boolean read GetVisible;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); override;
|
|
destructor Destroy; override;
|
|
procedure BeforeDestruction; override;
|
|
procedure DoVisibilityChanged(AVisible: Boolean);
|
|
function GetFontHeight(AFont: TFont): Integer;
|
|
procedure GetFontMetrics(AFont: TFont; out AMetrics: TTextMetric);
|
|
procedure GetHeight(const AMaxSize: TPoint; var AHeight: Integer;
|
|
var AFullyVisible: Boolean);
|
|
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; overload; virtual;
|
|
function GetHitTest(X, Y: Integer): TcxCustomGridHitTest; overload; virtual;
|
|
procedure GetWidth(const AMaxSize: TPoint; var AWidth: Integer);
|
|
procedure MainCalculate(const ABounds: TRect);
|
|
procedure Recalculate;
|
|
|
|
property AllowHideSite: Boolean read FAllowHideSite write FAllowHideSite;
|
|
property BackgroundColor: TColor read GetBackgroundColor;
|
|
property BackgroundBitmap: TBitmap read GetBackgroundBitmap;
|
|
property Bounds: TRect read FBounds;
|
|
property Calculated: Boolean read GetCalculated;
|
|
property Canvas: TcxCanvas read GetCanvas;
|
|
property ClientBounds: TRect read GetClientBounds write SetClientBounds;
|
|
property ClientHeight: Integer read GetClientHeight;
|
|
property ClientWidth: Integer read GetClientWidth;
|
|
//property ContentBounds: TRect read GetContentBounds;
|
|
property DesignSelectorViewInfo: TcxGridDesignSelectorViewInfo read FDesignSelectorViewInfo;
|
|
property IsCalculating: Boolean read FIsCalculating;
|
|
property IsInternalUse: Boolean read GetIsInternalUseValue write FIsInternalUse;
|
|
property MousePos: TPoint read FMousePos;
|
|
property Site: TcxGridSite read FSite;
|
|
end;
|
|
|
|
TcxCustomGridViewInfoCacheItemClass = class of TcxCustomGridViewInfoCacheItem;
|
|
|
|
TcxCustomGridViewInfoCacheItem = class
|
|
private
|
|
FIndex: Integer;
|
|
FOwner: TcxCustomGridViewInfoCache;
|
|
protected
|
|
property Index: Integer read FIndex;
|
|
property Owner: TcxCustomGridViewInfoCache read FOwner;
|
|
public
|
|
constructor Create(AOwner: TcxCustomGridViewInfoCache; AIndex: Integer); virtual;
|
|
procedure UnassignValues(AKeepMaster: Boolean); virtual;
|
|
end;
|
|
|
|
TcxCustomGridViewInfoCacheClass = class of TcxCustomGridViewInfoCache;
|
|
|
|
TcxCustomGridViewInfoCache = class(TcxGridViewHandler)
|
|
private
|
|
FItems: TList;
|
|
FUnassigningValues: Boolean;
|
|
function GetCount: Integer;
|
|
function GetInternalItem(Index: Integer): TcxCustomGridViewInfoCacheItem;
|
|
function GetItem(Index: Integer): TcxCustomGridViewInfoCacheItem;
|
|
procedure SetCount(Value: Integer);
|
|
procedure DestroyItems;
|
|
protected
|
|
function GetItemClass(Index: Integer): TcxCustomGridViewInfoCacheItemClass; virtual; abstract;
|
|
property InternalItems[Index: Integer]: TcxCustomGridViewInfoCacheItem read GetInternalItem;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); override;
|
|
destructor Destroy; override;
|
|
procedure UnassignValues(AKeepMaster: Boolean = False); virtual;
|
|
property Count: Integer read GetCount write SetCount;
|
|
property Items[Index: Integer]: TcxCustomGridViewInfoCacheItem read GetItem; default;
|
|
end;
|
|
|
|
{ custom view }
|
|
|
|
TcxGridViewChangeKind = (vcProperty, vcLayout, vcSize);
|
|
|
|
TcxCustomGridOptions = class(TcxInterfacedPersistent)
|
|
private
|
|
FGridView: TcxCustomGridView;
|
|
function GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
|
|
protected
|
|
procedure Changed(AChangeKind: TcxGridViewChangeKind); virtual;
|
|
function GetGridViewValue: TcxCustomGridView; virtual;
|
|
procedure Notification(AComponent: TComponent; AOperation: TOperation); virtual;
|
|
|
|
procedure GetStoredProperties(AProperties: TStrings); virtual;
|
|
procedure GetStoredPropertyValue(const AName: string; var AValue: Variant); virtual;
|
|
procedure SetStoredPropertyValue(const AName: string; const AValue: Variant); virtual;
|
|
|
|
property LookAndFeelPainter: TcxCustomLookAndFeelPainterClass read GetLookAndFeelPainter;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); reintroduce; virtual;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
property GridView: TcxCustomGridView read GetGridViewValue;
|
|
end;
|
|
|
|
TcxCustomGridBackgroundBitmapsClass = class of TcxCustomGridBackgroundBitmaps;
|
|
|
|
TcxCustomGridBackgroundBitmaps = class(TcxCustomGridOptions)
|
|
private
|
|
FItems: TList;
|
|
function GetCount: Integer;
|
|
procedure BitmapChanged(Sender: TObject);
|
|
protected
|
|
function GetBitmapStyleIndex(Index: Integer): Integer; virtual;
|
|
function GetDefaultBitmap(Index: Integer): TBitmap; virtual;
|
|
function GetValue(Index: Integer): TBitmap;
|
|
procedure SetValue(Index: Integer; Value: TBitmap);
|
|
property Count: Integer read GetCount;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); override;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetBitmap(Index: Integer): TBitmap; virtual;
|
|
property Values[Index: Integer]: TBitmap read GetValue write SetValue; default;
|
|
published
|
|
property Background: TBitmap index bbBackground read GetValue write SetValue;
|
|
end;
|
|
|
|
TcxCustomGridOptionsBehaviorClass = class of TcxCustomGridOptionsBehavior;
|
|
|
|
TcxCustomGridOptionsBehavior = class(TcxCustomGridOptions)
|
|
private
|
|
FPostponedSynchronization: Boolean;
|
|
function GetPostponedSynchronization: Boolean;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
published
|
|
property PostponedSynchronization: Boolean read GetPostponedSynchronization
|
|
write FPostponedSynchronization default True; // should be published in all descendants
|
|
end;
|
|
|
|
TcxCustomGridOptionsDataClass = class of TcxCustomGridOptionsData;
|
|
|
|
TcxCustomGridOptionsData = class(TcxCustomGridOptions);
|
|
|
|
TcxCustomGridOptionsSelectionClass = class of TcxCustomGridOptionsSelection;
|
|
|
|
TcxCustomGridOptionsSelection = class(TcxCustomGridOptions);
|
|
|
|
TcxCustomGridOptionsViewClass = class of TcxCustomGridOptionsView;
|
|
|
|
TcxCustomGridOptionsView = class(TcxCustomGridOptions)
|
|
private
|
|
function GetScrollBars: TScrollStyle;
|
|
procedure SetScrollBars(Value: TScrollStyle);
|
|
protected
|
|
property ScrollBars: TScrollStyle read GetScrollBars write SetScrollBars default ssBoth;
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
end;
|
|
|
|
TcxCustomGridStyles = class(TcxStyles)
|
|
private
|
|
function GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
|
|
protected
|
|
procedure Changed(AIndex: Integer); override;
|
|
procedure GetDefaultViewParams(Index: Integer; AData: TObject; out AParams: TcxViewParams); override;
|
|
procedure GetFakeComponentLinks(AList: TList); virtual;
|
|
function GetGridView: TcxCustomGridView; virtual; abstract;
|
|
property LookAndFeelPainter: TcxCustomLookAndFeelPainterClass read GetLookAndFeelPainter;
|
|
public
|
|
property GridView: TcxCustomGridView read GetGridView;
|
|
end;
|
|
|
|
TcxCustomGridViewStylesClass = class of TcxCustomGridViewStyles;
|
|
|
|
TcxCustomGridViewStyles = class(TcxCustomGridStyles)
|
|
protected
|
|
procedure GetDefaultViewParams(Index: Integer; AData: TObject; out AParams: TcxViewParams); override;
|
|
function GetGridView: TcxCustomGridView; override;
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
published
|
|
property Background: TcxStyle index vsBackground read GetValue write SetValue;
|
|
end;
|
|
|
|
TcxGridListenerLink = class
|
|
private
|
|
FGridView: TcxCustomGridView;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView);
|
|
destructor Destroy; override;
|
|
procedure Clear;
|
|
property GridView: TcxCustomGridView read FGridView;
|
|
end;
|
|
|
|
TcxGridStorageOption = (gsoUseFilter, gsoUseSummary);
|
|
TcxGridStorageOptions = set of TcxGridStorageOption;
|
|
TcxGridViewChangeNotificationKind = (vcnName{, vsRemoved});
|
|
|
|
TcxGridInitStoredObjectEvent = procedure(Sender: TcxCustomGridView; AObject: TObject) of object;
|
|
TcxGridViewGetStoredPropertiesEvent = procedure(Sender: TcxCustomGridView;
|
|
AProperties: TStrings) of object;
|
|
TcxGridViewGetStoredPropertyValueEvent = procedure(Sender: TcxCustomGridView;
|
|
const AName: string; var AValue: Variant) of object;
|
|
TcxGridViewSetStoredPropertyValueEvent = procedure(Sender: TcxCustomGridView;
|
|
const AName: string; const AValue: Variant) of object;
|
|
|
|
TcxCustomGridViewClass = class of TcxCustomGridView;
|
|
|
|
TcxCustomGridView = class(TcxControlChildComponent, IcxStoredObject, IcxStoredParent,
|
|
IcxGridViewLayoutEditorSupport)
|
|
private
|
|
FAssigningPattern: Boolean;
|
|
FAssigningSettings: Boolean;
|
|
FBackgroundBitmaps: TcxCustomGridBackgroundBitmaps;
|
|
FClones: TList;
|
|
FController: TcxCustomGridController;
|
|
FIsRestoring: Boolean;
|
|
FIsSynchronizing: Boolean;
|
|
FLevel: TComponent;
|
|
FListenerLinks: TList;
|
|
FOptionsList: TList;
|
|
FOptionsBehavior: TcxCustomGridOptionsBehavior;
|
|
FOptionsData: TcxCustomGridOptionsData;
|
|
FOptionsSelection: TcxCustomGridOptionsSelection;
|
|
FOptionsView: TcxCustomGridOptionsView;
|
|
FPainter: TcxCustomGridPainter;
|
|
FPatternGridView: TcxCustomGridView;
|
|
FRepository: TComponent;
|
|
FStorageControl: TcxControl;
|
|
FStorageOptions: TcxGridStorageOptions;
|
|
FStoredVersion: Integer;
|
|
FStoringName: string;
|
|
FStyles: TcxCustomGridStyles;
|
|
FSynchronization: Boolean;
|
|
FSynchronizationAssignNeeded: Boolean;
|
|
FSynchronizationNeeded: Boolean;
|
|
FUpdateLockCount: Integer;
|
|
FViewData: TcxCustomGridViewData;
|
|
FViewInfo: TcxCustomGridViewInfo;
|
|
FViewInfoCache: TcxCustomGridViewInfoCache;
|
|
FOnCustomization: TNotifyEvent;
|
|
FOnGetStoredProperties: TcxGridViewGetStoredPropertiesEvent;
|
|
FOnGetStoredPropertyValue: TcxGridViewGetStoredPropertyValueEvent;
|
|
FOnInitStoredObject: TcxGridInitStoredObjectEvent;
|
|
FOnSetStoredPropertyValue: TcxGridViewSetStoredPropertyValueEvent;
|
|
|
|
function GetClone(Index: Integer): TcxCustomGridView;
|
|
function GetCloneCount: Integer;
|
|
function GetDragMode: TDragMode;
|
|
function GetFocused: Boolean;
|
|
function GetIsControlFocusedValue: Boolean;
|
|
function GetIsDetail: Boolean;
|
|
function GetIsMaster: Boolean;
|
|
function GetIsPattern: Boolean;
|
|
function GetIsStoringNameMode: Boolean;
|
|
function GetIsUpdating: Boolean;
|
|
function GetLookAndFeel: TcxLookAndFeel;
|
|
function GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
|
|
function GetMasterGridView: TcxCustomGridView;
|
|
function GetMasterGridRecordIndex: Integer;
|
|
function GetMasterRecordIndex: Integer;
|
|
function GetOnDblClick: TNotifyEvent;
|
|
function GetOnDragDrop: TDragDropEvent;
|
|
function GetOnDragOver: TDragOverEvent;
|
|
function GetOnEndDrag: TEndDragEvent;
|
|
function GetOnKeyDown: TKeyEvent;
|
|
function GetOnKeyPress: TKeyPressEvent;
|
|
function GetOnKeyUp: TKeyEvent;
|
|
function GetOnMouseDown: TMouseEvent;
|
|
function GetOnMouseEnter: TNotifyEvent;
|
|
function GetOnMouseLeave: TNotifyEvent;
|
|
function GetOnMouseMove: TMouseMoveEvent;
|
|
function GetOnMouseUp: TMouseEvent;
|
|
function GetOnMouseWheel: TMouseWheelEvent;
|
|
function GetOnMouseWheelDown: TMouseWheelUpDownEvent;
|
|
function GetOnMouseWheelUp: TMouseWheelUpDownEvent;
|
|
function GetOnStartDrag: TStartDragEvent;
|
|
function GetPatternGridView: TcxCustomGridView;
|
|
function GetPopupMenu: TComponent;
|
|
function GetSite: TcxGridSite;
|
|
function GetSynchronization: Boolean;
|
|
procedure SetBackgroundBitmaps(Value: TcxCustomGridBackgroundBitmaps);
|
|
procedure SetDragMode(Value: TDragMode);
|
|
procedure SetFocused(Value: Boolean);
|
|
procedure SetIsRestoring(Value: Boolean);
|
|
procedure SetSynchronization(Value: Boolean);
|
|
procedure SetOnCustomization(Value: TNotifyEvent);
|
|
procedure SetOnDblClick(Value: TNotifyEvent);
|
|
procedure SetOnDragDrop(Value: TDragDropEvent);
|
|
procedure SetOnDragOver(Value: TDragOverEvent);
|
|
procedure SetOnEndDrag(Value: TEndDragEvent);
|
|
procedure SetOnGetStoredProperties(Value: TcxGridViewGetStoredPropertiesEvent);
|
|
procedure SetOnGetStoredPropertyValue(Value: TcxGridViewGetStoredPropertyValueEvent);
|
|
procedure SetOnInitStoredObject(Value: TcxGridInitStoredObjectEvent);
|
|
procedure SetOnKeyDown(Value: TKeyEvent);
|
|
procedure SetOnKeyPress(Value: TKeyPressEvent);
|
|
procedure SetOnKeyUp(Value: TKeyEvent);
|
|
procedure SetOnMouseDown(Value: TMouseEvent);
|
|
procedure SetOnMouseEnter(Value: TNotifyEvent);
|
|
procedure SetOnMouseLeave(Value: TNotifyEvent);
|
|
procedure SetOnMouseMove(Value: TMouseMoveEvent);
|
|
procedure SetOnMouseUp(Value: TMouseEvent);
|
|
procedure SetOnMouseWheel(Value: TMouseWheelEvent);
|
|
procedure SetOnMouseWheelDown(Value: TMouseWheelUpDownEvent);
|
|
procedure SetOnMouseWheelUp(Value: TMouseWheelUpDownEvent);
|
|
procedure SetOnSetStoredPropertyValue(Value: TcxGridViewSetStoredPropertyValueEvent);
|
|
procedure SetOnStartDrag(Value: TStartDragEvent);
|
|
procedure SetOptionsBehavior(Value: TcxCustomGridOptionsBehavior);
|
|
procedure SetOptionsData(Value: TcxCustomGridOptionsData);
|
|
procedure SetOptionsSelection(Value: TcxCustomGridOptionsSelection);
|
|
procedure SetOptionsView(Value: TcxCustomGridOptionsView);
|
|
procedure SetPopupMenu(Value: TComponent);
|
|
procedure SetStyles(Value: TcxCustomGridStyles);
|
|
|
|
procedure ClearListenerLinks;
|
|
protected
|
|
FDataController: TcxCustomDataController;
|
|
FSubClassEvents: TNotifyEvent;
|
|
// IcxStoredObject
|
|
function GetObjectName: string; virtual;
|
|
function GetProperties(AProperties: TStrings): Boolean; virtual;
|
|
procedure GetPropertyValue(const AName: string; var AValue: Variant); virtual;
|
|
procedure SetPropertyValue(const AName: string; const AValue: Variant); virtual;
|
|
// IcxStoredParent
|
|
function CreateChild(const AObjectName, AClassName: string): TObject;
|
|
function CreateStoredObject(const AObjectName, AClassName: string): TObject; virtual;
|
|
procedure DeleteChild(const AObjectName: string; AObject: TObject); virtual;
|
|
procedure IcxStoredParent.GetChildren = GetStoredChildren;
|
|
procedure GetStoredChildren(AChildren: TStringList); virtual;
|
|
// IcxGridViewLayoutEditorSupport - for design-time layout editor
|
|
procedure AssignLayout(ALayoutView: TcxCustomGridView); virtual;
|
|
procedure BeforeEditLayout(ALayoutView: TcxCustomGridView); virtual;
|
|
procedure DoAssignLayout(ALayoutView: TcxCustomGridView);
|
|
function GetLayoutCustomizationFormButtonCaption: string; virtual;
|
|
function HasLayoutCustomizationForm: Boolean; virtual;
|
|
function IsLayoutChangeable: Boolean; virtual;
|
|
procedure RunLayoutCustomizationForm; virtual;
|
|
|
|
procedure GetFakeComponentLinks(AList: TList); override;
|
|
function GetIsDestroying: Boolean; override;
|
|
procedure Loaded; override;
|
|
procedure Notification(AComponent: TComponent; Operation: TOperation); override;
|
|
procedure SetControl(Value: TcxControl); override;
|
|
procedure SetName(const NewName: TComponentName); override;
|
|
procedure Updated; override;
|
|
procedure Updating; override;
|
|
|
|
procedure CreateHandlers; virtual;
|
|
procedure DestroyHandlers; virtual;
|
|
procedure InitDataController; virtual;
|
|
|
|
procedure CreateOptions; virtual;
|
|
procedure DestroyOptions; virtual;
|
|
|
|
procedure AddOptions(AOptions: TcxCustomGridOptions);
|
|
procedure RemoveOptions(AOptions: TcxCustomGridOptions);
|
|
procedure NotifyOptions(AComponent: TComponent; AOperation: TOperation);
|
|
|
|
procedure AddClone(AClone: TcxCustomGridView);
|
|
procedure RemoveClone(AClone: TcxCustomGridView);
|
|
|
|
function AddListenerLink: TcxGridListenerLink;
|
|
procedure RemoveListenerLink(ALink: TcxGridListenerLink);
|
|
|
|
procedure Synchronize(ACheckUpdateLock: Boolean = True); overload;
|
|
procedure Synchronize(AView: TcxCustomGridView); overload;
|
|
property SynchronizationAssignNeeded: Boolean read FSynchronizationAssignNeeded;
|
|
property SynchronizationNeeded: Boolean read FSynchronizationNeeded;
|
|
|
|
procedure AssignPattern(APattern: TcxCustomGridView);
|
|
procedure BeforeAssign(ASource: TcxCustomGridView); virtual;
|
|
procedure DoAssign(ASource: TcxCustomGridView); virtual;
|
|
procedure DoAssignSettings(ASource: TcxCustomGridView); virtual;
|
|
procedure AfterAssign(ASource: TcxCustomGridView); virtual;
|
|
property AssigningPattern: Boolean read FAssigningPattern;
|
|
property AssigningSettings: Boolean read FAssigningSettings;
|
|
|
|
procedure BeforeRestoring; virtual;
|
|
procedure AfterRestoring; virtual;
|
|
property IsRestoring: Boolean read FIsRestoring write SetIsRestoring;
|
|
|
|
//procedure BeforeLevelChange; virtual;
|
|
function CanFocus: Boolean; virtual;
|
|
function CanTabStop: Boolean; virtual;
|
|
procedure DetailDataChanged(ADetail: TcxCustomGridView); virtual;
|
|
procedure DetailVisibleChanged(ADetailLevel: TComponent;
|
|
APrevVisibleDetailCount, AVisibleDetailCount: Integer); virtual;
|
|
procedure DoChanged(AChangeKind: TcxGridViewChangeKind); virtual;
|
|
function GetChangeable: Boolean; virtual;
|
|
function GetCustomVisible(ALevelVisible: Boolean): Boolean; virtual;
|
|
function GetIsControlFocused: Boolean; virtual;
|
|
function GetResizeOnBoundsChange: Boolean; virtual;
|
|
function GetVisible: Boolean; virtual;
|
|
procedure Init; virtual;
|
|
function IsDetailVisible(AGridView: TcxCustomGridView): Boolean; virtual;
|
|
procedure FocusChanged(AFocused: Boolean); virtual;
|
|
procedure LoadingComplete; virtual;
|
|
procedure LookAndFeelChanged; virtual;
|
|
procedure NotifyControl(AChangeKind: TcxGridViewChangeNotificationKind);
|
|
procedure RestoringComplete; virtual;
|
|
procedure SetLevel(Value: TComponent); virtual;
|
|
procedure SetTabStop(Value: Boolean); virtual;
|
|
procedure UpdateControl(AInfo: TcxUpdateControlInfo); virtual;
|
|
|
|
function GetControllerClass: TcxCustomGridControllerClass; virtual; abstract;
|
|
function GetDataControllerClass: TcxCustomDataControllerClass; virtual; abstract;
|
|
function GetPainterClass: TcxCustomGridPainterClass; virtual; abstract;
|
|
function GetViewDataClass: TcxCustomGridViewDataClass; virtual; abstract;
|
|
function GetViewInfoCacheClass: TcxCustomGridViewInfoCacheClass; virtual;
|
|
function GetViewInfoClass: TcxCustomGridViewInfoClass; virtual; abstract;
|
|
|
|
function GetBackgroundBitmapsClass: TcxCustomGridBackgroundBitmapsClass; virtual;
|
|
function GetOptionsBehaviorClass: TcxCustomGridOptionsBehaviorClass; virtual;
|
|
function GetOptionsDataClass: TcxCustomGridOptionsDataClass; virtual;
|
|
function GetOptionsSelectionClass: TcxCustomGridOptionsSelectionClass; virtual;
|
|
function GetOptionsViewClass: TcxCustomGridOptionsViewClass; virtual;
|
|
function GetStylesClass: TcxCustomGridViewStylesClass; virtual;
|
|
|
|
procedure Initialize; override;
|
|
|
|
procedure RefreshCustomizationForm;
|
|
|
|
procedure DoCustomization; virtual;
|
|
procedure DoInitStoredObject(AObject: TObject); virtual;
|
|
|
|
property BackgroundBitmaps: TcxCustomGridBackgroundBitmaps read FBackgroundBitmaps
|
|
write SetBackgroundBitmaps; {4}
|
|
property Changeable: Boolean read GetChangeable;
|
|
property IsStoringNameMode: Boolean read GetIsStoringNameMode;
|
|
property IsSynchronizing: Boolean read FIsSynchronizing;
|
|
property IsUpdating: Boolean read GetIsUpdating;
|
|
property OptionsBehavior: TcxCustomGridOptionsBehavior read FOptionsBehavior
|
|
write SetOptionsBehavior;
|
|
property OptionsData: TcxCustomGridOptionsData read FOptionsData write SetOptionsData;
|
|
property OptionsSelection: TcxCustomGridOptionsSelection read FOptionsSelection
|
|
write SetOptionsSelection;
|
|
property OptionsView: TcxCustomGridOptionsView read FOptionsView write SetOptionsView;
|
|
property ResizeOnBoundsChange: Boolean read GetResizeOnBoundsChange;
|
|
property StoredVersion: Integer read FStoredVersion;
|
|
property Styles: TcxCustomGridStyles read FStyles write SetStyles;
|
|
property OnCustomization: TNotifyEvent read FOnCustomization write SetOnCustomization;
|
|
property OnInitStoredObject: TcxGridInitStoredObjectEvent read FOnInitStoredObject write SetOnInitStoredObject;
|
|
public
|
|
constructor CreateCloned(AControl: TcxControl); virtual;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure AssignSettings(ASource: TcxCustomGridView);
|
|
function GetParentComponent: TComponent; override;
|
|
function HasParent: Boolean; override;
|
|
function HasAsClone(AGridView: TcxCustomGridView): Boolean;
|
|
function HasAsMaster(AGridView: TcxCustomGridView): Boolean;
|
|
procedure Invalidate(AHardUpdate: Boolean = False);
|
|
procedure RestoreDefaults; virtual;
|
|
procedure SetParentComponent(Value: TComponent); override;
|
|
|
|
procedure CheckSynchronizationAssignNeeded;
|
|
function IsSynchronization: Boolean;
|
|
|
|
procedure BeginUpdate;
|
|
procedure CancelUpdate;
|
|
function Changed(AGridChange: TObject): Boolean; overload; {$IFDEF BCB}virtual;{$ENDIF}
|
|
procedure EndUpdate;
|
|
function IsUpdateLocked: Boolean;
|
|
|
|
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; overload; {$IFDEF BCB}virtual;{$ENDIF}
|
|
function GetHitTest(X, Y: Integer): TcxCustomGridHitTest; overload; {$IFDEF BCB}virtual;{$ENDIF}
|
|
|
|
procedure BoundsChanged(AUpdateSelfOnly: Boolean = False; AKeepMaster: Boolean = False); virtual;
|
|
procedure Changed(AChangeKind: TcxGridViewChangeKind); overload; {$IFDEF BCB}virtual;{$ENDIF}
|
|
procedure LayoutChanged(AUpdateSelfOnly: Boolean = True);
|
|
function SizeChanged(AUpdateSelfOnly: Boolean = False; AKeepMaster: Boolean = False): Boolean;
|
|
procedure ViewChanged; overload; {$IFDEF BCB}virtual;{$ENDIF}
|
|
procedure ViewChanged(const AUpdateRect: TRect); overload; {$IFDEF BCB}virtual;{$ENDIF}
|
|
procedure ViewChanged(ARegion: TcxRegion); overload; {$IFDEF BCB}virtual;{$ENDIF}
|
|
|
|
procedure RestoreFromIniFile(const AStorageName: string; AChildrenCreating: Boolean = True{False};
|
|
AChildrenDeleting: Boolean = False; AOptions: TcxGridStorageOptions = [gsoUseFilter, gsoUseSummary]{[]};
|
|
const ARestoreViewName: string = '');
|
|
procedure RestoreFromRegistry(const AStorageName: string; AChildrenCreating: Boolean = True{False};
|
|
AChildrenDeleting: Boolean = False; AOptions: TcxGridStorageOptions = [gsoUseFilter, gsoUseSummary]{[]};
|
|
const ARestoreViewName: string = '');
|
|
procedure RestoreFromStream(AStream: TStream; AChildrenCreating: Boolean = True{False};
|
|
AChildrenDeleting: Boolean = False; AOptions: TcxGridStorageOptions = [gsoUseFilter, gsoUseSummary]{[]};
|
|
const ARestoreViewName: string = '');
|
|
procedure RestoreFromStorage(const AStorageName: string; AReaderClass: TcxCustomReaderClass;
|
|
AChildrenCreating: Boolean = True; AChildrenDeleting: Boolean = False;
|
|
AOptions: TcxGridStorageOptions = [gsoUseFilter, gsoUseSummary];
|
|
const ARestoreViewName: string = '');
|
|
|
|
procedure StoreToIniFile(const AStorageName: string; AReCreate: Boolean = True;
|
|
AOptions: TcxGridStorageOptions = []; const ASaveViewName: string = '');
|
|
procedure StoreToRegistry(const AStorageName: string; AReCreate: Boolean = True;
|
|
AOptions: TcxGridStorageOptions = []; const ASaveViewName: string = '');
|
|
procedure StoreToStream(AStream: TStream; AOptions: TcxGridStorageOptions = [];
|
|
const ASaveViewName: string = '');
|
|
procedure StoreToStorage(const AStorageName: string; AWriterClass: TcxCustomWriterClass;
|
|
AReCreate: Boolean = True; AOptions: TcxGridStorageOptions = []; const ASaveViewName: string = '');
|
|
|
|
function CreateViewInfo: TcxCustomGridViewInfo;
|
|
|
|
property Focused: Boolean read GetFocused write SetFocused;
|
|
property StorageOptions: TcxGridStorageOptions read FStorageOptions write FStorageOptions;
|
|
property StoringName: string read FStoringName write FStoringName;
|
|
property TabStop: Boolean write SetTabStop;
|
|
|
|
property CloneCount: Integer read GetCloneCount;
|
|
property Clones[Index: Integer]: TcxCustomGridView read GetClone;
|
|
property IsControlFocused: Boolean read GetIsControlFocusedValue;
|
|
property IsDetail: Boolean read GetIsDetail;
|
|
property IsMaster: Boolean read GetIsMaster;
|
|
property IsPattern: Boolean read GetIsPattern;
|
|
property Level: TComponent read FLevel; // TcxGridLevel
|
|
property MasterGridView: TcxCustomGridView read GetMasterGridView;
|
|
property MasterGridRecordIndex: Integer read GetMasterGridRecordIndex;
|
|
property MasterRecordIndex: Integer read GetMasterRecordIndex;
|
|
property PatternGridView: TcxCustomGridView read GetPatternGridView;
|
|
property Repository: TComponent read FRepository write FRepository; {5}
|
|
|
|
property Controller: TcxCustomGridController read FController;
|
|
property DataController: TcxCustomDataController read FDataController;
|
|
property LookAndFeel: TcxLookAndFeel read GetLookAndFeel;
|
|
property LookAndFeelPainter: TcxCustomLookAndFeelPainterClass read GetLookAndFeelPainter;
|
|
property Painter: TcxCustomGridPainter read FPainter;
|
|
property Site: TcxGridSite read GetSite;
|
|
property StorageControl: TcxControl read FStorageControl;
|
|
property ViewData: TcxCustomGridViewData read FViewData;
|
|
property ViewInfo: TcxCustomGridViewInfo read FViewInfo;
|
|
property ViewInfoCache: TcxCustomGridViewInfoCache read FViewInfoCache;
|
|
property Visible: Boolean read GetVisible;
|
|
published
|
|
property DataControllerEvents: TNotifyEvent read FSubClassEvents write FSubClassEvents;
|
|
property DragMode: TDragMode read GetDragMode write SetDragMode default dmManual;
|
|
property PopupMenu: TComponent read GetPopupMenu write SetPopupMenu;
|
|
property StylesEvents: TNotifyEvent read FSubClassEvents write FSubClassEvents;
|
|
property Synchronization: Boolean read GetSynchronization write SetSynchronization default True{False};
|
|
|
|
property OnDblClick: TNotifyEvent read GetOnDblClick write SetOnDblClick;
|
|
property OnDragDrop: TDragDropEvent read GetOnDragDrop write SetOnDragDrop;
|
|
property OnDragOver: TDragOverEvent read GetOnDragOver write SetOnDragOver;
|
|
property OnEndDrag: TEndDragEvent read GetOnEndDrag write SetOnEndDrag;
|
|
property OnKeyDown: TKeyEvent read GetOnKeyDown write SetOnKeyDown;
|
|
property OnKeyPress: TKeyPressEvent read GetOnKeyPress write SetOnKeyPress;
|
|
property OnKeyUp: TKeyEvent read GetOnKeyUp write SetOnKeyUp;
|
|
property OnMouseDown: TMouseEvent read GetOnMouseDown write SetOnMouseDown;
|
|
property OnMouseEnter: TNotifyEvent read GetOnMouseEnter write SetOnMouseEnter;
|
|
property OnMouseLeave: TNotifyEvent read GetOnMouseLeave write SetOnMouseLeave;
|
|
property OnMouseMove: TMouseMoveEvent read GetOnMouseMove write SetOnMouseMove;
|
|
property OnMouseUp: TMouseEvent read GetOnMouseUp write SetOnMouseUp;
|
|
property OnMouseWheel: TMouseWheelEvent read GetOnMouseWheel write SetOnMouseWheel;
|
|
property OnMouseWheelDown: TMouseWheelUpDownEvent read GetOnMouseWheelDown write SetOnMouseWheelDown;
|
|
property OnMouseWheelUp: TMouseWheelUpDownEvent read GetOnMouseWheelUp write SetOnMouseWheelUp;
|
|
property OnStartDrag: TStartDragEvent read GetOnStartDrag write SetOnStartDrag;
|
|
|
|
property OnGetStoredProperties: TcxGridViewGetStoredPropertiesEvent
|
|
read FOnGetStoredProperties write SetOnGetStoredProperties;
|
|
property OnGetStoredPropertyValue: TcxGridViewGetStoredPropertyValueEvent
|
|
read FOnGetStoredPropertyValue write SetOnGetStoredPropertyValue;
|
|
property OnSetStoredPropertyValue: TcxGridViewSetStoredPropertyValueEvent
|
|
read FOnSetStoredPropertyValue write SetOnSetStoredPropertyValue;
|
|
end;
|
|
|
|
{ TcxCustomGridViewAccess }
|
|
|
|
TcxCustomGridViewAccess = class
|
|
class procedure AddClone(AInstance: TcxCustomGridView; AClone: TcxCustomGridView);
|
|
class procedure AssignPattern(AInstance: TcxCustomGridView; APattern: TcxCustomGridView);
|
|
class function CanFocus(AInstance: TcxCustomGridView): Boolean;
|
|
class procedure DetailVisibleChanged(AInstance: TcxCustomGridView;
|
|
ADetailLevel: TComponent; APrevVisibleDetailCount, AVisibleDetailCount: Integer);
|
|
class procedure FocusChanged(AInstance: TcxCustomGridView; AFocused: Boolean);
|
|
class procedure LookAndFeelChanged(AInstance: TcxCustomGridView);
|
|
class procedure SetLevel(AInstance: TcxCustomGridView; Value: TComponent);
|
|
|
|
class function GetChangeable(AInstance: TcxCustomGridView): Boolean;
|
|
class function GetStyles(AInstance: TcxCustomGridView): TcxCustomGridStyles;
|
|
end;
|
|
|
|
function GetGridViewDataController(AView: TcxCustomGridView): TcxCustomDataController;
|
|
function GetParentGridView(AControl: TControl): TcxCustomGridView;
|
|
|
|
var
|
|
cxGridRegisteredViews: TcxRegisteredClasses;
|
|
|
|
implementation
|
|
|
|
uses
|
|
SysUtils, Math, ImgList, cxGeometry, cxScrollBar, cxVariants, cxLibraryConsts,
|
|
cxGrid, cxGridLevel, cxGridStrs;
|
|
|
|
const
|
|
CheckOffset = 2;
|
|
|
|
DesignSelectorWidth = 20;
|
|
DesignSelectorHeight = 20;
|
|
|
|
type
|
|
TCustomFormAccess = class(TCustomForm);
|
|
TcxControlAccess = class(TcxControl);
|
|
TcxCustomGridAccess = class(TcxCustomGrid);
|
|
TcxGridViewRepositoryAccess = class(TcxGridViewRepository);
|
|
|
|
{ TGridHitTests }
|
|
|
|
type
|
|
TGridHitTests = class
|
|
private
|
|
FItems: TList;
|
|
function GetCount: Integer;
|
|
function GetInstance(AClass: TcxCustomGridHitTestClass): TcxCustomGridHitTest;
|
|
function GetItem(Index: Integer): TcxCustomGridHitTest;
|
|
protected
|
|
function GetObjectByClass(AClass: TcxCustomGridHitTestClass): TcxCustomGridHitTest;
|
|
property Count: Integer read GetCount;
|
|
property Items[Index: Integer]: TcxCustomGridHitTest read GetItem;
|
|
public
|
|
constructor Create;
|
|
destructor Destroy; override;
|
|
property Instances[AClass: TcxCustomGridHitTestClass]: TcxCustomGridHitTest read GetInstance; default;
|
|
end;
|
|
|
|
var
|
|
GridHitTests: TGridHitTests;
|
|
|
|
constructor TGridHitTests.Create;
|
|
begin
|
|
inherited;
|
|
FItems := TList.Create;
|
|
end;
|
|
|
|
destructor TGridHitTests.Destroy;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to Count - 1 do
|
|
Items[I].Free;
|
|
FItems.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TGridHitTests.GetCount: Integer;
|
|
begin
|
|
Result := FItems.Count;
|
|
end;
|
|
|
|
function TGridHitTests.GetInstance(AClass: TcxCustomGridHitTestClass): TcxCustomGridHitTest;
|
|
begin
|
|
Result := GetObjectByClass(AClass);
|
|
if Result = nil then
|
|
begin
|
|
Result := AClass.Create;
|
|
FItems.Add(Result);
|
|
end;
|
|
end;
|
|
|
|
function TGridHitTests.GetItem(Index: Integer): TcxCustomGridHitTest;
|
|
begin
|
|
Result := TcxCustomGridHitTest(FItems[Index]);
|
|
end;
|
|
|
|
function TGridHitTests.GetObjectByClass(AClass: TcxCustomGridHitTestClass): TcxCustomGridHitTest;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to Count - 1 do
|
|
begin
|
|
Result := Items[I];
|
|
if Result.ClassType = AClass then Exit;
|
|
end;
|
|
Result := nil;
|
|
end;
|
|
|
|
{ TcxCustomGridViewChange }
|
|
|
|
constructor TcxCustomGridViewChange.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited Create;
|
|
FGridView := AGridView;
|
|
end;
|
|
|
|
function TcxCustomGridViewChange.IsEqual(AChange: TcxCustomGridChange): Boolean;
|
|
begin
|
|
Result := inherited IsEqual(AChange) and
|
|
(FGridView = TcxCustomGridViewChange(AChange).GridView);
|
|
end;
|
|
|
|
{ TcxGridControlFocusChange }
|
|
|
|
procedure TcxGridControlFocusChange.Execute;
|
|
begin
|
|
if GridView.Changeable then
|
|
GridView.Controller.ControlFocusChanged;
|
|
end;
|
|
|
|
{ TcxCustomGridHitTest }
|
|
|
|
destructor TcxCustomGridHitTest.Destroy;
|
|
begin
|
|
ViewInfo := nil;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxCustomGridHitTest.SetViewInfo(Value: TcxCustomGridCellViewInfo);
|
|
var
|
|
APrevViewInfo: TcxCustomGridCellViewInfo;
|
|
begin
|
|
if FViewInfo <> Value then
|
|
begin
|
|
APrevViewInfo := FViewInfo;
|
|
FViewInfo := Value;
|
|
if (APrevViewInfo <> nil) and (APrevViewInfo.LinkedHitTest = Self) then
|
|
APrevViewInfo.LinkedHitTest := nil;
|
|
if FViewInfo <> nil then
|
|
FViewInfo.LinkedHitTest := Self;
|
|
end;
|
|
end;
|
|
|
|
class function TcxCustomGridHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htError;
|
|
end;
|
|
|
|
procedure TcxCustomGridHitTest.Init(const APos: TPoint);
|
|
begin
|
|
FPos := APos;
|
|
end;
|
|
|
|
function TcxCustomGridHitTest.Cursor: TCursor;
|
|
begin
|
|
Result := crDefault;
|
|
end;
|
|
|
|
function TcxCustomGridHitTest.DragAndDropObjectClass: TcxCustomGridDragAndDropObjectClass;
|
|
begin
|
|
Result := nil;
|
|
end;
|
|
|
|
class function TcxCustomGridHitTest.HitTestCode: Integer;
|
|
begin
|
|
Result := GetHitTestCode;
|
|
end;
|
|
|
|
class function TcxCustomGridHitTest.Instance(const APos: TPoint): TcxCustomGridHitTest;
|
|
begin
|
|
Result := GridHitTests.Instances[Self];
|
|
Result.Init(APos);
|
|
end;
|
|
|
|
{ TcxGridHitTestNone }
|
|
|
|
class function TcxGridNoneHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htNone;
|
|
end;
|
|
|
|
{ TcxGridViewNoneHitTest }
|
|
|
|
class function TcxGridViewNoneHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htNone;
|
|
end;
|
|
|
|
{ TcxGridNavigatorHitTest }
|
|
|
|
class function TcxGridNavigatorHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htNavigator;
|
|
end;
|
|
|
|
{ TcxGridCustomizationFormHitTest }
|
|
|
|
class function TcxGridCustomizationFormHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htCustomizationForm;
|
|
end;
|
|
|
|
{ TcxGridDesignSelectorHitTest }
|
|
|
|
class function TcxGridDesignSelectorHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htDesignSelector;
|
|
end;
|
|
|
|
function TcxGridDesignSelectorHitTest.Cursor: TCursor;
|
|
begin
|
|
Result := crcxHandPoint;
|
|
end;
|
|
|
|
{ TcxGridViewHandler }
|
|
|
|
constructor TcxGridViewHandler.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited Create(nil);
|
|
FGridView := AGridView;
|
|
end;
|
|
|
|
function TcxGridViewHandler.GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
|
|
begin
|
|
Result := FGridView.LookAndFeelPainter;
|
|
end;
|
|
|
|
function TcxGridViewHandler.GetControl: TcxControl;
|
|
begin
|
|
Result := FGridView.Control;
|
|
end;
|
|
|
|
function TcxGridViewHandler.GetController: TcxCustomGridController;
|
|
begin
|
|
Result := FGridView.Controller;
|
|
end;
|
|
|
|
function TcxGridViewHandler.GetDataController: TcxCustomDataController;
|
|
begin
|
|
Result := FGridView.DataController;
|
|
end;
|
|
|
|
function TcxGridViewHandler.GetPainter: TcxCustomGridPainter;
|
|
begin
|
|
Result := FGridView.Painter;
|
|
end;
|
|
|
|
function TcxGridViewHandler.GetSite: TcxGridSite;
|
|
begin
|
|
Result := FGridView.Site;
|
|
end;
|
|
|
|
function TcxGridViewHandler.GetViewData: TcxCustomGridViewData;
|
|
begin
|
|
Result := FGridView.ViewData;
|
|
end;
|
|
|
|
function TcxGridViewHandler.GetViewInfo: TcxCustomGridViewInfo;
|
|
begin
|
|
Result := FGridView.ViewInfo;
|
|
end;
|
|
|
|
procedure TcxGridViewHandler.BeginUpdate;
|
|
begin
|
|
FGridView.BeginUpdate;
|
|
end;
|
|
|
|
procedure TcxGridViewHandler.EndUpdate;
|
|
begin
|
|
FGridView.EndUpdate;
|
|
end;
|
|
|
|
{ TcxCustomGridDragAndDropObject }
|
|
|
|
function TcxCustomGridDragAndDropObject.GetController: TcxCustomGridController;
|
|
begin
|
|
Result := GridView.Controller;
|
|
end;
|
|
|
|
function TcxCustomGridDragAndDropObject.GetGridView: TcxCustomGridView;
|
|
begin
|
|
Result := TcxGridSite(Control).GridView;
|
|
end;
|
|
|
|
function TcxCustomGridDragAndDropObject.GetViewInfo: TcxCustomGridViewInfo;
|
|
begin
|
|
Result := GridView.ViewInfo;
|
|
end;
|
|
|
|
procedure TcxCustomGridDragAndDropObject.AfterDragAndDrop(Accepted: Boolean);
|
|
begin
|
|
inherited;
|
|
if Accepted then Controller.DesignerModified;
|
|
end;
|
|
|
|
procedure TcxCustomGridDragAndDropObject.AfterPaint;
|
|
begin
|
|
AfterViewChange;
|
|
end;
|
|
|
|
procedure TcxCustomGridDragAndDropObject.BeforePaint;
|
|
begin
|
|
BeforeViewChange;
|
|
end;
|
|
|
|
procedure TcxCustomGridDragAndDropObject.AfterScrolling;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridDragAndDropObject.BeforeScrolling;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridDragAndDropObject.AfterViewChange;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridDragAndDropObject.BeforeViewChange;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridDragAndDropObject.Init(const P: TPoint; AParams: TcxCustomGridHitTest);
|
|
begin
|
|
SourcePoint := P;
|
|
end;
|
|
|
|
{ TcxCustomGridMovingObject }
|
|
|
|
function TcxCustomGridMovingObject.GetArrowPlace(AArrowNumber: TcxGridArrowNumber): TcxGridArrowPlace;
|
|
begin
|
|
if AreArrowsVertical then
|
|
if AArrowNumber = anFirst then
|
|
Result := apTop
|
|
else
|
|
Result := apBottom
|
|
else
|
|
if AArrowNumber = anFirst then
|
|
Result := apLeft
|
|
else
|
|
Result := apRight;
|
|
end;
|
|
|
|
function TcxCustomGridMovingObject.GetCustomizationForm: TcxCustomGridCustomizationForm;
|
|
begin
|
|
Result := Controller.CustomizationForm;
|
|
end;
|
|
|
|
procedure TcxCustomGridMovingObject.DirtyChanged;
|
|
begin
|
|
inherited;
|
|
ChangeArrowsPosition(not Dirty);
|
|
ChangeDragImagePosition(not Dirty);
|
|
end;
|
|
|
|
function TcxCustomGridMovingObject.GetDragAndDropCursor(Accepted: Boolean): TCursor;
|
|
begin
|
|
if Accepted then
|
|
Result := crArrow
|
|
else
|
|
if CanRemove then
|
|
Result := crcxGridRemove
|
|
else
|
|
Result := crcxGridNoDrop;
|
|
end;
|
|
|
|
procedure TcxCustomGridMovingObject.ChangeArrowsPosition(AVisible: Boolean = True);
|
|
var
|
|
AArrowNumber: TcxGridArrowNumber;
|
|
begin
|
|
if AVisible and not IsValidDestination then
|
|
AVisible := False;
|
|
for AArrowNumber := Low(Arrows) to High(Arrows) do
|
|
begin
|
|
if AVisible then
|
|
Arrows[AArrowNumber].Init(GridView.Site, GetArrowAreaBounds(ArrowPlaces[AArrowNumber]),
|
|
ArrowsClientRect, ArrowPlaces[AArrowNumber]);
|
|
Arrows[AArrowNumber].Visible := AVisible;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridMovingObject.ChangeDragImagePosition(AVisible: Boolean = True);
|
|
begin
|
|
if AVisible then
|
|
DragImage.MoveTo(Control.ClientToScreen(CurMousePos));
|
|
DragImage.Visible := AVisible;
|
|
end;
|
|
|
|
function TcxCustomGridMovingObject.AreArrowsVertical: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TcxCustomGridMovingObject.GetArrowClass: TcxDragAndDropArrowClass;
|
|
begin
|
|
Result := TcxDragAndDropArrow;
|
|
end;
|
|
|
|
function TcxCustomGridMovingObject.GetArrowsClientRect: TRect;
|
|
begin
|
|
Result := ViewInfo.Bounds;
|
|
end;
|
|
|
|
function TcxCustomGridMovingObject.GetDragImageClass: TcxDragImageClass;
|
|
begin
|
|
Result := TcxDragImage;
|
|
end;
|
|
|
|
function TcxCustomGridMovingObject.GetSourceItemBounds: TRect;
|
|
begin
|
|
if SourceItemViewInfo <> nil then
|
|
Result := SourceItemViewInfo.Bounds
|
|
else
|
|
if IsSourceCustomizationForm and (CustomizationFormListBox <> nil) then
|
|
with CustomizationFormListBox do
|
|
begin
|
|
Result := ItemRect(IndexOfItem(SourceItem));
|
|
MapWindowRect(Handle, Control.Handle, Result);
|
|
end
|
|
else
|
|
Result := Rect(0, 0, 0, 0);
|
|
end;
|
|
|
|
function TcxCustomGridMovingObject.GetSourceItemViewInfo: TcxCustomGridCellViewInfo;
|
|
begin
|
|
Result := nil;
|
|
end;
|
|
|
|
procedure TcxCustomGridMovingObject.InitDragImage;
|
|
|
|
procedure InitUsingSourceItemViewInfo;
|
|
var
|
|
AViewInfo: TcxCustomGridCellViewInfo;
|
|
begin
|
|
AViewInfo := SourceItemViewInfo;
|
|
with AViewInfo.Bounds.TopLeft do
|
|
SetViewportOrgEx(DragImage.Canvas.Handle, -X, -Y, nil);
|
|
AViewInfo.Paint(DragImage.Canvas);
|
|
end;
|
|
|
|
procedure InitFromCustomizationForm;
|
|
var
|
|
R: TRect;
|
|
begin
|
|
R := SourceItemBounds;
|
|
with R do
|
|
OffsetRect(R, -Left, -Top);
|
|
InitDragImageUsingCustomizationForm(DragImage.Canvas, R, SourceItem);
|
|
end;
|
|
|
|
begin
|
|
DragImage.Init(SourceItemBounds, SourcePoint);
|
|
if SourceItemViewInfo <> nil then
|
|
InitUsingSourceItemViewInfo
|
|
else
|
|
if IsSourceCustomizationForm then
|
|
InitFromCustomizationForm;
|
|
end;
|
|
|
|
procedure TcxCustomGridMovingObject.InitDragImageUsingCustomizationForm(ACanvas: TcxCanvas;
|
|
const R: TRect; AItem: TObject);
|
|
begin
|
|
if CustomizationFormListBox <> nil then
|
|
CustomizationFormListBox.PaintDragAndDropItem(ACanvas, R, AItem);
|
|
end;
|
|
|
|
procedure TcxCustomGridMovingObject.BeginDragAndDrop;
|
|
var
|
|
AArrowNumber: TcxGridArrowNumber;
|
|
begin
|
|
FDragImage := GetDragImageClass.Create;
|
|
InitDragImage;
|
|
for AArrowNumber := Low(Arrows) to High(Arrows) do
|
|
Arrows[AArrowNumber] := GetArrowClass.Create(DragImage.AlphaBlended);
|
|
GridView.Control.UpdateWithChildren;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxCustomGridMovingObject.DragAndDrop(const P: TPoint; var Accepted: Boolean);
|
|
begin
|
|
inherited;
|
|
ChangeDragImagePosition;
|
|
end;
|
|
|
|
procedure TcxCustomGridMovingObject.EndDragAndDrop(Accepted: Boolean);
|
|
var
|
|
AArrowNumber: TcxGridArrowNumber;
|
|
begin
|
|
inherited;
|
|
for AArrowNumber := Low(Arrows) to High(Arrows) do
|
|
FreeAndNil(Arrows[AArrowNumber]);
|
|
FreeAndNil(FDragImage);
|
|
end;
|
|
|
|
procedure TcxCustomGridMovingObject.AfterScrolling;
|
|
begin
|
|
ChangeArrowsPosition;
|
|
inherited;
|
|
end;
|
|
|
|
{ TcxCustomGridItemsInnerListBox }
|
|
|
|
constructor TcxCustomGridItemsInnerListBox.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
Sorted := True;
|
|
Style := lbOwnerDrawFixed;
|
|
CalculateBorderStyle;
|
|
FDragAndDropItemIndex := -1;
|
|
end;
|
|
|
|
function TcxCustomGridItemsInnerListBox.GetContainer: TcxCustomGridItemsListBox;
|
|
begin
|
|
Result := TcxCustomGridItemsListBox(inherited Container);
|
|
end;
|
|
|
|
function TcxCustomGridItemsInnerListBox.GetDragAndDropItem: TObject;
|
|
begin
|
|
Result := Items.Objects[FDragAndDropItemIndex];
|
|
end;
|
|
|
|
function TcxCustomGridItemsInnerListBox.GetGridView: TcxCustomGridView;
|
|
begin
|
|
Result := Container.GridView;
|
|
end;
|
|
|
|
function TcxCustomGridItemsInnerListBox.GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
|
|
begin
|
|
Result := LookAndFeel.Painter;
|
|
end;
|
|
|
|
procedure TcxCustomGridItemsInnerListBox.WMCancelMode(var Message: TWMCancelMode);
|
|
begin
|
|
inherited;
|
|
FDragAndDropItemIndex := -1;
|
|
end;
|
|
|
|
procedure TcxCustomGridItemsInnerListBox.WMNCCalcSize(var Message: TWMNCCalcSize);
|
|
begin
|
|
inherited;
|
|
if BorderStyle = bsNone then
|
|
InflateRect(Message.CalcSize_Params^.rgrc[0], -1, -1);
|
|
end;
|
|
|
|
procedure TcxCustomGridItemsInnerListBox.WMNCPaint(var Message: TWMNCPaint);
|
|
var
|
|
R: TRect;
|
|
DC: HDC;
|
|
begin
|
|
inherited;
|
|
if BorderStyle = bsNone then
|
|
begin
|
|
R := cxGetWindowRect(Handle);
|
|
OffsetRect(R, -R.Left, -R.Top);
|
|
DC := GetWindowDC(Handle);
|
|
DrawEdge(DC, R, BDR_SUNKENOUTER, BF_RECT);
|
|
ReleaseDC(Handle, DC);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridItemsInnerListBox.CreateParams(var Params: TCreateParams);
|
|
begin
|
|
inherited;
|
|
with Params do
|
|
WindowClass.Style := WindowClass.Style or CS_HREDRAW;
|
|
end;
|
|
|
|
procedure TcxCustomGridItemsInnerListBox.CreateWnd;
|
|
begin
|
|
inherited;
|
|
CalculateItemHeight;
|
|
end;
|
|
|
|
procedure TcxCustomGridItemsInnerListBox.DrawItem(Index: Integer; Rect: TRect;
|
|
State: TOwnerDrawState);
|
|
begin
|
|
Container.PaintItem(Canvas, Rect, Index, odFocused in State);
|
|
if odFocused in State then Canvas.DrawFocusRect(Rect);
|
|
end;
|
|
|
|
procedure TcxCustomGridItemsInnerListBox.KeyDown(var Key: Word; Shift: TShiftState);
|
|
begin
|
|
inherited;
|
|
if Key = VK_ESCAPE then
|
|
GridView.Site.FinishDragAndDrop(False);
|
|
end;
|
|
|
|
procedure TcxCustomGridItemsInnerListBox.LookAndFeelChanged(Sender: TcxLookAndFeel;
|
|
AChangedValues: TcxLookAndFeelValues);
|
|
begin
|
|
CalculateBorderStyle;
|
|
CalculateItemHeight;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxCustomGridItemsInnerListBox.MouseDown(Button: TMouseButton;
|
|
Shift: TShiftState; X, Y: Integer);
|
|
var
|
|
AItemIndex: Integer;
|
|
begin
|
|
inherited;
|
|
if Button = mbLeft then
|
|
begin
|
|
AItemIndex := ItemAtPos(Point(X, Y), True);
|
|
if AItemIndex <> -1 then
|
|
begin
|
|
FDragAndDropItemIndex := AItemIndex;
|
|
FMouseDownPos := Point(X, Y);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridItemsInnerListBox.MouseMove(Shift: TShiftState; X, Y: Integer);
|
|
var
|
|
AParams: TcxCustomGridHitTest;
|
|
P: TPoint;
|
|
begin
|
|
inherited;
|
|
if (FDragAndDropItemIndex <> -1) and
|
|
(not IsPointInDragDetectArea(FMouseDownPos, X, Y) or
|
|
(ItemAtPos(Point(X, Y), False) <> FDragAndDropItemIndex)) then
|
|
begin
|
|
ItemIndex := FDragAndDropItemIndex;
|
|
AParams := Container.GetDragAndDropParams;
|
|
with GridView do
|
|
begin
|
|
P := FMouseDownPos;
|
|
P := Site.ScreenToClient(ClientToScreen(P));
|
|
Controller.DragAndDropObjectClass := AParams.DragAndDropObjectClass;
|
|
Controller.DragAndDropObject.Init(P, AParams);
|
|
Site.BeginDragAndDrop;
|
|
end;
|
|
FDragAndDropItemIndex := -1;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridItemsInnerListBox.MouseUp(Button: TMouseButton; Shift: TShiftState;
|
|
X, Y: Integer);
|
|
begin
|
|
inherited;
|
|
FDragAndDropItemIndex := -1;
|
|
end;
|
|
|
|
procedure TcxCustomGridItemsInnerListBox.CalculateBorderStyle;
|
|
begin
|
|
if LookAndFeelPainter.HeaderBorderSize <= 1 then
|
|
BorderStyle := bsNone
|
|
else
|
|
BorderStyle := bsSingle;
|
|
end;
|
|
|
|
procedure TcxCustomGridItemsInnerListBox.CalculateItemHeight;
|
|
begin
|
|
if HandleAllocated then
|
|
ItemHeight := Container.CalculateItemHeight;
|
|
end;
|
|
|
|
{ TcxCustomGridItemsListBox }
|
|
|
|
constructor TcxCustomGridItemsListBox.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
with Style do
|
|
begin
|
|
BorderStyle := cbsNone;
|
|
HotTrack := False;
|
|
LookAndFeel.MasterLookAndFeel := GridView.LookAndFeel;
|
|
TransparentBorder := False;
|
|
end;
|
|
StyleFocused.BorderStyle := cbsNone;
|
|
StyleHot.BorderStyle := cbsNone;
|
|
ParentFont := True;
|
|
end;
|
|
|
|
function TcxCustomGridItemsListBox.GetDragAndDropItem: TObject;
|
|
begin
|
|
Result := InnerListBox.DragAndDropItem;
|
|
end;
|
|
|
|
function TcxCustomGridItemsListBox.GetGridView: TcxCustomGridView;
|
|
begin
|
|
Result := (Owner as TcxCustomGridCustomizationForm).GridView;
|
|
end;
|
|
|
|
function TcxCustomGridItemsListBox.GetInnerListBox: TcxCustomGridItemsInnerListBox;
|
|
begin
|
|
Result := TcxCustomGridItemsInnerListBox(inherited InnerListBox);
|
|
end;
|
|
|
|
function TcxCustomGridItemsListBox.GetInnerListBoxClass: TcxInnerListBoxClass;
|
|
begin
|
|
Result := TcxCustomGridItemsInnerListBox;
|
|
end;
|
|
|
|
function TcxCustomGridItemsListBox.IndexOfItem(AItem: TObject): Integer;
|
|
begin
|
|
Result := Items.IndexOfObject(AItem);
|
|
end;
|
|
|
|
procedure TcxCustomGridItemsListBox.PaintDragAndDropItem(ACanvas: TcxCanvas;
|
|
const R: TRect; AItem: TObject);
|
|
begin
|
|
ACanvas.Brush.Color := Color;
|
|
ACanvas.Font := Font;
|
|
PaintItem(ACanvas, R, IndexOfItem(AItem), False);
|
|
end;
|
|
|
|
procedure TcxCustomGridItemsListBox.RefreshItems;
|
|
var
|
|
ATopIndex, AItemIndex: Integer;
|
|
begin
|
|
InnerListBox.CalculateItemHeight;
|
|
|
|
ATopIndex := TopIndex;
|
|
AItemIndex := ItemIndex;
|
|
Items.BeginUpdate;
|
|
try
|
|
DoRefreshItems;
|
|
TopIndex := ATopIndex;
|
|
ItemIndex := Min(AItemIndex, Items.Count - 1);
|
|
finally
|
|
Items.EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
{ TcxCustomGridCustomizationForm }
|
|
|
|
// TODO: system menu
|
|
|
|
constructor TcxCustomGridCustomizationForm.Create(AController: TcxCustomGridController);
|
|
begin
|
|
inherited CreateNew(nil);
|
|
FController := AController;
|
|
Caption := cxGetResourceString(@scxGridCustomizationFormCaption);
|
|
BorderStyle := bsSizeToolWin;
|
|
Font := TcxControlAccess(Controller.Control).Font;
|
|
CalculateConsts;
|
|
CreateControls;
|
|
end;
|
|
|
|
destructor TcxCustomGridCustomizationForm.Destroy;
|
|
begin
|
|
FHookTimer.Free;
|
|
FController.Customization := False;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxCustomGridCustomizationForm.GetGridView: TcxCustomGridView;
|
|
begin
|
|
Result := FController.GridView;
|
|
end;
|
|
|
|
function TcxCustomGridCustomizationForm.GetViewInfo: TcxCustomGridViewInfo;
|
|
begin
|
|
Result := FController.ViewInfo;
|
|
end;
|
|
|
|
procedure TcxCustomGridCustomizationForm.HookTimerHandler(Sender: TObject);
|
|
begin
|
|
if IsIconic(Application.Handle) then
|
|
Visible := False
|
|
else
|
|
if not GridView.Visible or not IsWindowVisible(FController.Site.Handle) then
|
|
FController.Customization := False
|
|
else
|
|
if not Visible then
|
|
begin
|
|
ShowWindow(Handle, SW_SHOWNOACTIVATE);
|
|
Visible := True;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridCustomizationForm.CreateParams(var Params: TCreateParams);
|
|
begin
|
|
inherited;
|
|
with Params do
|
|
begin
|
|
Style := Style or WS_POPUP;
|
|
WndParent := FController.Site.Handle;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridCustomizationForm.DoClose(var Action: TCloseAction);
|
|
begin
|
|
FreeAndNil(FHookTimer);
|
|
Action := caFree;
|
|
end;
|
|
|
|
procedure TcxCustomGridCustomizationForm.DoShow;
|
|
begin
|
|
if FHookTimer = nil then
|
|
begin
|
|
FHookTimer := TcxTimer.Create(nil);
|
|
with FHookTimer do
|
|
begin
|
|
Interval := 100;
|
|
OnTimer := HookTimerHandler;
|
|
end;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxCustomGridCustomizationForm.CalculateConsts;
|
|
begin
|
|
FOffset := Canvas.TextHeight('Qq') div 6;
|
|
end;
|
|
|
|
procedure TcxCustomGridCustomizationForm.CreateControls;
|
|
begin
|
|
FPageControl := TcxPageControl.Create(Self);
|
|
with FPageControl do
|
|
begin
|
|
Anchors := [akTop, akLeft, akRight, akBottom];
|
|
BoundsRect := GetPageControlBounds;
|
|
Focusable := False;
|
|
HotTrack := True;
|
|
LookAndFeel.MasterLookAndFeel := GridView.LookAndFeel;
|
|
Parent := Self;
|
|
InitPageControl;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridCustomizationForm.CreatePage(const ACaption: string;
|
|
AVisible: Boolean): TcxTabSheet;
|
|
begin
|
|
Result := TcxTabSheet.Create(FPageControl);
|
|
with Result do
|
|
begin
|
|
Caption := ACaption;
|
|
TabVisible := AVisible;
|
|
PageControl := FPageControl;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridCustomizationForm.GridViewChanged;
|
|
begin
|
|
end;
|
|
|
|
function TcxCustomGridCustomizationForm.GetContentBounds: TRect;
|
|
begin
|
|
Result := ClientRect;
|
|
InflateRect(Result, -Offset, -Offset);
|
|
end;
|
|
|
|
function TcxCustomGridCustomizationForm.GetPageControlBounds: TRect;
|
|
begin
|
|
Result := ContentBounds;
|
|
end;
|
|
|
|
procedure TcxCustomGridCustomizationForm.InitPageControl;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridCustomizationForm.ActivatePage(APage: TcxTabSheet);
|
|
begin
|
|
if APage.TabVisible then
|
|
FPageControl.ActivePage := APage;
|
|
end;
|
|
|
|
procedure TcxCustomGridCustomizationForm.RefreshData;
|
|
begin
|
|
end;
|
|
|
|
{ TcxCustomGridPopup }
|
|
|
|
constructor TcxCustomGridPopup.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited Create(AGridView.Site);
|
|
FGridView := AGridView;
|
|
Color := clWindow;
|
|
IsTopMost := True;
|
|
OwnerParent := FGridView.Site;
|
|
end;
|
|
|
|
procedure TcxCustomGridPopup.SetOwner(Value: IcxCustomGridPopupOwner);
|
|
begin
|
|
if FOwner <> Value then
|
|
begin
|
|
if (Value = nil) and Visible and FOwner.ClosePopupWhenNilOwner then
|
|
CloseUp;
|
|
FOwner := Value;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridPopup.CalculateOwnerBounds: TRect;
|
|
begin
|
|
Result := FOwner.GetOwnerBounds;
|
|
end;
|
|
|
|
function TcxCustomGridPopup.GetClientMinWidth: Integer;
|
|
begin
|
|
with Owner.GetOwnerBounds do
|
|
Result := Right - Left - NCWidth;
|
|
end;
|
|
|
|
procedure TcxCustomGridPopup.InitPopup;
|
|
begin
|
|
inherited;
|
|
BorderStyle := GridView.LookAndFeelPainter.PopupBorderStyle;
|
|
Font := TcxControlAccess(FGridView.Control).Font;
|
|
OwnerBounds := CalculateOwnerBounds;
|
|
end;
|
|
|
|
procedure TcxCustomGridPopup.Paint;
|
|
begin
|
|
DrawFrame;
|
|
Canvas.Brush.Color := Color;
|
|
Canvas.FillRect(ClientBounds);
|
|
end;
|
|
|
|
procedure TcxCustomGridPopup.VisibleChanged;
|
|
begin
|
|
inherited;
|
|
if not Visible and (FOwner <> nil) then
|
|
begin
|
|
FOwner.PopupClosed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridPopup.CloseUp;
|
|
begin
|
|
inherited;
|
|
//TcxControlAccess(FGridView.Site).FocusChanged;
|
|
end;
|
|
|
|
procedure TcxCustomGridPopup.Popup;
|
|
begin
|
|
SetCaptureControl(nil);
|
|
inherited Popup(FindNextControl(nil, True, True, False));
|
|
end;
|
|
|
|
{ TcxGridPopupListBox }
|
|
|
|
constructor TcxGridPopupListBox.Create(APopup: TcxCustomGridPopup);
|
|
begin
|
|
inherited Create(APopup);
|
|
FItemTextOffsetLeft := cxGridCellTextOffset;
|
|
FItemTextOffsetRight := cxGridCellTextOffset;
|
|
FCheckedIndexes := TList.Create;
|
|
FPopup := APopup;
|
|
FPressedItemIndex := -1;
|
|
Init;
|
|
Parent := FPopup;
|
|
end;
|
|
|
|
destructor TcxGridPopupListBox.Destroy;
|
|
begin
|
|
FCheckedIndexes.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridPopupListBox.GetChecked(Index: Integer): Boolean;
|
|
begin
|
|
Result := FCheckedIndexes.IndexOf(TObject(Index)) <> -1;
|
|
end;
|
|
|
|
function TcxGridPopupListBox.GetCheckedIndexes: TcxGridIndexes;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
SetLength(Result, FCheckedIndexes.Count);
|
|
for I := 0 to FCheckedIndexes.Count - 1 do
|
|
Result[I] := Integer(FCheckedIndexes[I]);
|
|
end;
|
|
|
|
function TcxGridPopupListBox.GetGridView: TcxCustomGridView;
|
|
begin
|
|
Result := FPopup.GridView;
|
|
end;
|
|
|
|
procedure TcxGridPopupListBox.SetChecked(Index: Integer; Value: Boolean);
|
|
var
|
|
AChanged: Boolean;
|
|
I: Integer;
|
|
begin
|
|
AChanged := False;
|
|
I := FCheckedIndexes.IndexOf(TObject(Index));
|
|
if Value then
|
|
if I = -1 then
|
|
begin
|
|
FCheckedIndexes.Add(TObject(Index));
|
|
AChanged := True;
|
|
end
|
|
else
|
|
else
|
|
if I <> -1 then
|
|
begin
|
|
FCheckedIndexes.Delete(I);
|
|
AChanged := True;
|
|
end;
|
|
if AChanged then InvalidateItem(Index);
|
|
end;
|
|
|
|
procedure TcxGridPopupListBox.SetCheckedIndexes(const Value: TcxGridIndexes);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
FCheckedIndexes.Count := Length(Value);
|
|
for I := 0 to Length(Value) - 1 do
|
|
FCheckedIndexes[I] := TObject(Value[I]);
|
|
end;
|
|
|
|
procedure TcxGridPopupListBox.SetPressedItemIndex(Value: Integer);
|
|
begin
|
|
if FPressedItemIndex <> Value then
|
|
begin
|
|
if FPressedItemIndex <> -1 then
|
|
InvalidateItem(FPressedItemIndex);
|
|
FPressedItemIndex := Value;
|
|
if FPressedItemIndex <> -1 then
|
|
InvalidateItem(FPressedItemIndex);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridPopupListBox.SetShowChecks(Value: Boolean);
|
|
begin
|
|
if FShowChecks <> Value then
|
|
begin
|
|
FShowChecks := Value;
|
|
FCheckedIndexes.Clear;
|
|
end;
|
|
end;
|
|
|
|
function TcxGridPopupListBox.DrawItem(ACanvas: TcxCanvas; AIndex: Integer;
|
|
const ARect: TRect; AState: TOwnerDrawState): Boolean;
|
|
var
|
|
AContentRect, ACheckAreaRect: TRect;
|
|
begin
|
|
AContentRect := ARect;
|
|
if CanHaveCheck(AIndex) then
|
|
begin
|
|
Inc(AContentRect.Left, GetCheckAreaWidth);
|
|
ACheckAreaRect := ARect;
|
|
ACheckAreaRect.Right := AContentRect.Left;
|
|
if HasCheck(AIndex) and Checked[AIndex] then
|
|
begin
|
|
ACanvas.Brush.Color := clHighlight;
|
|
ACanvas.Font.Color := clHighlightText;
|
|
end;
|
|
end;
|
|
DrawItemContent(ACanvas, AIndex, AContentRect, AState);
|
|
if IsCheck(AIndex) then
|
|
DrawItemCheck(ACanvas, AIndex, ACheckAreaRect, AState);
|
|
if odFocused in AState then ACanvas.DrawFocusRect(ARect);
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TcxGridPopupListBox.KeyDown(var Key: Word; Shift: TShiftState);
|
|
begin
|
|
inherited;
|
|
case Key of
|
|
VK_RETURN, VK_SPACE:
|
|
DoAction(ItemIndex);
|
|
VK_ESCAPE:
|
|
FPopup.CloseUp;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridPopupListBox.MouseDown(Button: TMouseButton; Shift: TShiftState;
|
|
X, Y: Integer);
|
|
begin
|
|
PressedItemIndex := ItemAtPos(Point(X, Y), True);
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridPopupListBox.MouseLeave(AControl: TControl);
|
|
begin
|
|
inherited;
|
|
ItemIndex := -1;
|
|
PressedItemIndex := -1;
|
|
end;
|
|
|
|
procedure TcxGridPopupListBox.MouseMove(Shift: TShiftState; X, Y: Integer);
|
|
begin
|
|
ItemIndex := ItemAtPos(Point(X, Y), True);
|
|
if PressedItemIndex <> ItemIndex then
|
|
PressedItemIndex := -1;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridPopupListBox.MouseUp(Button: TMouseButton; Shift: TShiftState;
|
|
X, Y: Integer);
|
|
var
|
|
AItemIndex: Integer;
|
|
begin
|
|
inherited;
|
|
AItemIndex := ItemAtPos(Point(X, Y), True);
|
|
if not IsCheck(AItemIndex) or (AItemIndex = PressedItemIndex) then
|
|
DoAction(AItemIndex);
|
|
PressedItemIndex := -1;
|
|
end;
|
|
|
|
function TcxGridPopupListBox.GetVisibleItemCount(AItems: TStrings): Integer;
|
|
begin
|
|
Result := FVisibleItemCount;
|
|
if (Result = 0) or (Result > AItems.Count) then
|
|
Result := AItems.Count;
|
|
end;
|
|
|
|
function TcxGridPopupListBox.CalculateItemHeight: Integer;
|
|
begin
|
|
Result := Canvas.TextHeight('Qq') + 2 * FItemTextOffsetVert;
|
|
if ShowChecks then
|
|
Result := Max(Result, GetCheckAreaHeight);
|
|
end;
|
|
|
|
procedure TcxGridPopupListBox.DoAction(AItemIndex: Integer);
|
|
begin
|
|
if AItemIndex = -1 then Exit;
|
|
if IsCheck(AItemIndex) then
|
|
ChangeChecked(AItemIndex)
|
|
else
|
|
FPopup.CloseUp;
|
|
if Assigned(FOnAction) then FOnAction(Self, AItemIndex);
|
|
end;
|
|
|
|
procedure TcxGridPopupListBox.DrawItemCheck(ACanvas: TcxCanvas; AIndex: Integer;
|
|
const ACheckAreaRect: TRect; AState: TOwnerDrawState);
|
|
var
|
|
R: TRect;
|
|
ACheckState: TcxButtonState;
|
|
begin
|
|
R := cxRectCenter(ACheckAreaRect, LookAndFeelPainter.CheckButtonSize);
|
|
if (odFocused in AState) and (odSelected in AState) then
|
|
if AIndex = PressedItemIndex then
|
|
ACheckState := cxbsPressed
|
|
else
|
|
ACheckState := cxbsHot
|
|
else
|
|
ACheckState := cxbsNormal;
|
|
LookAndFeelPainter.DrawCheckButton(ACanvas, R, ACheckState, Checked[AIndex]);
|
|
end;
|
|
|
|
procedure TcxGridPopupListBox.DrawItemContent(ACanvas: TcxCanvas; AIndex: Integer;
|
|
ARect: TRect; AState: TOwnerDrawState);
|
|
begin
|
|
with ACanvas do
|
|
begin
|
|
FillRect(ARect);
|
|
Inc(ARect.Left, FItemTextOffsetLeft);
|
|
DrawText(Items[AIndex], ARect, cxSingleLine or cxAlignLeft or cxAlignVCenter);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridPopupListBox.Init;
|
|
begin
|
|
Style.LookAndFeel.MasterLookAndFeel := GridView.LookAndFeel;
|
|
ListStyle := lbOwnerDrawFixed;
|
|
with Style do
|
|
begin
|
|
BorderStyle := cbsNone;
|
|
HotTrack := False;
|
|
TransparentBorder := False;
|
|
end;
|
|
StyleFocused.BorderStyle := cbsNone;
|
|
StyleHot.BorderStyle := cbsNone;
|
|
ParentFont := True;
|
|
end;
|
|
|
|
procedure TcxGridPopupListBox.InvalidateItem(AIndex: Integer);
|
|
var
|
|
R: TRect;
|
|
begin
|
|
R := InnerListBox.ItemRect(AIndex);
|
|
Windows.InvalidateRect(InnerListBox.Handle, @R, False);
|
|
end;
|
|
|
|
function TcxGridPopupListBox.CanHaveCheck(AItemIndex: Integer): Boolean;
|
|
begin
|
|
Result := ShowChecks;
|
|
end;
|
|
|
|
procedure TcxGridPopupListBox.ChangeChecked(AItemIndex: Integer);
|
|
begin
|
|
Checked[AItemIndex] := not Checked[AItemIndex];
|
|
end;
|
|
|
|
function TcxGridPopupListBox.GetCheckAreaHeight: Integer;
|
|
begin
|
|
Result := 2 * CheckOffset + LookAndFeelPainter.CheckButtonSize.cy;
|
|
end;
|
|
|
|
function TcxGridPopupListBox.GetCheckAreaWidth: Integer;
|
|
begin
|
|
Result := 2 * CheckOffset + LookAndFeelPainter.CheckButtonSize.cx;
|
|
end;
|
|
|
|
function TcxGridPopupListBox.HasCheck(AItemIndex: Integer): Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxGridPopupListBox.IsCheck(AItemIndex: Integer): Boolean;
|
|
begin
|
|
Result := (AItemIndex <> -1) and CanHaveCheck(AItemIndex) and HasCheck(AItemIndex);
|
|
end;
|
|
|
|
procedure TcxGridPopupListBox.AdjustBounds(AItems: TStrings = nil);
|
|
|
|
function CalculateClientHeight: Integer;
|
|
begin
|
|
Result := GetVisibleItemCount(AItems) * ItemHeight;
|
|
end;
|
|
|
|
function CalculateClientWidth: Integer;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := 0;
|
|
for I := 0 to AItems.Count - 1 do
|
|
Result := Max(Result, Canvas.TextWidth(AItems[I]));
|
|
Inc(Result, FItemTextOffsetLeft + FItemTextOffsetRight);
|
|
if ShowChecks then
|
|
Inc(Result, GetCheckAreaWidth);
|
|
if FVisibleWidth <> 0 then
|
|
Result := Min(Result, FVisibleWidth);
|
|
if GetVisibleItemCount(AItems) < AItems.Count then
|
|
Inc(Result, GetScrollBarSize.cx);
|
|
end;
|
|
|
|
begin
|
|
if AItems = nil then AItems := Items;
|
|
Canvas.Font := Font;
|
|
ItemHeight := CalculateItemHeight;
|
|
ClientHeight := CalculateClientHeight;
|
|
ClientWidth := CalculateClientWidth;
|
|
MinWidth := FPopup.ClientMinWidth;
|
|
if (FMinWidth <> 0) and (Width < FMinWidth) then
|
|
Width := FMinWidth;
|
|
end;
|
|
|
|
{ TcxCustomGridDesignController }
|
|
|
|
function TcxCustomGridDesignController.GetDesignObject(AObject: TPersistent): TPersistent;
|
|
begin
|
|
Result := AObject;
|
|
end;
|
|
|
|
function TcxCustomGridDesignController.IsObjectSelected(AObject: TPersistent): Boolean;
|
|
begin
|
|
{$IFDEF DELPHI6}
|
|
if TcxCustomGrid(Control).StructureNavigator = nil then
|
|
Result := False
|
|
else
|
|
Result := TcxCustomGrid(Control).StructureNavigator.IsObjectSelected(GetDesignObject(AObject));
|
|
{$ELSE}
|
|
Result := False;
|
|
{$ENDIF}
|
|
end;
|
|
|
|
procedure TcxCustomGridDesignController.SelectObject(AObject: TPersistent; AClearSelection: Boolean);
|
|
begin
|
|
TcxCustomGrid(Control).StructureNavigator.SelectObject(GetDesignObject(AObject), AClearSelection);
|
|
end;
|
|
|
|
procedure TcxCustomGridDesignController.SelectObjects(AObjects: TList);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to AObjects.Count - 1 do
|
|
AObjects[I] := GetDesignObject(AObjects[I]);
|
|
TcxCustomGrid(Control).StructureNavigator.SelectObjects(AObjects);
|
|
end;
|
|
|
|
procedure TcxCustomGridDesignController.UnselectObject(AObject: TPersistent);
|
|
begin
|
|
if Control <> nil then
|
|
TcxCustomGrid(Control).StructureNavigator.UnselectObject(GetDesignObject(AObject));
|
|
end;
|
|
|
|
{ TcxGridViewDesignController }
|
|
|
|
constructor TcxGridViewDesignController.Create(AController: TcxCustomGridController);
|
|
begin
|
|
inherited Create;
|
|
FController := AController;
|
|
end;
|
|
|
|
function TcxGridViewDesignController.GetControl: TcxControl;
|
|
begin
|
|
Result := FController.Control;
|
|
end;
|
|
|
|
function TcxGridViewDesignController.GetDesignObject(AObject: TPersistent): TPersistent;
|
|
begin
|
|
if FController.GridView.IsPattern then
|
|
Result := inherited GetDesignObject(AObject)
|
|
else
|
|
Result := FController.GetPatternObject(AObject);
|
|
end;
|
|
|
|
{ TcxCustomGridController }
|
|
|
|
destructor TcxCustomGridController.Destroy;
|
|
begin
|
|
HideHint;
|
|
FreeAndNil(FHintWindow);
|
|
FreeAndNil(FDesignController);
|
|
inherited;
|
|
end;
|
|
|
|
function TcxCustomGridController.GetDesignController: TcxGridViewDesignController;
|
|
begin
|
|
if (FDesignController = nil) and GridView.IsDesigning then
|
|
FDesignController := GetDesignControllerClass.Create(Self);
|
|
Result := FDesignController;
|
|
end;
|
|
|
|
function TcxCustomGridController.GetDragAndDropObject: TcxCustomGridDragAndDropObject;
|
|
begin
|
|
Result := Site.DragAndDropObject as TcxCustomGridDragAndDropObject;
|
|
end;
|
|
|
|
function TcxCustomGridController.GetDragAndDropObjectClass: TcxDragAndDropObjectClass;
|
|
begin
|
|
Result := Site.DragAndDropObjectClass;
|
|
end;
|
|
|
|
function TcxCustomGridController.GetDragImages: TcxDragImageList;
|
|
begin
|
|
Result := Site.DragImages;
|
|
end;
|
|
|
|
function TcxCustomGridController.GetIsDragging: Boolean;
|
|
begin
|
|
Result := Site.DragAndDropState = ddsInProcess;
|
|
end;
|
|
|
|
function TcxCustomGridController.GetMouseCaptureViewInfo: TcxCustomGridCellViewInfo;
|
|
begin
|
|
if Site.MouseCaptureObject is TcxCustomGridCellViewInfo then
|
|
Result := TcxCustomGridCellViewInfo(Site.MouseCaptureObject)
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.SetCustomization(Value: Boolean);
|
|
begin
|
|
if Value and (GridView.IsPattern or not Site.HandleAllocated) then Exit;
|
|
if FCustomization <> Value then
|
|
begin
|
|
FCustomization := Value;
|
|
CustomizationChanged;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.SetDragAndDropObjectClass(Value: TcxDragAndDropObjectClass);
|
|
begin
|
|
Site.DragAndDropObjectClass := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.SetMouseCaptureViewInfo(Value: TcxCustomGridCellViewInfo);
|
|
begin
|
|
Site.MouseCaptureObject := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.HintCheckerTimerHandler(Sender: TObject);
|
|
begin
|
|
if not CanShowHint then HideHint;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.MouseLeave;
|
|
begin
|
|
HideHint;
|
|
end;
|
|
|
|
function TcxCustomGridController.PtInCaller(const P: TPoint): Boolean;
|
|
begin
|
|
if FHintCellViewInfo = nil then
|
|
if IsRectEmpty(FHintAreaBounds) then
|
|
Result := PtInRect(Site.Bounds, P)
|
|
else
|
|
Result := PtInRect(FHintAreaBounds, P)
|
|
else
|
|
Result := FHintCellViewInfo.HasHintPoint(P);
|
|
end;
|
|
|
|
procedure TcxCustomGridController.AfterPaint;
|
|
begin
|
|
if IsDragging then
|
|
DragAndDropObject.AfterPaint;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.BeforeKillFocus;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.BeforePaint;
|
|
begin
|
|
if IsDragging then
|
|
DragAndDropObject.BeforePaint;
|
|
end;
|
|
|
|
function TcxCustomGridController.CanFocusOnClick(X, Y: Integer): Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TcxCustomGridController.CanHandleHitTest(AHitTest: TcxCustomGridHitTest): Boolean;
|
|
begin
|
|
Result := not (AHitTest is TcxCustomGridViewHitTest) or
|
|
(TcxCustomGridViewHitTest(AHitTest).GridView = FGridView);
|
|
end;
|
|
|
|
procedure TcxCustomGridController.CheckCoordinates;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DetailFocused(ADetail: TcxCustomGridView);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DoEnter;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DoExit;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DoSetFocus(ANotifyMaster: Boolean);
|
|
begin
|
|
FIsFocusing := True;
|
|
try
|
|
SetFocus(ANotifyMaster);
|
|
finally
|
|
FIsFocusing := False;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridController.GetDesignControllerClass: TcxGridViewDesignControllerClass;
|
|
begin
|
|
Result := TcxGridViewDesignController;
|
|
end;
|
|
|
|
function TcxCustomGridController.GetDesignHitTest(AHitTest: TcxCustomGridHitTest): Boolean;
|
|
begin
|
|
Result := (AHitTest.DragAndDropObjectClass <> nil) or
|
|
(AHitTest.HitTestCode = htDesignSelector);
|
|
end;
|
|
|
|
function TcxCustomGridController.GetMouseWheelScrollingKind: TcxMouseWheelScrollingKind;
|
|
begin
|
|
Result := mwskNone;
|
|
end;
|
|
|
|
function TcxCustomGridController.GetPatternObject(AObject: TPersistent): TPersistent;
|
|
begin
|
|
if AObject is TcxCustomGridView then
|
|
Result := TcxCustomGridView(AObject).PatternGridView
|
|
else
|
|
if AObject is TcxDataSummaryItem then
|
|
Result := DataController.Summary.GetPatternSummaryItems(GridView.PatternGridView.DataController.Summary,
|
|
TcxDataSummaryItem(AObject).SummaryItems)[TcxDataSummaryItem(AObject).Index]
|
|
else
|
|
Result := AObject;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.GridViewChanged;
|
|
begin
|
|
if CustomizationForm <> nil then
|
|
CustomizationForm.GridViewChanged;
|
|
end;
|
|
|
|
function TcxCustomGridController.IsPixelScrollBar(AKind: TScrollBarKind): Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxCustomGridController.MayFocus: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.RemoveFocus;
|
|
begin
|
|
BeforeKillFocus;
|
|
GridView.TabStop := False;
|
|
if not GridView.Visible then
|
|
begin
|
|
Site.Parent := nil;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.SetFocus(ANotifyMaster: Boolean);
|
|
begin
|
|
GridView.TabStop := True;
|
|
ViewInfo.DoVisibilityChanged(True);
|
|
if Control.IsFocused and Site.CanFocusEx then
|
|
Site.SetFocus;
|
|
if ANotifyMaster and GridView.IsDetail then
|
|
GridView.MasterGridView.Controller.DetailFocused(GridView);
|
|
end;
|
|
|
|
procedure TcxCustomGridController.VisibilityChanged(AVisible: Boolean);
|
|
begin
|
|
if not AVisible then
|
|
Customization := False;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.CheckCustomizationFormBounds(var R: TRect);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.CustomizationChanged;
|
|
begin
|
|
if Customization then
|
|
ShowCustomizationForm
|
|
else
|
|
HideCustomizationForm;
|
|
if Control <> nil then
|
|
TcxCustomGrid(Control).SendNotifications(gnkCustomization);
|
|
GridView.DoCustomization;
|
|
end;
|
|
|
|
function TcxCustomGridController.GetCustomizationFormBounds: TRect;
|
|
begin
|
|
if IsRectEmpty(FCustomizationFormBounds) then
|
|
begin
|
|
Result.BottomRight := Site.ClientToScreen(Site.ClientRect.BottomRight);
|
|
Result.Left := Result.Right - GetCustomizationFormDefaultWidth;
|
|
Result.Top := Result.Bottom - GetCustomizationFormDefaultHeight;
|
|
CheckCustomizationFormBounds(Result);
|
|
end
|
|
else
|
|
Result := FCustomizationFormBounds;
|
|
end;
|
|
|
|
function TcxCustomGridController.GetCustomizationFormClass: TcxCustomGridCustomizationFormClass;
|
|
begin
|
|
Result := TcxCustomGridCustomizationForm;
|
|
end;
|
|
|
|
function TcxCustomGridController.GetCustomizationFormDefaultWidth: Integer;
|
|
begin
|
|
Result := cxGridCustomizationFormDefaultWidth;
|
|
end;
|
|
|
|
function TcxCustomGridController.GetCustomizationFormDefaultHeight: Integer;
|
|
begin
|
|
Result := cxGridCustomizationFormDefaultHeight;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.HideCustomizationForm;
|
|
begin
|
|
if not (csDestroying in FCustomizationForm.ComponentState) then
|
|
FCustomizationForm.Free;
|
|
FCustomizationForm := nil;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.ShowCustomizationForm;
|
|
begin
|
|
FCustomizationForm := GetCustomizationFormClass.Create(Self);
|
|
FCustomizationForm.BoundsRect := GetCustomizationFormBounds;
|
|
FCustomizationForm.Show;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.ControlFocusChanged;
|
|
begin
|
|
ViewInfo.ControlFocusChanged;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DesignerModified;
|
|
begin
|
|
Site.Modified;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DoCancelMode;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DoCheckCoordinates;
|
|
var
|
|
APrevIsCheckingCoordinates: Boolean;
|
|
begin
|
|
APrevIsCheckingCoordinates := FIsCheckingCoordinates;
|
|
FIsCheckingCoordinates := True;
|
|
try
|
|
CheckCoordinates;
|
|
finally
|
|
FIsCheckingCoordinates := APrevIsCheckingCoordinates;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DoControlFocusChanged;
|
|
begin
|
|
GridView.Changed(TcxGridControlFocusChange.Create(GridView));
|
|
end;
|
|
|
|
function TcxCustomGridController.GetCursor(X, Y: Integer): TCursor;
|
|
var
|
|
AHitTest: TcxCustomGridHitTest;
|
|
begin
|
|
AHitTest := ViewInfo.GetHitTest(Point(X, Y));
|
|
if CanHandleHitTest(AHitTest) then
|
|
Result := AHitTest.Cursor
|
|
else
|
|
Result := crDefault;
|
|
end;
|
|
|
|
function TcxCustomGridController.HasFocusedControls: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
{function TcxCustomGridController.CanDrag(X, Y: Integer): Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxCustomGridController.GetDragObjectClass: TDragControlObjectClass;
|
|
begin
|
|
Result := TcxDragControlObject;
|
|
end;}
|
|
|
|
procedure TcxCustomGridController.InitScrollBarsParameters;
|
|
begin
|
|
end;
|
|
|
|
function TcxCustomGridController.IsDataFullyVisible(AIsCallFromMaster: Boolean = False): Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.Scroll(AScrollBarKind: TScrollBarKind;
|
|
AScrollCode: TScrollCode; var AScrollPos: Integer);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.SetScrollBarInfo(AScrollBarKind: TScrollBarKind;
|
|
AMin, AMax, AStep, APage, APos: Integer; AAllowShow, AAllowHide: Boolean);
|
|
begin
|
|
Site.SetScrollBarInfo(AScrollBarKind, AMin, AMax, AStep, APage, APos, AAllowShow, AAllowHide);
|
|
end;
|
|
|
|
procedure TcxCustomGridController.UpdateScrollBars(AIgnoreUpdateLock: Boolean = False);
|
|
var
|
|
APrevIgnoreUpdateLock: Boolean;
|
|
begin
|
|
APrevIgnoreUpdateLock := Site.IgnoreUpdateLock;
|
|
Site.IgnoreUpdateLock := AIgnoreUpdateLock;
|
|
try
|
|
Site.UpdateScrollBars;
|
|
finally
|
|
Site.IgnoreUpdateLock := APrevIgnoreUpdateLock;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.BeginDragAndDrop;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DragAndDrop(const P: TPoint; var Accepted: Boolean);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.EndDragAndDrop(Accepted: Boolean);
|
|
begin
|
|
end;
|
|
|
|
function TcxCustomGridController.StartDragAndDrop(const P: TPoint): Boolean;
|
|
var
|
|
AHitTest: TcxCustomGridHitTest;
|
|
begin
|
|
AHitTest := ViewInfo.GetHitTest(P);
|
|
Result := CanHandleHitTest(AHitTest);
|
|
if Result then
|
|
begin
|
|
Result := AHitTest.DragAndDropObjectClass <> nil;
|
|
if Result then
|
|
begin
|
|
HideHint;
|
|
DragAndDropObjectClass := AHitTest.DragAndDropObjectClass;
|
|
DragAndDropObject.Init(P, AHitTest);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.BeforeStartDrag;
|
|
begin
|
|
end;
|
|
|
|
function TcxCustomGridController.CanDrag(X, Y: Integer): Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DragDrop(Source: TObject; X, Y: Integer);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DragOver(Source: TObject; X, Y: Integer;
|
|
State: TDragState; var Accept: Boolean);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DrawDragImage(ACanvas: TcxCanvas; R: TRect);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.EndDrag(Target: TObject; X, Y: Integer);
|
|
begin
|
|
end;
|
|
|
|
function TcxCustomGridController.GetDragImagesSize: TPoint;
|
|
begin
|
|
Result := Point(0, 0);
|
|
end;
|
|
|
|
function TcxCustomGridController.HasDragImages: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.StartDrag(var DragObject: TDragObject);
|
|
begin
|
|
end;
|
|
|
|
function TcxCustomGridController.CanShowHint: Boolean;
|
|
var
|
|
AForm: TCustomForm;
|
|
begin
|
|
AForm := GetParentForm(Site);
|
|
Result := (AForm = nil) or Application.Active and
|
|
(AForm.Active or
|
|
(TCustomFormAccess(AForm).FormStyle = fsMDIForm));
|
|
if Result then
|
|
Result := Site.HandleAllocated and IsWindowVisible(Site.Handle) and
|
|
(FindVCLWindow(GetMouseCursorPos) = Site);
|
|
end;
|
|
|
|
procedure TcxCustomGridController.HideHint;
|
|
begin
|
|
StopHintCheckerTimer;
|
|
EndMouseTracking(Self);
|
|
FHintCellViewInfo := nil;
|
|
SetRectEmpty(FHintAreaBounds);
|
|
if (FHintWindow <> nil) and FHintWindow.HandleAllocated then
|
|
ShowWindow(FHintWindow.Handle, SW_HIDE);
|
|
end;
|
|
|
|
function TcxCustomGridController.GetHintWindowClass: THintWindowClass;
|
|
begin
|
|
Result := HintWindowClass;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.ShowHint(const AHintAreaBounds, ATextRect: TRect;
|
|
const AText: string; AIsHintMultiLine: Boolean; AFont: TFont;
|
|
AHintCellViewInfo: TcxCustomGridViewCellViewInfo);
|
|
|
|
function GetHintWindowRect: TRect;
|
|
|
|
function GetMaxTextWidth: Integer;
|
|
begin
|
|
if AIsHintMultiLine then
|
|
Result := ATextRect.Right - ATextRect.Left
|
|
else
|
|
Result := MaxInt div 20;
|
|
end;
|
|
|
|
function GetTextRectOffset: TPoint;
|
|
const
|
|
TextOffset: TPoint = (X: 2; Y: 2);
|
|
begin
|
|
with FHintWindow.ClientToScreen(Point(0, 0)) do
|
|
begin
|
|
Result.X := X - FHintWindow.Left + TextOffset.X;
|
|
Result.Y := Y - FHintWindow.Top + TextOffset.Y;
|
|
end;
|
|
end;
|
|
|
|
begin
|
|
Result := FHintWindow.CalcHintRect(GetMaxTextWidth, AText, nil);
|
|
with Result do
|
|
begin
|
|
Inc(Right, -6);
|
|
Inc(Bottom, -2);
|
|
end;
|
|
with Site.ClientToScreen(ATextRect.TopLeft) do
|
|
OffsetRect(Result, X, Y);
|
|
with GetTextRectOffset do
|
|
InflateRect(Result, X, Y);
|
|
MakeVisibleOnDesktop(Result, Result.TopLeft);
|
|
Dec(Result.Bottom, 4);
|
|
end;
|
|
|
|
begin
|
|
if not CanShowHint then Exit;
|
|
if (FHintWindow = nil) or (FHintWindow.ClassType <> GetHintWindowClass) then
|
|
begin
|
|
FHintWindow.Free;
|
|
FHintWindow := GetHintWindowClass.Create(nil);
|
|
FHintWindow.Color := Application.HintColor;
|
|
end
|
|
else
|
|
if IsWindowVisible(FHintWindow.Handle) then
|
|
begin
|
|
if (FHintWindow.Caption = AText) and EqualRect(FHintTextRect, ATextRect) then
|
|
Exit;
|
|
EndMouseTracking(Self);
|
|
end;
|
|
FHintTextRect := ATextRect;
|
|
FHintWindow.Canvas.Font := AFont;
|
|
FHintWindow.ActivateHint(GetHintWindowRect, AText);
|
|
FHintAreaBounds := AHintAreaBounds;
|
|
FHintCellViewInfo := AHintCellViewInfo;
|
|
BeginMouseTracking(Site, FHintAreaBounds, Self);
|
|
StartHintCheckerTimer;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.StartHintCheckerTimer;
|
|
begin
|
|
if FHintCheckerTimer <> nil then Exit;
|
|
FHintCheckerTimer := TcxTimer.Create(nil);
|
|
with FHintCheckerTimer do
|
|
begin
|
|
Interval := 100;
|
|
OnTimer := HintCheckerTimerHandler;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.StopHintCheckerTimer;
|
|
begin
|
|
FreeAndNil(FHintCheckerTimer);
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DoKeyDown(var Key: Word; Shift: TShiftState);
|
|
begin
|
|
KeyDown(Key, Shift);
|
|
end;
|
|
|
|
procedure TcxCustomGridController.KeyDown(var Key: Word; Shift: TShiftState);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.KeyPress(var Key: Char);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.KeyUp(var Key: Word; Shift: TShiftState);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.MouseDown(Button: TMouseButton; Shift: TShiftState;
|
|
X, Y: Integer);
|
|
var
|
|
AHitTest: TcxCustomGridHitTest;
|
|
begin
|
|
FIsDblClick := ssDouble in Shift;
|
|
AHitTest := ViewInfo.GetHitTest(X, Y);
|
|
if AHitTest.ViewInfo <> nil then
|
|
AHitTest.ViewInfo.MouseDown(AHitTest, Button, Shift);
|
|
end;
|
|
|
|
procedure TcxCustomGridController.MouseMove(Shift: TShiftState; X, Y: Integer);
|
|
var
|
|
AHitTest: TcxCustomGridHitTest;
|
|
begin
|
|
AHitTest := ViewInfo.GetHitTest(X, Y);
|
|
if MouseCaptureViewInfo <> nil then
|
|
MouseCaptureViewInfo.MouseMove(AHitTest, Shift)
|
|
else
|
|
if AHitTest.ViewInfo <> nil then
|
|
AHitTest.ViewInfo.MouseMove(AHitTest, Shift);
|
|
end;
|
|
|
|
procedure TcxCustomGridController.MouseUp(Button: TMouseButton; Shift: TShiftState;
|
|
X, Y: Integer);
|
|
var
|
|
AHitTest: TcxCustomGridHitTest;
|
|
begin
|
|
AHitTest := ViewInfo.GetHitTest(X, Y);
|
|
if MouseCaptureViewInfo <> nil then
|
|
MouseCaptureViewInfo.MouseUp(AHitTest, Button, Shift)
|
|
else
|
|
if AHitTest.ViewInfo <> nil then
|
|
AHitTest.ViewInfo.MouseUp(AHitTest, Button, Shift);
|
|
end;
|
|
|
|
function TcxCustomGridController.ProcessDetailDialogChar(ADetail: TcxCustomGridView;
|
|
ACharCode: Word): Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxCustomGridController.ProcessDialogChar(ACharCode: Word): Boolean;
|
|
begin
|
|
Result := (GridView.MasterGridView <> nil) and
|
|
GridView.MasterGridView.Controller.ProcessDetailDialogChar(GridView, ACharCode);
|
|
end;
|
|
|
|
procedure TcxCustomGridController.WndProc(var Message: TMessage);
|
|
begin
|
|
if (Message.Msg = CN_SYSCHAR) and ProcessDialogChar(Message.WParam) then
|
|
Message.Msg := WM_NULL;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.RefreshCustomizationForm;
|
|
begin
|
|
if CustomizationForm <> nil then
|
|
CustomizationForm.RefreshData;
|
|
end;
|
|
|
|
{procedure TcxCustomGridController.BeginCellMouseTracking(AViewInfo: TcxCustomGridCellViewInfo);
|
|
begin
|
|
BeginMouseTracking(Site, AViewInfo.Bounds, AViewInfo);
|
|
end;
|
|
|
|
procedure TcxCustomGridController.EndCellMouseTracking(AViewInfo: TcxCustomGridCellViewInfo);
|
|
begin
|
|
EndMouseTracking(AViewInfo);
|
|
end;}
|
|
|
|
{ TcxDataGroupNode }
|
|
|
|
constructor TcxDataGroupNode.Create(AParent: TcxDataGroupNode; ADataGroupInfo: TcxDataGroupInfo);
|
|
begin
|
|
inherited Create;
|
|
FChilds := TList.Create;
|
|
FDataGroupInfo := ADataGroupInfo;
|
|
FParent := AParent;
|
|
end;
|
|
|
|
destructor TcxDataGroupNode.Destroy;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to ChildCount - 1 do
|
|
Childs[I].Free;
|
|
FChilds.Free;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
function TcxDataGroupNode.GetChild(Index: Integer): TcxDataGroupNode;
|
|
begin
|
|
Result := TcxDataGroupNode(FChilds[Index]);
|
|
end;
|
|
|
|
function TcxDataGroupNode.GetChildCount: Integer;
|
|
begin
|
|
Result := FChilds.Count;
|
|
end;
|
|
|
|
function TcxDataGroupNode.AddChild(ADataGroupInfo: TcxDataGroupInfo): TcxDataGroupNode;
|
|
begin
|
|
Result := TcxDataGroupNode.Create(Self, ADataGroupInfo);
|
|
FChilds.Add(Result);
|
|
end;
|
|
|
|
{ TcxGridSortingBySummaryEngine }
|
|
|
|
constructor TcxGridSortingBySummaryEngine.Create(ADataControllerInfo: TcxCustomDataControllerInfo);
|
|
begin
|
|
inherited;
|
|
FInfos := TList.Create;
|
|
FRootNode := TcxDataGroupNode.Create(nil, nil);
|
|
end;
|
|
|
|
destructor TcxGridSortingBySummaryEngine.Destroy;
|
|
begin
|
|
FRootNode.Free;
|
|
ClearInfos;
|
|
FInfos.Free;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
function TcxGridSortingBySummaryEngine.GetDataGroups: TcxDataGroups;
|
|
begin
|
|
Result := DataControllerInfo.DataGroups;
|
|
end;
|
|
|
|
function TcxGridSortingBySummaryEngine.GetInfo(Index: Integer): TcxSortingBySummaryInfo;
|
|
begin
|
|
Result := TcxSortingBySummaryInfo(FInfos[Index]);
|
|
end;
|
|
|
|
function TcxGridSortingBySummaryEngine.GetInfoCount: Integer;
|
|
begin
|
|
Result := FInfos.Count;
|
|
end;
|
|
|
|
procedure TcxGridSortingBySummaryEngine.AddInfo(AInfo: TcxSortingBySummaryInfo);
|
|
begin
|
|
FInfos.Add(AInfo);
|
|
end;
|
|
|
|
procedure TcxGridSortingBySummaryEngine.BuildNodes(AParentNode: TcxDataGroupNode; ALevel: Integer;
|
|
var ACurIndex: Integer);
|
|
var
|
|
ANode: TcxDataGroupNode;
|
|
begin
|
|
while ACurIndex < DataGroups.Count do
|
|
if DataGroups[ACurIndex].Level = ALevel then
|
|
begin
|
|
ANode := AParentNode.AddChild(DataGroups[ACurIndex]);
|
|
Inc(ACurIndex);
|
|
if ALevel < DataGroups.LevelCount - 1 then // build childs
|
|
BuildNodes(ANode, ALevel + 1, ACurIndex);
|
|
end
|
|
else
|
|
Break;
|
|
end;
|
|
|
|
procedure TcxGridSortingBySummaryEngine.ClearInfos;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to InfoCount - 1 do
|
|
Infos[I].Free;
|
|
FInfos.Clear;
|
|
end;
|
|
|
|
function TcxGridSortingBySummaryEngine.CompareGroupsBySummary(AInfo1, AInfo2:
|
|
Pointer): Integer;
|
|
var
|
|
AInfo: TcxSortingBySummaryInfo;
|
|
begin
|
|
AInfo := Infos[TcxDataGroupNode(AInfo1).DataGroupInfo.Level];
|
|
Result := VarCompare(
|
|
TcxDataGroupNode(AInfo1).DataGroupInfo.SummaryValues[AInfo.SummaryItemIndex],
|
|
TcxDataGroupNode(AInfo2).DataGroupInfo.SummaryValues[AInfo.SummaryItemIndex]);
|
|
if Result = 0 then
|
|
begin
|
|
Result := DataControllerInfo.CompareGroupRecords(
|
|
{DataControllerInfo.GetRowInfo(TcxDataGroupNode(AInfo1).DataGroupInfo.RowIndex).RecordIndex,
|
|
DataControllerInfo.GetRowInfo(TcxDataGroupNode(AInfo2).DataGroupInfo.RowIndex).RecordIndex,}
|
|
DataControllerInfo.GetInternalRecordIndex(
|
|
DataGroups.GetDataRecordListIndex(TcxDataGroupNode(AInfo1).DataGroupInfo)),
|
|
DataControllerInfo.GetInternalRecordIndex(
|
|
DataGroups.GetDataRecordListIndex(TcxDataGroupNode(AInfo2).DataGroupInfo)),
|
|
TcxDataGroupNode(AInfo1).DataGroupInfo.Level)
|
|
end
|
|
else
|
|
if AInfo.SortOrder = soDescending then
|
|
Result := -Result;
|
|
end;
|
|
|
|
procedure TcxGridSortingBySummaryEngine.RebuildDataGroupRecursive(AParentNode: TcxDataGroupNode;
|
|
var ABeginRecordListIndex: Integer);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
DataGroups.SetItem(ABeginRecordListIndex, AParentNode.DataGroupInfo);
|
|
Inc(ABeginRecordListIndex);
|
|
if AParentNode.DataGroupInfo.Level < (DataGroups.LevelCount - 1) then
|
|
begin
|
|
AParentNode.DataGroupInfo.BeginRecordListIndex := ABeginRecordListIndex;
|
|
for I := 0 to AParentNode.ChildCount - 1 do
|
|
RebuildDataGroupRecursive(AParentNode.Childs[I], ABeginRecordListIndex);
|
|
AParentNode.DataGroupInfo.EndRecordListIndex := ABeginRecordListIndex - 1;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridSortingBySummaryEngine.RebuildDataGroups;
|
|
var
|
|
I: Integer;
|
|
ABeginRecordListIndex: Integer;
|
|
begin
|
|
ABeginRecordListIndex := 0;
|
|
for I := 0 to FRootNode.ChildCount - 1 do
|
|
RebuildDataGroupRecursive(FRootNode.Childs[I], ABeginRecordListIndex);
|
|
DataGroups.Rebuild;
|
|
end;
|
|
|
|
procedure TcxGridSortingBySummaryEngine.SortNodeRecursive(ANode: TcxDataGroupNode; ALevel: Integer);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
if Infos[ALevel].SummaryItemIndex <> -1 then
|
|
QuickSortList(ANode.FChilds.List, 0, ANode.FChilds.Count - 1, CompareGroupsBySummary);
|
|
if (ALevel + 1) < DataGroups.LevelCount then // Last Level?
|
|
for I := 0 to ANode.ChildCount - 1 do
|
|
SortNodeRecursive(ANode.Childs[I], ALevel + 1);
|
|
end;
|
|
|
|
procedure TcxGridSortingBySummaryEngine.SortNodes;
|
|
var
|
|
I: Integer;
|
|
AInfo: TcxSortingBySummaryInfo;
|
|
ASortedSummaryItem: TcxDataSummaryItem;
|
|
begin
|
|
ClearInfos;
|
|
for I := 0 to DataControllerInfo.GroupingFieldList.Count - 1 do
|
|
begin
|
|
AInfo := TcxSortingBySummaryInfo.Create;
|
|
ASortedSummaryItem := DataController.Summary.GroupSummaryItems[I].SortedSummaryItem;
|
|
if ASortedSummaryItem <> nil then
|
|
begin
|
|
AInfo.SummaryItemIndex := ASortedSummaryItem.Index;
|
|
if DataController.SortingBySummaryDataItemIndex <> -1 then
|
|
AInfo.SortOrder := DataController.GetItemSortOrder(DataController.SortingBySummaryDataItemIndex)
|
|
else
|
|
AInfo.SortOrder := DataControllerInfo.GroupingFieldList[I].SortOrder;
|
|
end
|
|
else
|
|
AInfo.SummaryItemIndex := -1;
|
|
AddInfo(AInfo);
|
|
end;
|
|
|
|
SortNodeRecursive(FRootNode, 0);
|
|
end;
|
|
|
|
procedure TcxGridSortingBySummaryEngine.Sort;
|
|
var
|
|
ACurIndex: Integer;
|
|
begin
|
|
if DataGroups.Count = 0 then Exit;
|
|
ACurIndex := 0;
|
|
BuildNodes(FRootNode, 0, ACurIndex);
|
|
SortNodes;
|
|
RebuildDataGroups;
|
|
end;
|
|
|
|
{ TcxCustomGridCellPainter }
|
|
|
|
constructor TcxCustomGridCellPainter.Create(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxCustomGridCellViewInfo);
|
|
begin
|
|
inherited Create;
|
|
FCanvas := ACanvas;
|
|
FViewInfo := AViewInfo;
|
|
end;
|
|
|
|
function TcxCustomGridCellPainter.GetIsMainCanvasInUseValue: Boolean;
|
|
begin
|
|
Result := GetIsMainCanvasInUse(FCanvas, FViewInfo);
|
|
end;
|
|
|
|
procedure TcxCustomGridCellPainter.AfterPaint;
|
|
begin
|
|
if CanDrawDesignSelection then DoDrawDesignSelection(Canvas, ViewInfo);
|
|
end;
|
|
|
|
procedure TcxCustomGridCellPainter.BeforePaint;
|
|
begin
|
|
end;
|
|
|
|
function TcxCustomGridCellPainter.CanDrawDesignSelection: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellPainter.DoExcludeFromClipRect;
|
|
begin
|
|
Canvas.ExcludeClipRect(ViewInfo.Bounds);
|
|
end;
|
|
|
|
procedure TcxCustomGridCellPainter.DrawBackground;
|
|
begin
|
|
DrawBackground(ViewInfo.ClientBounds);
|
|
end;
|
|
|
|
procedure TcxCustomGridCellPainter.DrawBackground(const R: TRect);
|
|
begin
|
|
with Canvas, ViewInfo do
|
|
if not Transparent then
|
|
begin
|
|
Brush.Color := Params.Color;
|
|
FillRect(R);
|
|
end
|
|
else
|
|
if BackgroundBitmap <> nil then
|
|
FillRect(R, BackgroundBitmap);
|
|
end;
|
|
|
|
function TcxCustomGridCellPainter.DrawBackgroundHandler(ACanvas: TcxCanvas;
|
|
const ABounds: TRect): Boolean;
|
|
begin {4}
|
|
Result := ViewInfo.BackgroundBitmap <> nil;
|
|
if Result then
|
|
ACanvas.FillRect(ABounds, ViewInfo.BackgroundBitmap);
|
|
end;
|
|
|
|
procedure TcxCustomGridCellPainter.DrawBorder(ABorder: TcxBorder);
|
|
begin
|
|
with Canvas do
|
|
begin
|
|
SetBrushColor(ViewInfo.BorderColor[ABorder]);
|
|
FillRect(ViewInfo.BorderBounds[ABorder]);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellPainter.DrawBorders;
|
|
var
|
|
ABorder: TcxBorder;
|
|
begin
|
|
for ABorder := Low(ABorder) to High(ABorder) do
|
|
if ABorder in ViewInfo.Borders then
|
|
DrawBorder(ABorder);
|
|
end;
|
|
|
|
procedure TcxCustomGridCellPainter.DrawContent;
|
|
begin
|
|
if ViewInfo.HasBackground and not ViewInfo.DoCustomDrawBackground(Canvas) then
|
|
DrawBackground;
|
|
DrawText;
|
|
end;
|
|
|
|
class procedure TcxCustomGridCellPainter.DrawDesignSelection(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxCustomGridCellViewInfo);
|
|
begin
|
|
ACanvas.DrawDesignSelection(AViewInfo.DesignSelectionBounds, AViewInfo.DesignSelectionWidth);
|
|
end;
|
|
|
|
procedure TcxCustomGridCellPainter.DrawText;
|
|
var
|
|
R: TRect;
|
|
begin
|
|
with Canvas, ViewInfo do
|
|
if TextForPainting <> '' then
|
|
begin
|
|
R := TextAreaBounds; // can call font change
|
|
Font := Params.Font;
|
|
Font.Color := Params.TextColor;
|
|
Brush.Style := bsClear;
|
|
PrepareCanvasForDrawText;
|
|
DrawText(TextForPainting, R, GetTextAttributes(True));
|
|
UnprepareCanvasForDrawText;
|
|
Brush.Style := bsSolid;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridCellPainter.ExcludeFromClipRect: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
class function TcxCustomGridCellPainter.GetIsMainCanvasInUse(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxCustomGridCellViewInfo): Boolean;
|
|
begin
|
|
Result := ACanvas = AViewInfo.Canvas;
|
|
end;
|
|
|
|
function TcxCustomGridCellPainter.NeedsPainting: Boolean;
|
|
begin
|
|
Result := ViewInfo.Calculated and Canvas.RectVisible(ViewInfo.GetAreaBoundsForPainting);
|
|
end;
|
|
|
|
procedure TcxCustomGridCellPainter.Paint;
|
|
var
|
|
ASavedParams: TcxViewParams;
|
|
begin
|
|
ViewInfo.SaveParams(ASavedParams);
|
|
try
|
|
if not ViewInfo.DoCustomDraw(Canvas) then
|
|
DrawContent;
|
|
finally
|
|
ViewInfo.RestoreParams(ASavedParams);
|
|
end;
|
|
DrawBorders;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellPainter.PrepareCanvasForDrawText;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridCellPainter.UnprepareCanvasForDrawText;
|
|
begin
|
|
end;
|
|
|
|
class procedure TcxCustomGridCellPainter.DoDrawDesignSelection(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxCustomGridCellViewInfo);
|
|
begin
|
|
if AViewInfo.IsDesignSelected and GetIsMainCanvasInUse(ACanvas, AViewInfo) then
|
|
DrawDesignSelection(ACanvas, AViewInfo);
|
|
end;
|
|
|
|
procedure TcxCustomGridCellPainter.MainPaint;
|
|
begin
|
|
if not NeedsPainting then Exit;
|
|
BeforePaint;
|
|
Paint;
|
|
AfterPaint;
|
|
if ExcludeFromClipRect then DoExcludeFromClipRect;
|
|
end;
|
|
|
|
{ TcxGridDesignSelectorPainter }
|
|
|
|
function TcxGridDesignSelectorPainter.GetViewInfo: TcxGridDesignSelectorViewInfo;
|
|
begin
|
|
Result := TcxGridDesignSelectorViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
procedure TcxGridDesignSelectorPainter.DoExcludeFromClipRect;
|
|
begin
|
|
Canvas.SetClipRegion(ViewInfo.Region, roSubtract, False);
|
|
end;
|
|
|
|
procedure TcxGridDesignSelectorPainter.DrawSign(AColor: TColor);
|
|
const
|
|
SignOffsetStart = 3;
|
|
SignOffsetEnd = 8;
|
|
SignElementSize = 2;
|
|
SignLineWidth = 1;
|
|
var
|
|
R: TRect;
|
|
I: Integer;
|
|
begin
|
|
R := ViewInfo.Bounds;
|
|
with R do
|
|
begin
|
|
Inc(Left, SignOffsetStart);
|
|
Inc(Top, SignOffsetStart);
|
|
Dec(Right, SignOffsetEnd);
|
|
Dec(Bottom, SignOffsetEnd);
|
|
end;
|
|
Canvas.Brush.Color := AColor;
|
|
|
|
Canvas.FillRect(Rect(R.Left, R.Top, R.Left + SignLineWidth, R.Bottom));
|
|
Inc(R.Left, SignLineWidth);
|
|
for I := 0 to (R.Bottom - R.Top) div SignElementSize - 1 do
|
|
begin
|
|
R.Bottom := R.Top + SignLineWidth;
|
|
Canvas.FillRect(R);
|
|
R.Top := R.Bottom + SignElementSize - SignLineWidth;
|
|
Dec(R.Right, SignElementSize);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridDesignSelectorPainter.ExcludeFromClipRect: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TcxGridDesignSelectorPainter.Paint;
|
|
var
|
|
AParams: TcxViewParams;
|
|
begin
|
|
ViewInfo.GetViewParams(AParams);
|
|
Canvas.DrawRegion(ViewInfo.Region, AParams.Color, AParams.TextColor);
|
|
DrawSign(AParams.TextColor);
|
|
end;
|
|
|
|
{ TcxCustomGridPainter }
|
|
|
|
function TcxCustomGridPainter.GetCanvas: TcxCanvas;
|
|
begin
|
|
if FCanvas = nil then
|
|
Result := ViewInfo.Canvas
|
|
else
|
|
Result := FCanvas;
|
|
end;
|
|
|
|
function TcxCustomGridPainter.GetViewInfo: TcxCustomGridViewInfo;
|
|
begin
|
|
if FViewInfo = nil then
|
|
Result := inherited ViewInfo
|
|
else
|
|
Result := FViewInfo;
|
|
end;
|
|
|
|
procedure TcxCustomGridPainter.DrawBackground;
|
|
|
|
procedure DrawBackgroundUsingBrush;
|
|
begin
|
|
with Canvas do
|
|
begin
|
|
Brush.Color := ViewInfo.BackgroundColor;
|
|
FillRgn(Handle, FBackgroundRegion.Handle, Brush.Handle);
|
|
end;
|
|
end;
|
|
|
|
procedure DrawBackgroundUsingBitmap;
|
|
var
|
|
AClipRegion: TcxRegion;
|
|
begin
|
|
with Canvas do
|
|
begin
|
|
AClipRegion := GetClipRegion;
|
|
SetClipRegion(FBackgroundRegion, roIntersect, False);
|
|
FillRect(ViewInfo.Bounds, ViewInfo.BackgroundBitmap);
|
|
SetClipRegion(AClipRegion, roSet);
|
|
end;
|
|
end;
|
|
|
|
begin
|
|
if ViewInfo.BackgroundBitmap = nil then
|
|
DrawBackgroundUsingBrush
|
|
else
|
|
DrawBackgroundUsingBitmap; {4}
|
|
//Canvas.ExcludeClipRect(ViewInfo.Bounds);
|
|
end;
|
|
|
|
procedure TcxCustomGridPainter.PaintAfter;
|
|
begin
|
|
DrawBackground;
|
|
FreeAndNil(FBackgroundRegion);
|
|
Canvas.SetClipRegion(FBeforePaintClipRegion, roSet);
|
|
end;
|
|
|
|
procedure TcxCustomGridPainter.PaintBefore;
|
|
begin
|
|
FBeforePaintClipRegion := Canvas.GetClipRegion;
|
|
FBackgroundRegion := TcxRegion.Create(ViewInfo.Bounds);
|
|
if ViewInfo.DesignSelectorViewInfo <> nil then
|
|
ViewInfo.DesignSelectorViewInfo.Paint(Canvas);
|
|
end;
|
|
|
|
procedure TcxCustomGridPainter.PaintContent;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridPainter.DrawFocusRect(const R: TRect; AHideFocusRect: Boolean);
|
|
begin
|
|
if GridView.IsControlFocused then
|
|
Canvas.DrawFocusRect(R)
|
|
else
|
|
if not AHideFocusRect then
|
|
with Canvas, R do
|
|
begin
|
|
InvertRect(Rect(Left, Top, Right, Top + 1));
|
|
InvertRect(Rect(Left, Bottom - 1, Right, Bottom));
|
|
InvertRect(Rect(Left, Top + 1, Left + 1, Bottom - 1));
|
|
InvertRect(Rect(Right - 1, Top + 1, Right, Bottom - 1));
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridPainter.ExcludeFromBackground(const R: TRect);
|
|
begin
|
|
FBackgroundRegion.Combine(TcxRegion.Create(R), roSubtract);
|
|
end;
|
|
|
|
procedure TcxCustomGridPainter.Paint(ACanvas: TcxCanvas = nil;
|
|
AViewInfo: TcxCustomGridViewInfo = nil);
|
|
{
|
|
var i,ft,lt:integer;
|
|
}
|
|
begin
|
|
{
|
|
ft:=gettickcount;
|
|
for i:=1 to 10 do
|
|
begin
|
|
}
|
|
ViewInfo := AViewInfo;
|
|
Canvas := ACanvas;
|
|
|
|
Controller.BeforePaint;
|
|
PaintBefore;
|
|
PaintContent;
|
|
PaintAfter;
|
|
Controller.AfterPaint;
|
|
|
|
Canvas := nil;
|
|
ViewInfo := nil;
|
|
{
|
|
windows.SelectClipRgn(canvas.Handle, 0);
|
|
end;
|
|
lt:=gettickcount;
|
|
application.MainForm.caption := inttostr(lt-ft);
|
|
}
|
|
end;
|
|
|
|
procedure TcxCustomGridPainter.Invalidate;
|
|
begin
|
|
Site.Invalidate;
|
|
end;
|
|
|
|
procedure TcxCustomGridPainter.Invalidate(const R: TRect);
|
|
begin
|
|
Site.InvalidateRect(R, False);
|
|
end;
|
|
|
|
procedure TcxCustomGridPainter.Invalidate(ARegion: TcxRegion);
|
|
begin
|
|
Site.InvalidateRgn(ARegion, False);
|
|
end;
|
|
|
|
{ TcxCustomGridViewData }
|
|
|
|
function TcxCustomGridViewData.GetSortingBySummaryEngineClass: TcxSortingBySummaryEngineClass;
|
|
begin
|
|
Result := TcxGridSortingBySummaryEngine;
|
|
end;
|
|
|
|
function TcxCustomGridViewData.IsEmpty: Boolean;
|
|
begin
|
|
Result := DataController.RowCount = 0;
|
|
end;
|
|
|
|
function TcxCustomGridViewData.MakeDetailVisible(ADetailLevel: TComponent{TcxGridLevel}): TcxCustomGridView;
|
|
begin
|
|
Result := nil;
|
|
end;
|
|
|
|
{ TcxGridSite }
|
|
|
|
constructor TcxGridSite.Create(AViewInfo: TcxCustomGridViewInfo);
|
|
begin
|
|
FViewInfo := AViewInfo;
|
|
inherited Create(nil);
|
|
ControlStyle := ControlStyle + [csNoDesignVisible];
|
|
Keys := [kArrows, kChars];
|
|
ParentColor := False;
|
|
{$IFDEF USETCXSCROLLBAR}
|
|
HScrollBar.UnlimitedTracking := True;
|
|
VScrollBar.UnlimitedTracking := True;
|
|
{$ENDIF}
|
|
end;
|
|
|
|
destructor TcxGridSite.Destroy;
|
|
begin
|
|
CancelPostBoundsChanged;
|
|
//!!!!FViewInfo.FSite := nil; should always be nil here already;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridSite.GetContainer: TcxControl;
|
|
begin
|
|
Result := GridView.Control;
|
|
end;
|
|
|
|
function TcxGridSite.GetController: TcxCustomGridController;
|
|
begin
|
|
Result := GridView.Controller;
|
|
end;
|
|
|
|
function TcxGridSite.GetGridView: TcxCustomGridView;
|
|
begin
|
|
Result := FViewInfo.GridView;
|
|
end;
|
|
|
|
function TcxGridSite.GetPainter: TcxCustomGridPainter;
|
|
begin
|
|
Result := GridView.Painter;
|
|
end;
|
|
|
|
procedure TcxGridSite.SendKeyDownNotification(var Message: TWMKeyDown);
|
|
begin
|
|
TcxCustomGrid(GridView.Control).SendNotifications(gnkKeyDown,
|
|
@Message);
|
|
end;
|
|
|
|
procedure TcxGridSite.CNKeyDown(var Message: TWMKeyDown);
|
|
begin
|
|
SendKeyDownNotification(Message);
|
|
if Message.Result = 0 then
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridSite.CNSysKeyDown(var Message: TWMKeyDown);
|
|
begin
|
|
SendKeyDownNotification(Message);
|
|
if Message.Result = 0 then
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridSite.BoundsChangedTimerHandler(Sender: TObject);
|
|
begin
|
|
CancelPostBoundsChanged;
|
|
GridView.BoundsChanged;
|
|
end;
|
|
|
|
function TcxGridSite.AllowAutoDragAndDropAtDesignTime(X, Y: Integer;
|
|
Shift: TShiftState): Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxGridSite.AllowDragAndDropWithoutFocus: Boolean;
|
|
begin
|
|
if TcxCustomGridAccess(GridView.Control).IsPopupControl then {8}
|
|
Result := True
|
|
else
|
|
Result := inherited AllowDragAndDropWithoutFocus;
|
|
end;
|
|
|
|
procedure TcxGridSite.BeforeMouseDown(Button: TMouseButton; Shift: TShiftState;
|
|
X, Y: Integer);
|
|
begin
|
|
inherited;
|
|
if HandleAllocated then
|
|
Controller.MouseDown(Button, Shift, X, Y);
|
|
end;
|
|
|
|
procedure TcxGridSite.BoundsChanged;
|
|
var
|
|
APrevSize: TPoint;
|
|
|
|
function AllowNotification: Boolean;
|
|
var
|
|
AGridView: TcxCustomGridView;
|
|
begin
|
|
AGridView := GridView;
|
|
repeat
|
|
Result := AGridView.ViewInfo.AllowBoundsChangedNotification;
|
|
AGridView := AGridView.MasterGridView;
|
|
until not Result or (AGridView = nil);
|
|
end;
|
|
|
|
begin
|
|
if CreatingWindow then Exit;
|
|
APrevSize := FSize;
|
|
UpdateSize;
|
|
if ViewInfo.VisibilityChanging then Exit;
|
|
if ((APrevSize.X <> 0) or (APrevSize.Y <> 0)) and
|
|
((APrevSize.X <> FSize.X) or (APrevSize.Y <> FSize.Y)) then
|
|
if AllowNotification then
|
|
GridView.BoundsChanged(True)
|
|
else
|
|
if UpdatingScrollBars then PostBoundsChanged;
|
|
{if AllowNotification and
|
|
((APrevSize.X <> 0) or (APrevSize.Y <> 0)) and
|
|
((APrevSize.X <> FSize.X) or (APrevSize.Y <> FSize.Y)) then
|
|
GridView.BoundsChanged(True);}
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridSite.CanDrag(X, Y: Integer): Boolean;
|
|
begin
|
|
Result := inherited CanDrag(X, Y) and Controller.CanDrag(X, Y);
|
|
end;
|
|
|
|
function TcxGridSite.CanFocusOnClick(X, Y: Integer): Boolean;
|
|
begin
|
|
Result := inherited CanFocusOnClick(X, Y) and Controller.CanFocusOnClick(X, Y);
|
|
end;
|
|
|
|
procedure TcxGridSite.DoCancelMode;
|
|
begin
|
|
inherited;
|
|
Controller.DoCancelMode;
|
|
end;
|
|
|
|
procedure TcxGridSite.DoContextPopup(MousePos: TPoint; var Handled: Boolean);
|
|
begin
|
|
inherited;
|
|
if not Handled and (GridView.Control <> nil) then
|
|
Handled := TcxCustomGrid(GridView.Control).SendNotifications(gnkContextMenu,
|
|
TObject((MousePos.X = -1) and (MousePos.Y = -1)));
|
|
end;
|
|
|
|
procedure TcxGridSite.DoEnter;
|
|
begin
|
|
inherited;
|
|
Controller.DoEnter;
|
|
end;
|
|
|
|
procedure TcxGridSite.DoExit;
|
|
begin
|
|
if not GridView.IsDestroying then
|
|
Controller.DoExit;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridSite.FocusChanged;
|
|
var
|
|
ALink: TcxObjectLink;
|
|
begin
|
|
ALink := cxAddObjectLink(Self);
|
|
try
|
|
inherited;
|
|
if IsFocused then
|
|
GridView.Focused := True;
|
|
if ALink.Ref = nil then Exit;
|
|
TcxCustomGridAccess(Container).UpdateFocusing(GridView.IsControlFocused);
|
|
finally
|
|
cxRemoveObjectLink(ALink);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridSite.FocusWhenChildIsClicked(AChild: TControl): Boolean;
|
|
begin
|
|
Result := inherited FocusWhenChildIsClicked(AChild) and not Container.IsFocused;
|
|
end;
|
|
|
|
function TcxGridSite.GetClientBounds: TRect;
|
|
begin
|
|
Result := inherited GetClientBounds;
|
|
ViewInfo.AdjustClientBounds(Result);
|
|
end;
|
|
|
|
function TcxGridSite.GetCursor(X, Y: Integer): TCursor;
|
|
begin
|
|
Result := Controller.GetCursor(X, Y);
|
|
if Result = crDefault then
|
|
Result := inherited GetCursor(X, Y);
|
|
end;
|
|
|
|
function TcxGridSite.GetDesignHitTest(X, Y: Integer; Shift: TShiftState): Boolean;
|
|
var
|
|
AHitTest: TcxCustomGridHitTest;
|
|
begin
|
|
Result := inherited GetDesignHitTest(X, Y, Shift);
|
|
if not Result and not ((ssRight in Shift) or (Shift = []) and MouseRightButtonReleased) and
|
|
not TcxCustomGrid(Container).UpdateLocked then
|
|
begin
|
|
AHitTest := ViewInfo.GetHitTest(X, Y);
|
|
Result := Controller.GetDesignHitTest(AHitTest);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridSite.GetIsDesigning: Boolean;
|
|
begin
|
|
if Container = nil then
|
|
Result := GridView.IsDesigning
|
|
else
|
|
Result := Container.IsDesigning;
|
|
end;
|
|
|
|
function TcxGridSite.GetIsFocused: Boolean;
|
|
begin
|
|
Result := (GridView.Control <> nil) and
|
|
TcxCustomGridAccess(GridView.Control).IsPopupControl or {8}
|
|
inherited GetIsFocused or Controller.HasFocusedControls;
|
|
end;
|
|
|
|
function TcxGridSite.GetMouseWheelScrollingKind: TcxMouseWheelScrollingKind;
|
|
begin
|
|
Result := Controller.GetMouseWheelScrollingKind;
|
|
end;
|
|
|
|
function TcxGridSite.IsPixelScrollBar(AKind: TScrollBarKind): Boolean;
|
|
begin
|
|
Result := Controller.IsPixelScrollBar(AKind);
|
|
end;
|
|
|
|
procedure TcxGridSite.KeyDown(var Key: Word; Shift: TShiftState);
|
|
begin
|
|
inherited;
|
|
Controller.DoKeyDown(Key, Shift);
|
|
end;
|
|
|
|
procedure TcxGridSite.KeyPress(var Key: Char);
|
|
begin
|
|
inherited;
|
|
Controller.KeyPress(Key);
|
|
end;
|
|
|
|
procedure TcxGridSite.KeyUp(var Key: Word; Shift: TShiftState);
|
|
begin
|
|
inherited;
|
|
Controller.KeyUp(Key, Shift);
|
|
end;
|
|
|
|
function TcxGridSite.MayFocus: Boolean;
|
|
begin
|
|
Result := inherited MayFocus and ((Parent = nil) or Controller.MayFocus);
|
|
end;
|
|
|
|
procedure TcxGridSite.MouseLeave(AControl: TControl);
|
|
begin
|
|
inherited;
|
|
Controller.MouseLeave;
|
|
end;
|
|
|
|
procedure TcxGridSite.MouseMove(Shift: TShiftState; X, Y: Integer);
|
|
begin
|
|
inherited;
|
|
if DragAndDropState = ddsNone then
|
|
Controller.MouseMove(Shift, X, Y);
|
|
end;
|
|
|
|
procedure TcxGridSite.MouseUp(Button: TMouseButton; Shift: TShiftState;
|
|
X, Y: Integer);
|
|
begin
|
|
if DragAndDropState = ddsNone then
|
|
begin
|
|
Controller.MouseUp(Button, Shift, X, Y);
|
|
inherited;
|
|
end
|
|
else
|
|
begin
|
|
inherited;
|
|
Controller.MouseUp(Button, Shift, X, Y);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridSite.Paint;
|
|
begin
|
|
if not FViewInfo.IsCalculating and (Left <> cxGridInvisibleCoordinate) then
|
|
begin
|
|
inherited;
|
|
Painter.Paint;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridSite.RequestAlign;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxGridSite.SetParent(AParent: TWinControl);
|
|
begin
|
|
if Parent <> AParent then
|
|
begin
|
|
if AParent <> nil then
|
|
LookAndFeel.MasterLookAndFeel := GridView.LookAndFeel;
|
|
InitTabStop(AParent);
|
|
if (AParent = nil) and GridView.Focused and
|
|
not (csDestroying in Parent.ComponentState) and Parent.CanFocus then
|
|
Parent.SetFocus;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridSite.WndProc(var Message: TMessage);
|
|
begin
|
|
{if (Message.Msg = WM_MOUSEACTIVATE) and IsDesigning then
|
|
Exit;}
|
|
Controller.WndProc(Message);
|
|
inherited WndProc(Message);
|
|
end;
|
|
|
|
procedure TcxGridSite.DoEndDrag(Target: TObject; X, Y: Integer);
|
|
begin
|
|
Controller.EndDrag(Target, X, Y);
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridSite.DoStartDrag(var DragObject: TDragObject);
|
|
begin
|
|
Controller.BeforeStartDrag;
|
|
inherited;
|
|
Controller.StartDrag(DragObject);
|
|
end;
|
|
|
|
procedure TcxGridSite.DragOver(Source: TObject; X, Y: Integer; State: TDragState;
|
|
var Accept: Boolean);
|
|
begin
|
|
inherited;
|
|
Controller.DragOver(Source, X, Y, State, Accept);
|
|
end;
|
|
|
|
procedure TcxGridSite.DrawDragImage(ACanvas: TcxCanvas; const R: TRect);
|
|
begin
|
|
Controller.DrawDragImage(ACanvas, R);
|
|
end;
|
|
|
|
function TcxGridSite.GetDragImagesSize: TPoint;
|
|
begin
|
|
Result := Controller.GetDragImagesSize;
|
|
end;
|
|
|
|
function TcxGridSite.HasDragImages: Boolean;
|
|
begin
|
|
Result := Controller.HasDragImages;
|
|
end;
|
|
|
|
function TcxGridSite.GetHScrollBarBounds: TRect;
|
|
begin
|
|
Result := inherited GetHScrollBarBounds;
|
|
ViewInfo.GetHScrollBarBounds(Result);
|
|
end;
|
|
|
|
procedure TcxGridSite.InitScrollBarsParameters;
|
|
begin
|
|
Controller.InitScrollBarsParameters;
|
|
end;
|
|
|
|
procedure TcxGridSite.Scroll(AScrollBarKind: TScrollBarKind;
|
|
AScrollCode: TScrollCode; var AScrollPos: Integer);
|
|
begin
|
|
Controller.Scroll(AScrollBarKind, AScrollCode, AScrollPos);
|
|
end;
|
|
|
|
procedure TcxGridSite.UpdateScrollBars;
|
|
begin
|
|
if not FViewInfo.IsCalculating and GridView.Visible and
|
|
(IgnoreUpdateLock or (Container <> nil) and not TcxCustomGrid(Container).UpdateLocked) then
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridSite.DragAndDrop(const P: TPoint; var Accepted: Boolean);
|
|
begin
|
|
inherited;
|
|
Controller.DragAndDrop(P, Accepted);
|
|
end;
|
|
|
|
procedure TcxGridSite.EndDragAndDrop(Accepted: Boolean);
|
|
begin
|
|
Controller.EndDragAndDrop(Accepted);
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridSite.StartDragAndDrop(const P: TPoint): Boolean;
|
|
begin
|
|
Result := Controller.StartDragAndDrop(P);
|
|
end;
|
|
|
|
procedure TcxGridSite.CancelPostBoundsChanged;
|
|
begin
|
|
FreeAndNil(FBoundsChangedTimer);
|
|
end;
|
|
|
|
procedure TcxGridSite.InitTabStop(AParent: TWinControl);
|
|
begin
|
|
if (AParent <> nil) and (GridView.Level <> nil) then
|
|
GridView.TabStop := TcxGridLevel(GridView.Level).IsTop;
|
|
end;
|
|
|
|
procedure TcxGridSite.PostBoundsChanged;
|
|
begin
|
|
if FBoundsChangedTimer <> nil then Exit;
|
|
FBoundsChangedTimer := TcxTimer.Create(nil);
|
|
with FBoundsChangedTimer do
|
|
begin
|
|
Interval := 1;
|
|
OnTimer := BoundsChangedTimerHandler;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxGridSite.UpdateSize;
|
|
begin
|
|
FSize := ClientBounds.BottomRight;
|
|
end;
|
|
|
|
procedure TcxGridSite.BeginDragAndDrop;
|
|
begin
|
|
Controller.BeginDragAndDrop;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridSite.DragDrop(Source: TObject; X, Y: Integer);
|
|
begin
|
|
Controller.DragDrop(Source, X, Y);
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridSite.ExecuteAction(Action: TBasicAction): Boolean;
|
|
begin
|
|
Result := inherited ExecuteAction(Action) or
|
|
GridView.Focused and GridView.DataController.ExecuteAction(Action);
|
|
end;
|
|
|
|
procedure TcxGridSite.SetBounds(ALeft, ATop, AWidth, AHeight: Integer);
|
|
var
|
|
APrevWidth, APrevHeight: Integer;
|
|
begin
|
|
APrevWidth := Width;
|
|
APrevHeight := Height;
|
|
inherited;
|
|
if (Width <> APrevWidth) or (Height <> APrevHeight) then
|
|
UpdateSize;
|
|
end;
|
|
|
|
procedure TcxGridSite.SetFocus;
|
|
var
|
|
ALink: TcxObjectLink;
|
|
begin
|
|
ALink := cxAddObjectLink(Self);
|
|
try
|
|
if not GridView.Focused then
|
|
TcxCustomGrid(Container).FocusedView.Controller.BeforeKillFocus;
|
|
if ALink.Ref = nil then Exit;
|
|
inherited;
|
|
finally
|
|
cxRemoveObjectLink(ALink);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridSite.UpdateAction(Action: TBasicAction): Boolean;
|
|
begin
|
|
Result := inherited UpdateAction(Action) or
|
|
GridView.Focused and GridView.DataController.UpdateAction(Action);
|
|
end;
|
|
|
|
{ TcxCustomGridCellViewInfo }
|
|
|
|
constructor TcxCustomGridCellViewInfo.Create;
|
|
begin
|
|
inherited;
|
|
FVisible := True;
|
|
end;
|
|
|
|
destructor TcxCustomGridCellViewInfo.Destroy;
|
|
begin
|
|
LinkedHitTest := nil;
|
|
if DropDownWindowExists and (DropDownWindow.Owner = IcxCustomGridPopupOwner(Self)) then
|
|
DropDownWindow.Owner := nil;
|
|
MouseCapture := False;
|
|
State := gcsNone;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetBorderSize(AIndex: TcxBorder): Integer;
|
|
begin
|
|
if AIndex in Borders then
|
|
Result := BorderWidth[AIndex]
|
|
else
|
|
Result := 0;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetButtonState: TcxButtonState;
|
|
begin
|
|
Result := GridCellStateToButtonState(ActualState);
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetClientBounds: TRect;
|
|
begin
|
|
if IsRectEmpty(FClientBounds) then
|
|
FClientBounds := CalculateClientBounds;
|
|
Result := FClientBounds;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetContentBounds: TRect;
|
|
begin
|
|
if IsRectEmpty(FContentBounds) then
|
|
FContentBounds := CalculateContentBounds;
|
|
Result := FContentBounds;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetTextBoundsValue: TRect;
|
|
begin
|
|
Result := GetTextBounds(True, True);
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetTextHeight: Integer;
|
|
begin
|
|
Result := CalculateTextHeight(False);
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetTextHeightWithOffset: Integer;
|
|
begin
|
|
Result := TextHeight;
|
|
GetCellTextAreaSize(Result);
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetTextWidth: Integer;
|
|
begin
|
|
Result := CalculateTextWidth;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetTextWidthWithOffset: Integer;
|
|
begin
|
|
Result := TextWidth;
|
|
GetCellTextAreaSize(Result);
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.SetLinkedHitTest(Value: TcxCustomGridHitTest);
|
|
var
|
|
APrevLinkedHitTest: TcxCustomGridHitTest;
|
|
begin
|
|
if FLinkedHitTest <> Value then
|
|
begin
|
|
APrevLinkedHitTest := FLinkedHitTest;
|
|
FLinkedHitTest := Value;
|
|
if (APrevLinkedHitTest <> nil) and (APrevLinkedHitTest.ViewInfo = Self) then
|
|
APrevLinkedHitTest.ViewInfo := nil;
|
|
if FLinkedHitTest <> nil then
|
|
FLinkedHitTest.ViewInfo := Self;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.SetState(Value: TcxGridCellState);
|
|
var
|
|
APrevState: TcxGridCellState;
|
|
begin
|
|
if FState <> Value then
|
|
begin
|
|
BeforeStateChange;
|
|
APrevState := FState;
|
|
FState := Value;
|
|
StateChanged(APrevState);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.DoCancelMode;
|
|
begin
|
|
State := gcsNone;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.MouseLeave;
|
|
begin
|
|
if not MouseCapture and
|
|
((FState = gcsSelected) or not IsCheck and (FState = gcsPressed)) then
|
|
State := gcsNone;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.PtInCaller(const P: TPoint): Boolean;
|
|
begin
|
|
Result := HasPoint(P);
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.ClosePopupWhenNilOwner: Boolean;
|
|
begin
|
|
Result := CloseDropDownWindowOnDestruction;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetOwnerBounds: TRect;
|
|
begin
|
|
Result := GetDropDownWindowOwnerBounds;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.PopupClosed;
|
|
begin
|
|
CloseUp;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.AfterCalculateBounds(var ABounds: TRect);
|
|
begin
|
|
ResetContentBounds;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.AfterCustomDraw(ACanvas: TcxCanvas);
|
|
begin
|
|
ACanvas.GetParams(Params);
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.BeforeCustomDraw(ACanvas: TcxCanvas);
|
|
begin
|
|
ACanvas.SetParams(Params);
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.BeforeStateChange;
|
|
begin
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.CalculateClientBounds: TRect;
|
|
var
|
|
ABorder: TcxBorder;
|
|
ABorderSize: Integer;
|
|
begin
|
|
Result := Bounds;
|
|
for ABorder := Low(ABorder) to High(ABorder) do
|
|
begin
|
|
ABorderSize := BorderSize[ABorder];
|
|
with Result do
|
|
case ABorder of
|
|
bLeft:
|
|
Inc(Left, ABorderSize);
|
|
bTop:
|
|
Inc(Top, ABorderSize);
|
|
bRight:
|
|
Dec(Right, ABorderSize);
|
|
bBottom:
|
|
Dec(Bottom, ABorderSize);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.CalculateContentBounds: TRect;
|
|
begin
|
|
Result := ClientBounds;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.CalculateTextWidth(AAngle: Integer = 0): Integer;
|
|
var
|
|
R: TRect;
|
|
begin
|
|
CalculateParams;
|
|
R := Rect(0, 0, MaxInt div 2, MaxInt div 2);
|
|
Canvas.Font := Params.Font;
|
|
if AAngle <> 0 then
|
|
Canvas.SetFontAngle(AAngle);
|
|
// Result := Canvas.TextWidth(Text);
|
|
Canvas.TextExtent(Text, R,
|
|
GetTextAttributes(False{AForPainting}) and not (cxAlignRight or cxAlignCenter) or cxAlignLeft);
|
|
if AAngle <> 0 then
|
|
Canvas.SetFontAngle(0);
|
|
Result := R.Right - R.Left;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.CalculateTextHeight(AForPainting: Boolean;
|
|
AAngle: Integer = 0): Integer;
|
|
var
|
|
R: TRect;
|
|
begin
|
|
CalculateParams;
|
|
R := TextAreaBounds;
|
|
Canvas.Font := Params.Font;
|
|
if AAngle <> 0 then
|
|
Canvas.SetFontAngle(AAngle);
|
|
Canvas.TextExtent(Text, R,
|
|
GetTextAttributes(AForPainting) and not (cxAlignBottom or cxAlignVCenter) or cxAlignTop); {1}
|
|
if AAngle <> 0 then
|
|
Canvas.SetFontAngle(0);
|
|
Result := R.Bottom - R.Top;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.CalculateParams;
|
|
begin
|
|
if FParamsCalculated or FCalculatingParams then Exit;
|
|
FCalculatingParams := True;
|
|
try
|
|
DoCalculateParams;
|
|
finally
|
|
FCalculatingParams := False;
|
|
FParamsCalculated := True;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.CalculateParamsNeeded;
|
|
begin
|
|
FParamsCalculated := False;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.CalculateHeight: Integer;
|
|
begin
|
|
Result := Bounds.Bottom - Bounds.Top;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.CalculateWidth: Integer;
|
|
begin
|
|
Result := Bounds.Right - Bounds.Left;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.CaptureMouseOnPress: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.Click;
|
|
begin
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.CustomDraw(ACanvas: TcxCanvas): Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.CustomDrawBackground(ACanvas: TcxCanvas): Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.Destroying;
|
|
begin
|
|
FIsDestroying := True;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.DoCalculateParams;
|
|
begin
|
|
AlignmentHorz := GetAlignmentHorz;
|
|
AlignmentVert := GetAlignmentVert;
|
|
GetViewParams(Params);
|
|
Borders := GetBorders;
|
|
Text := GetText;
|
|
MultiLine := GetMultiLine;
|
|
MultiLinePainting := GetMultiLinePainting;
|
|
Width := CalculateWidth;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.DoInvalidate;
|
|
begin
|
|
if Control <> nil then
|
|
Control.InvalidateRect(Bounds, False);
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.DoCustomDraw(ACanvas: TcxCanvas): Boolean;
|
|
begin
|
|
Result := HasCustomDraw;
|
|
if Result then
|
|
begin
|
|
BeforeCustomDraw(ACanvas);
|
|
Result := CustomDraw(ACanvas);
|
|
if not Result then
|
|
AfterCustomDraw(ACanvas);
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.DoCustomDrawBackground(ACanvas: TcxCanvas): Boolean;
|
|
begin
|
|
Result := HasCustomDrawBackground;
|
|
if Result then
|
|
begin
|
|
BeforeCustomDraw(ACanvas);
|
|
Result := CustomDrawBackground(ACanvas);
|
|
if not Result then
|
|
AfterCustomDraw(ACanvas);
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetActualState: TcxGridCellState;
|
|
begin
|
|
Result := FState;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetAlignmentHorz: TAlignment;
|
|
begin
|
|
Result := taLeftJustify;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetAlignmentVert: TcxAlignmentVert;
|
|
begin
|
|
Result := vaTop;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetAreaBounds: TRect;
|
|
begin
|
|
SetRectEmpty(Result);
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetBackgroundBitmap: TBitmap;
|
|
begin {4}
|
|
Result := Params.Bitmap;
|
|
//Result := nil;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetBorderColor(AIndex: TcxBorder): TColor;
|
|
begin
|
|
Result := clDefault;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetBorderBounds(AIndex: TcxBorder): TRect;
|
|
begin
|
|
Result := ClientBounds;
|
|
with Result do
|
|
begin
|
|
case AIndex of
|
|
bLeft:
|
|
begin
|
|
Right := Left;
|
|
Dec(Left, BorderWidth[AIndex]);
|
|
end;
|
|
bTop:
|
|
begin
|
|
Bottom := Top;
|
|
Dec(Top, BorderWidth[AIndex]);
|
|
end;
|
|
bRight:
|
|
begin
|
|
Left := Right;
|
|
Inc(Right, BorderWidth[AIndex]);
|
|
end;
|
|
bBottom:
|
|
begin
|
|
Top := Bottom;
|
|
Inc(Bottom, BorderWidth[AIndex]);
|
|
end;
|
|
end;
|
|
if AIndex in [bLeft, bRight] then
|
|
begin
|
|
if bTop in Borders then
|
|
Dec(Top, BorderWidth[bTop]);
|
|
if bBottom in Borders then
|
|
Inc(Bottom, BorderWidth[bBottom]);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetBorders: TcxBorders;
|
|
begin
|
|
Result := [];
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetBorderWidth(AIndex: TcxBorder): Integer;
|
|
begin
|
|
Result := 0;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetBounds: TRect;
|
|
var
|
|
AArea: TRect;
|
|
begin
|
|
Result := Bounds;
|
|
AArea := GetAreaBounds;
|
|
if not IsRectEmpty(AArea) then
|
|
IntersectRect(Result, Result, AArea);
|
|
end;
|
|
|
|
class function TcxCustomGridCellViewInfo.GetCellHeight(ATextHeight: Integer;
|
|
ALookAndFeelPainter: TcxCustomLookAndFeelPainterClass): Integer;
|
|
begin
|
|
Result := ATextHeight;
|
|
GetCellTextAreaSize(Result);
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetContentHeight: Integer;
|
|
begin
|
|
with ContentBounds do
|
|
Result := Bottom - Top;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetContentWidth: Integer;
|
|
begin
|
|
with ContentBounds do
|
|
Result := Right - Left;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetControl: TcxControl;
|
|
begin
|
|
if (Canvas.Canvas is TControlCanvas) and
|
|
(TControlCanvas(Canvas.Canvas).Control is TcxControl) then
|
|
Result := TControlCanvas(Canvas.Canvas).Control as TcxControl
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetDesignSelectionBounds: TRect;
|
|
begin
|
|
Result := Bounds;
|
|
InflateRect(Result, -1, -1);
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetDesignSelectionWidth: Integer;
|
|
begin
|
|
Result := cxDesignSelectionWidth;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetHeight: Integer;
|
|
begin
|
|
with Bounds do
|
|
Result := Bottom - Top;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetHotTrack: Boolean;
|
|
begin
|
|
Result := IsCheck;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetIsCheck: Boolean;
|
|
begin
|
|
Result := DropDownWindow <> nil;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetIsDesignSelected: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetIsVisibleForPainting: Boolean;
|
|
begin
|
|
Result := Visible;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetMouseCapture: Boolean;
|
|
begin
|
|
if Control = nil then
|
|
Result := False
|
|
else
|
|
Result := Control.MouseCaptureObject = Self;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetMultiLine: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetMultiLinePainting: Boolean;
|
|
begin
|
|
Result := MultiLine;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxCustomGridCellPainter;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetShowEndEllipsis: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetText: string;
|
|
begin
|
|
Result := '';
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetTextAreaBounds: TRect;
|
|
begin
|
|
Result := ContentBounds;
|
|
InflateRect(Result, -cxGridCellTextOffset, -cxGridCellTextOffset);
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetTextAttributes(AForPainting: Boolean): Integer;
|
|
const
|
|
MultiLines: array[Boolean] of Integer = (cxSingleLine, cxWordBreak);
|
|
ShowEndEllipsises: array[Boolean] of Integer = (0, cxShowEndEllipsis);
|
|
begin
|
|
Result :=
|
|
cxAlignmentsHorz[AlignmentHorz] or cxAlignmentsVert[AlignmentVert] or
|
|
MultiLines[AForPainting and MultiLinePainting or not AForPainting and MultiLine] or
|
|
ShowEndEllipsises[ShowEndEllipsis];
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetTextBounds(AHorizontal, AVertical: Boolean): TRect;
|
|
var
|
|
ATextWidth, ATextHeight: Integer;
|
|
begin
|
|
Result := TextAreaBounds;
|
|
if AHorizontal then
|
|
begin
|
|
ATextWidth := TextWidth;
|
|
with Result do
|
|
begin
|
|
if MultiLinePainting and (ATextWidth > Right - Left) then Exit;
|
|
case AlignmentHorz of
|
|
taLeftJustify:
|
|
Right := Left + ATextWidth;
|
|
taRightJustify:
|
|
Left := Right - ATextWidth;
|
|
taCenter:
|
|
begin
|
|
Left := (Left + Right - ATextWidth) div 2;
|
|
Right := Left + ATextWidth;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
if AVertical then
|
|
begin
|
|
ATextHeight := TextHeight;
|
|
with Result do
|
|
case AlignmentVert of
|
|
vaTop:
|
|
Bottom := Top + ATextHeight;
|
|
vaBottom:
|
|
Top := Bottom - ATextHeight;
|
|
vaCenter:
|
|
begin
|
|
Top := (Top + Bottom - ATextHeight) div 2;
|
|
Bottom := Top + ATextHeight;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetTextCellHeight(AGridViewInfo: TcxCustomGridViewInfo;
|
|
ALookAndFeelPainter: TcxCustomLookAndFeelPainterClass): Integer;
|
|
begin
|
|
CalculateParams;
|
|
if MultiLine then
|
|
Result := TextHeight
|
|
else
|
|
Result := AGridViewInfo.GetFontHeight(Params.Font);
|
|
Result := GetCellHeight(Result, ALookAndFeelPainter);
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetTextForPainting: string;
|
|
begin
|
|
Result := Text;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetTransparent: Boolean;
|
|
begin {4}
|
|
Result := BackgroundBitmap <> nil;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
begin
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetVisible: Boolean;
|
|
begin
|
|
Result := FVisible;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetVisibleForHitTest: Boolean;
|
|
begin
|
|
Result := Visible;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetWidth: Integer;
|
|
begin
|
|
with Bounds do
|
|
Result := Right - Left;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.HasBackground: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.HasCustomDraw: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.HasCustomDrawBackground: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.HasHitTestPoint(const P: TPoint): Boolean;
|
|
begin
|
|
Result := HasPoint(P);
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.HasMouse(AHitTest: TcxCustomGridHitTest): Boolean;
|
|
begin
|
|
Result := AHitTest is GetHitTestClass;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.InitHitTest(AHitTest: TcxCustomGridHitTest);
|
|
begin
|
|
AHitTest.ViewInfo := Self;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.InvalidateOnStateChange: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.Offset(DX, DY: Integer);
|
|
begin
|
|
OffsetRect(Bounds, DX, DY);
|
|
if not IsRectEmpty(FClientBounds) then
|
|
OffsetRect(FClientBounds, DX, DY);
|
|
if not IsRectEmpty(FContentBounds) then
|
|
OffsetRect(FContentBounds, DX, DY);
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.RestoreParams(const AParams: TcxViewParams);
|
|
begin
|
|
Params := AParams;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.SaveParams(out AParams: TcxViewParams);
|
|
begin
|
|
AParams := Params;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.SetHeight(Value: Integer);
|
|
begin
|
|
with Bounds do
|
|
Bottom := Top + Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.SetMouseCapture(Value: Boolean);
|
|
begin
|
|
if (Control <> nil) and (MouseCapture <> Value) then
|
|
if Value then
|
|
Control.MouseCaptureObject := Self
|
|
else
|
|
Control.MouseCaptureObject := nil;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.SetWidth(Value: Integer);
|
|
begin
|
|
with Bounds do
|
|
Right := Left + Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.StateChanged(APrevState: TcxGridCellState);
|
|
begin
|
|
if InvalidateOnStateChange then Invalidate;
|
|
case State of
|
|
gcsNone:
|
|
EndMouseTracking(Self);
|
|
gcsSelected:
|
|
if Control <> nil then
|
|
BeginMouseTracking(Control, Bounds, Self);
|
|
end;
|
|
if CaptureMouseOnPress then
|
|
case State of
|
|
gcsPressed:
|
|
MouseCapture := True;
|
|
{gcsNone:
|
|
MouseCapture := False; - commented because of the Offset happening during drag&drop}
|
|
end;
|
|
if (State = gcsPressed) and (DropDownWindow <> nil) then
|
|
DropDown;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.DropDown;
|
|
begin
|
|
if DropDownWindow.Visible then Exit;
|
|
DropDownWindow.Owner := Self;
|
|
DropDownWindow.Popup;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.CloseUp;
|
|
begin
|
|
State := gcsNone;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.CloseDropDownWindowOnDestruction: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.DropDownWindowExists: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetDropDownWindow: TcxCustomGridPopup;
|
|
begin
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetDropDownWindowOwnerBounds: TRect;
|
|
begin
|
|
Result := Bounds;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.IsDropDownWindowOwner: Boolean;
|
|
begin
|
|
Result := DropDownWindow.Owner = nil;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.AfterConstruction;
|
|
begin
|
|
inherited;
|
|
if not CloseDropDownWindowOnDestruction and DropDownWindowExists and
|
|
DropDownWindow.Visible and IsDropDownWindowOwner then
|
|
begin
|
|
DropDownWindow.Owner := Self;
|
|
State := gcsPressed;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.AfterRecalculation;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.BeforeDestruction;
|
|
begin
|
|
Destroying;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.BeforeRecalculation;
|
|
begin
|
|
CalculateParamsNeeded;
|
|
//ResetContentBounds;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.Calculate(ALeftBound, ATopBound: Integer;
|
|
AWidth: Integer = -1; AHeight: Integer = -1);
|
|
begin
|
|
CalculateParams;
|
|
if AWidth = -1 then AWidth := CalculateWidth;
|
|
if AHeight = -1 then AHeight := CalculateHeight;
|
|
with Bounds do
|
|
begin
|
|
Left := ALeftBound;
|
|
Top := ATopBound;
|
|
Right := Left + AWidth;
|
|
Bottom := Top + AHeight;
|
|
end;
|
|
AfterCalculateBounds(Bounds);
|
|
FCalculated := True;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.Calculate(const ABounds: TRect);
|
|
begin
|
|
with ABounds do
|
|
Calculate(Left, Top, Max(0, Right - Left), Max(0, Bottom - Top));
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetAreaBoundsForPainting: TRect;
|
|
begin
|
|
Result := Bounds;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetBestFitWidth: Integer;
|
|
begin
|
|
Result := BorderSize[bLeft] + TextWidthWithOffset + BorderSize[bRight];
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
|
|
begin
|
|
if VisibleForHitTest and HasHitTestPoint(P) and (GetHitTestClass <> nil) then
|
|
begin
|
|
Result := GetHitTestClass.Instance(P);
|
|
InitHitTest(Result);
|
|
end
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.HasPoint(const P: TPoint): Boolean;
|
|
begin
|
|
Result := PtInRect(GetBounds, P);
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.Invalidate;
|
|
begin
|
|
DoInvalidate;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.MouseDown(AHitTest: TcxCustomGridHitTest;
|
|
AButton: TMouseButton; AShift: TShiftState): Boolean;
|
|
begin
|
|
Result := False;
|
|
if (AButton = mbLeft) and HotTrack and HasMouse(AHitTest) then
|
|
begin
|
|
if IsCheck then
|
|
case FState of
|
|
gcsSelected:
|
|
State := gcsPressed;
|
|
gcsPressed:
|
|
State := gcsSelected;
|
|
end
|
|
else
|
|
State := gcsPressed;
|
|
Result := True;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.MouseMove(AHitTest: TcxCustomGridHitTest;
|
|
AShift: TShiftState): Boolean;
|
|
begin
|
|
Result := False;
|
|
if HotTrack then
|
|
if IsCheck then
|
|
if State <> gcsPressed then
|
|
begin
|
|
if HasMouse(AHitTest) then
|
|
State := gcsSelected
|
|
else
|
|
State := gcsNone;
|
|
Result := True;
|
|
end
|
|
else
|
|
else
|
|
begin
|
|
if HasMouse(AHitTest) then
|
|
if MouseCapture then
|
|
State := gcsPressed
|
|
else
|
|
State := gcsSelected
|
|
else
|
|
if MouseCapture then
|
|
State := gcsSelected
|
|
else
|
|
State := gcsNone;
|
|
Result := True;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.MouseUp(AHitTest: TcxCustomGridHitTest;
|
|
AButton: TMouseButton; AShift: TShiftState): Boolean;
|
|
begin
|
|
Result := False;
|
|
if (AButton = mbLeft) and not IsCheck then
|
|
begin
|
|
Result := State = gcsPressed;
|
|
State := gcsNone;
|
|
if Result then Click;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.DoOffset(DX, DY: Integer);
|
|
begin
|
|
if not Calculated then
|
|
Exit;
|
|
Offset(DX, DY);
|
|
State := gcsNone;
|
|
MouseLeave;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.Paint(ACanvas: TcxCanvas = nil);
|
|
begin
|
|
{if ACanvas = nil then ACanvas := Canvas;
|
|
if Visible and ACanvas.RectVisible(Bounds) and (GetPainterClass <> nil) then
|
|
begin
|
|
with GetPainterClass.Create(ACanvas, Self) do
|
|
try
|
|
MainPaint;
|
|
finally
|
|
Free;
|
|
end;
|
|
end;}
|
|
if IsVisibleForPainting and (GetPainterClass <> nil) then
|
|
begin
|
|
if ACanvas = nil then ACanvas := Canvas;
|
|
with GetPainterClass.Create(ACanvas, Self) do
|
|
try
|
|
MainPaint;
|
|
finally
|
|
Free;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.Recalculate;
|
|
begin
|
|
BeforeRecalculation;
|
|
Calculate(Bounds);
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.ResetContentBounds;
|
|
begin
|
|
SetRectEmpty(FClientBounds);
|
|
SetRectEmpty(FContentBounds);
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.Update;
|
|
begin
|
|
Recalculate;
|
|
Invalidate;
|
|
end;
|
|
|
|
{ TcxCustomGridViewCellViewInfo }
|
|
|
|
constructor TcxCustomGridViewCellViewInfo.Create(AGridViewInfo: TcxCustomGridViewInfo);
|
|
begin
|
|
FGridViewInfo := AGridViewInfo;
|
|
inherited Create;
|
|
end;
|
|
|
|
destructor TcxCustomGridViewCellViewInfo.Destroy;
|
|
begin
|
|
FGridViewInfo.RemoveActiveViewInfo(Self, True);
|
|
if Controller.HintCellViewInfo = Self then
|
|
Controller.HideHint;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.GetController: TcxCustomGridController;
|
|
begin
|
|
Result := GridView.Controller;
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.GetGridView: TcxCustomGridView;
|
|
begin
|
|
Result := FGridViewInfo.GridView;
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
|
|
begin
|
|
Result := FGridViewInfo.LookAndFeelPainter;
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.GetCanvas: TcxCanvas;
|
|
begin
|
|
Result := FGridViewInfo.Canvas;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewCellViewInfo.AfterCalculateBounds(var ABounds: TRect);
|
|
var
|
|
AHitTest: TcxCustomGridHitTest;
|
|
begin
|
|
inherited;
|
|
if EmulateMouseMoveAfterCalculate and HotTrack and
|
|
Control.HandleAllocated and GridViewInfo.Visible and
|
|
PtInRect(Bounds, GridViewInfo.MousePos) then
|
|
begin
|
|
AHitTest := GetHitTestClass.Instance(GridViewInfo.MousePos);
|
|
InitHitTest(AHitTest);
|
|
MouseMove(AHitTest, []);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewCellViewInfo.DoInvalidate;
|
|
begin
|
|
GridView.ViewChanged(Bounds);
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.EmulateMouseMoveAfterCalculate: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.GetControl: TcxControl;
|
|
begin
|
|
Result := GridView.Site;
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.HasMouse(AHitTest: TcxCustomGridHitTest): Boolean;
|
|
begin
|
|
Result := inherited HasMouse(AHitTest) and
|
|
(TcxCustomGridViewHitTest(AHitTest).GridView = GridView);
|
|
end;
|
|
|
|
procedure TcxCustomGridViewCellViewInfo.InitHitTest(AHitTest: TcxCustomGridHitTest);
|
|
begin
|
|
inherited;
|
|
GridViewInfo.InitHitTest(AHitTest);
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.CanShowHint: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewCellViewInfo.CheckHint(AHitTest: TcxCustomGridHitTest);
|
|
var
|
|
AHintText: TCaption;
|
|
AIsHintMultiLine: Boolean;
|
|
ATextRect, R: TRect;
|
|
begin
|
|
if NeedShowHint(AHitTest.Pos, AHintText, AIsHintMultiLine, ATextRect) then
|
|
begin
|
|
R := GetAreaBoundsForHint;
|
|
if not IsRectEmpty(R) then
|
|
begin
|
|
IntersectRect(R, ATextRect, R);
|
|
if not IsRectEmpty(R) then ATextRect := R;
|
|
end;
|
|
Controller.ShowHint(GetBoundsForHint, ATextRect, AHintText, AIsHintMultiLine,
|
|
Params.Font, Self);
|
|
end
|
|
else
|
|
Controller.HideHint;
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.GetAreaBoundsForHint: TRect;
|
|
begin
|
|
Result := GetAreaBounds;
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.GetBoundsForHint: TRect;
|
|
var
|
|
R: TRect;
|
|
begin
|
|
Result := GetCellBoundsForHint;
|
|
R := GetAreaBoundsForHint;
|
|
if not IsRectEmpty(R) then
|
|
IntersectRect(Result, Result, R);
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.GetCellBoundsForHint: TRect;
|
|
begin
|
|
Result := TextAreaBounds;
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.GetHintText: string;
|
|
begin
|
|
Result := Text;
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.GetHintTextRect(const AMousePos: TPoint): TRect;
|
|
begin
|
|
Result := TextAreaBounds;
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.HasHintPoint(const P: TPoint): Boolean;
|
|
begin
|
|
Result := PtInRect(GetBoundsForHint, P);
|
|
end;
|
|
|
|
procedure TcxCustomGridViewCellViewInfo.InitHint(const AMousePos: TPoint;
|
|
out AHintText: TCaption; out AIsHintMultiLine: Boolean; out ATextRect: TRect);
|
|
begin
|
|
AHintText := HintText;
|
|
AIsHintMultiLine := IsHintMultiLine;
|
|
ATextRect := GetHintTextRect(AMousePos);
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.IsHintForText: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.IsHintMultiLine: Boolean;
|
|
begin
|
|
Result := MultiLinePainting;
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.NeedShowHint(const AMousePos: TPoint;
|
|
out AHintText: TCaption; out AIsHintMultiLine: Boolean; out ATextRect: TRect): Boolean;
|
|
var
|
|
ATextBounds, R: TRect;
|
|
begin
|
|
Result := (HintText <> '') and HasHintPoint(AMousePos);
|
|
if Result then
|
|
begin
|
|
if IsHintForText then
|
|
begin
|
|
with TextAreaBounds do
|
|
Result := (CalculateTextHeight(True) > Bottom - Top) or
|
|
not MultiLinePainting and (TextWidth > Right - Left);
|
|
if not Result then
|
|
begin
|
|
ATextBounds := TextBounds;
|
|
IntersectRect(R, GetBoundsForHint, ATextBounds);
|
|
Result := not EqualRect(R, ATextBounds);
|
|
end;
|
|
end;
|
|
if Result then
|
|
InitHint(AMousePos, AHintText, AIsHintMultiLine, ATextRect);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewCellViewInfo.BeforeRecalculation;
|
|
begin
|
|
GridViewInfo.UpdateMousePos;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewCellViewInfo.Invalidate;
|
|
begin
|
|
if IsDestroying then Exit;
|
|
CalculateParams;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.MouseMove(AHitTest: TcxCustomGridHitTest;
|
|
AShift: TShiftState): Boolean;
|
|
begin
|
|
Result := inherited MouseMove(AHitTest, AShift);
|
|
if Visible and CanShowHint then
|
|
CheckHint(AHitTest);
|
|
end;
|
|
|
|
{ TcxGridDesignSelectorViewInfo }
|
|
|
|
destructor TcxGridDesignSelectorViewInfo.Destroy;
|
|
begin
|
|
DestroyRegion;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxGridDesignSelectorViewInfo.CalculateHeight: Integer;
|
|
begin
|
|
Result := DesignSelectorHeight;
|
|
end;
|
|
|
|
function TcxGridDesignSelectorViewInfo.CalculateWidth: Integer;
|
|
begin
|
|
Result := DesignSelectorWidth;
|
|
end;
|
|
|
|
function TcxGridDesignSelectorViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
|
|
begin
|
|
Result := TcxGridDesignSelectorHitTest;
|
|
end;
|
|
|
|
function TcxGridDesignSelectorViewInfo.GetHotTrack: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TcxGridDesignSelectorViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
|
|
begin
|
|
Result := TcxGridDesignSelectorPainter;
|
|
end;
|
|
|
|
procedure TcxGridDesignSelectorViewInfo.GetViewParams(var AParams: TcxViewParams);
|
|
const
|
|
Colors: array[Boolean, Boolean] of TColor =
|
|
((cxGridDesignViewColor, cxGridDesignViewHotColor),
|
|
(cxGridDesignSelectedColor, cxGridDesignSelectedHotColor));
|
|
BorderColors: array[Boolean, Boolean] of TColor =
|
|
((cxGridDesignViewBorderColor, cxGridDesignViewBorderColor),
|
|
(cxGridDesignSelectedBorderColor, cxGridDesignSelectedHotBorderColor));
|
|
var
|
|
AObjectSelected: Boolean;
|
|
begin
|
|
AObjectSelected := GridView.Controller.DesignController.IsObjectSelected(GridView);
|
|
AParams.Color := GetRealColor(Colors[AObjectSelected, State = gcsSelected]);
|
|
AParams.TextColor := GetRealColor(BorderColors[AObjectSelected, State = gcsSelected]);
|
|
end;
|
|
|
|
procedure TcxGridDesignSelectorViewInfo.CreateRegion;
|
|
var
|
|
Points: array[1..3] of TPoint;
|
|
begin
|
|
Points[1] := Point(0, 0);
|
|
Points[2] := Point(Width, 0);
|
|
Points[3] := Point(0, Height);
|
|
FRegion := TcxRegion.Create(CreatePolygonRgn(Points, Length(Points), WINDING));
|
|
FRegion.Offset(Bounds.Left, Bounds.Top);
|
|
end;
|
|
|
|
procedure TcxGridDesignSelectorViewInfo.DestroyRegion;
|
|
begin
|
|
FreeAndNil(FRegion);
|
|
end;
|
|
|
|
procedure TcxGridDesignSelectorViewInfo.Calculate(ALeftBound, ATopBound: Integer;
|
|
AWidth: Integer = -1; AHeight: Integer = -1);
|
|
begin
|
|
inherited;
|
|
DestroyRegion;
|
|
CreateRegion;
|
|
end;
|
|
|
|
function TcxGridDesignSelectorViewInfo.HasPoint(const P: TPoint): Boolean;
|
|
begin
|
|
Result := Region.PtInRegion(P);
|
|
end;
|
|
|
|
function TcxGridDesignSelectorViewInfo.MouseDown(AHitTest: TcxCustomGridHitTest;
|
|
AButton: TMouseButton; AShift: TShiftState): Boolean;
|
|
begin
|
|
if AButton = mbLeft then
|
|
begin
|
|
GridView.Controller.DesignController.SelectObject(GridView, not (ssShift in AShift));
|
|
Result := True;
|
|
end
|
|
else
|
|
Result := inherited MouseDown(AHitTest, AButton, AShift);
|
|
end;
|
|
|
|
{ TcxCustomGridViewInfo }
|
|
|
|
constructor TcxCustomGridViewInfo.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited;
|
|
InitializeCriticalSection(FLock);
|
|
FActiveViewInfos := TList.Create;
|
|
FAllowCheckCoordinates := True;
|
|
FAllowHideSite := True;
|
|
CreateSite;
|
|
CreateViewInfos;
|
|
end;
|
|
|
|
destructor TcxCustomGridViewInfo.Destroy;
|
|
begin
|
|
DestroySite;
|
|
FreeAndNil(FActiveViewInfos);
|
|
DeleteCriticalSection(FLock);
|
|
inherited;
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetCalculated: Boolean;
|
|
begin
|
|
Result := not IsRectEmpty(Bounds);
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetCanvas: TcxCanvas;
|
|
begin
|
|
Result := FSite.ActiveCanvas;
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetClientBounds: TRect;
|
|
begin
|
|
if FClientBoundsAssigned then
|
|
Result := FClientBounds
|
|
else
|
|
Result := CalculateClientBounds;
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetClientHeight: Integer;
|
|
begin
|
|
with ClientBounds do
|
|
Result := Bottom - Top;
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetClientWidth: Integer;
|
|
begin
|
|
with ClientBounds do
|
|
Result := Right - Left;
|
|
end;
|
|
|
|
{function TcxCustomGridViewInfo.GetIsCalculating: Boolean;
|
|
begin
|
|
Result := FIsCalculating or
|
|
GridView.IsDetail and GridView.MasterGridView.ViewInfo.IsCalculating;
|
|
end;}
|
|
|
|
function TcxCustomGridViewInfo.GetIsInternalUseValue: Boolean;
|
|
begin
|
|
Result := GetIsInternalUse or
|
|
GridView.IsDetail and
|
|
(GridView.MasterGridView.ViewInfo <> nil) and
|
|
GridView.MasterGridView.ViewInfo.IsInternalUse;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.SetClientBounds(const Value: TRect);
|
|
begin
|
|
FClientBounds := Value;
|
|
FClientBoundsAssigned := True;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.CreateViewInfos;
|
|
begin
|
|
if GridView.IsDesigning then
|
|
FDesignSelectorViewInfo := GetDesignSelectorViewInfoClass.Create(Self);
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.DestroyViewInfos(AIsRecreating: Boolean);
|
|
begin
|
|
FreeAndNil(FDesignSelectorViewInfo);
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.RecreateViewInfos;
|
|
begin
|
|
FClientBoundsAssigned := False;
|
|
DestroyViewInfos(True);
|
|
CreateViewInfos;
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetDesignSelectorViewInfoClass: TcxGridDesignSelectorViewInfoClass;
|
|
begin
|
|
Result := TcxGridDesignSelectorViewInfo;
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.CanHideSite: Boolean;
|
|
var
|
|
AGrid: TcxCustomGrid;
|
|
begin
|
|
AGrid := TcxCustomGrid(Control);
|
|
Result := (Control = nil) or GridView.IsDestroying or
|
|
FAllowHideSite and not FSite.IsFocused and
|
|
((AGrid.FocusedView = nil) or not FSite.ContainsControl(AGrid.FocusedView.Site));
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.CreateSite;
|
|
begin
|
|
FSite := GetSiteClass.Create(Self);
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.DestroySite;
|
|
begin
|
|
FreeAndNil(FSite);
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetSiteClass: TcxGridSiteClass;
|
|
begin
|
|
Result := TcxGridSite;
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetSiteParent: TWinControl;
|
|
begin
|
|
if GridView.IsDetail then
|
|
Result := GridView.MasterGridView.Site
|
|
else
|
|
Result := Control;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.AddActiveViewInfo(AViewInfo: TObject);
|
|
begin
|
|
FActiveViewInfos.Add(AViewInfo);
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.IsViewInfoActive(AViewInfo: TObject): Boolean;
|
|
begin
|
|
Result := FActiveViewInfos.IndexOf(AViewInfo) <> -1;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.RemoveActiveViewInfo(AViewInfo: TObject;
|
|
ARemoveAll: Boolean = False);
|
|
var
|
|
AIndex: Integer;
|
|
begin
|
|
repeat
|
|
AIndex := FActiveViewInfos.IndexOf(AViewInfo);
|
|
if AIndex = -1 then Break;
|
|
FActiveViewInfos.Delete(AIndex);
|
|
if not ARemoveAll then Break;
|
|
until False;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.AddScrollBarHeight(var AHeight: Integer);
|
|
begin
|
|
if Site.HScrollBarVisible then
|
|
Inc(AHeight, Site.HScrollBar.Height);
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.AdjustClientBounds(var ABounds: TRect);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.AfterCalculating;
|
|
begin
|
|
if not IsInternalUse then Controller.UpdateScrollBars(True);
|
|
if CanCheckCoordinates then Controller.DoCheckCoordinates;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.BeforeCalculating;
|
|
begin
|
|
UpdateMousePos;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.Calculate;
|
|
begin
|
|
if DesignSelectorViewInfo <> nil then
|
|
with GetDesignSelectorPos do
|
|
DesignSelectorViewInfo.Calculate(X, Y);
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.CalculateClientBounds: TRect;
|
|
begin
|
|
Result := Bounds;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.CalculateHeight(const AMaxSize: TPoint;
|
|
var AHeight: Integer; var AFullyVisible: Boolean);
|
|
begin
|
|
AddScrollBarHeight(AHeight);
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.CalculateWidth(const AMaxSize: TPoint; var AWidth: Integer);
|
|
begin
|
|
if Site.VScrollBarVisible then
|
|
Inc(AWidth, Site.VScrollBar.Width);
|
|
if AWidth > AMaxSize.X then AWidth := AMaxSize.X;
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.CanCheckCoordinates: Boolean;
|
|
begin
|
|
Result := not IsInternalUse and FAllowCheckCoordinates;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.ControlFocusChanged;
|
|
begin
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.DoGetHitTest(const P: TPoint): TcxCustomGridHitTest;
|
|
begin
|
|
Result := TcxGridViewNoneHitTest.Instance(P);
|
|
InitHitTest(Result);
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetAllowBoundsChangedNotification: Boolean;
|
|
begin
|
|
Result := not IsCalculating and not VisibilityChanging;
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetBackgroundBitmap: TBitmap;
|
|
begin {4}
|
|
Result := GridView.BackgroundBitmaps.GetBitmap(bbBackground);
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetBackgroundColor: TColor;
|
|
var
|
|
AParams: TcxViewParams;
|
|
begin
|
|
GridView.Styles.GetViewParams(vsBackground, nil, nil, AParams);
|
|
Result := AParams.Color;
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetDesignSelectorPos: TPoint;
|
|
begin
|
|
Result := Bounds.TopLeft;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.GetHScrollBarBounds(var ABounds: TRect);
|
|
begin
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetIsInternalUse: Boolean;
|
|
begin
|
|
Result := FIsInternalUse;
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetVisible: Boolean;
|
|
begin
|
|
Result := not IsInternalUse and not FSizeCalculating and
|
|
not GridView.DataController.IsUpdatingItems;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.InitHitTest(AHitTest: TcxCustomGridHitTest);
|
|
begin
|
|
(AHitTest as TcxCustomGridViewHitTest).GridView := GridView;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.UpdateMousePos;
|
|
begin
|
|
if FSite.Left = cxGridInvisibleCoordinate then Exit;
|
|
if FSite.HandleAllocated and not FSite.IsDesigning then
|
|
FMousePos := FSite.ScreenToClient(GetMouseCursorPos)
|
|
else
|
|
FMousePos := Point(MaxInt, MaxInt);
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.VisibilityChanged(AVisible: Boolean);
|
|
begin
|
|
UpdateMousePos;
|
|
if AVisible then
|
|
FSite.Parent := GetSiteParent
|
|
else
|
|
if CanHideSite then
|
|
FSite.Parent := nil
|
|
else
|
|
FSite.Left := cxGridInvisibleCoordinate;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.BeforeDestruction;
|
|
begin
|
|
inherited;
|
|
DestroyViewInfos(False);
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.DoVisibilityChanged(AVisible: Boolean);
|
|
begin
|
|
if Visible then
|
|
begin
|
|
FVisibilityChanging := True;
|
|
try
|
|
VisibilityChanged(AVisible and GridView.Visible);
|
|
finally
|
|
FVisibilityChanging := False;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetFontHeight(AFont: TFont): Integer;
|
|
begin
|
|
Canvas.Font := AFont;
|
|
Result := Canvas.TextHeight('Qq');
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.GetFontMetrics(AFont: TFont; out AMetrics: TTextMetric);
|
|
begin
|
|
Canvas.Font := AFont;
|
|
GetTextMetrics(Canvas.Handle, AMetrics);
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.GetHeight(const AMaxSize: TPoint; var AHeight: Integer;
|
|
var AFullyVisible: Boolean);
|
|
begin
|
|
FSizeCalculating := True;
|
|
CalculateHeight(AMaxSize, AHeight, AFullyVisible);
|
|
FSizeCalculating := False;
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
|
|
begin
|
|
Result := nil;
|
|
if (Controller.CustomizationForm <> nil) and Site.HandleAllocated and
|
|
PtInRect(Controller.CustomizationForm.BoundsRect, Site.ClientToScreen(P)) then
|
|
begin
|
|
Result := TcxGridCustomizationFormHitTest.Instance(P);
|
|
InitHitTest(Result);
|
|
end
|
|
else
|
|
if DesignSelectorViewInfo <> nil then
|
|
Result := DesignSelectorViewInfo.GetHitTest(P);
|
|
if Result = nil then
|
|
Result := DoGetHitTest(P);
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetHitTest(X, Y: Integer): TcxCustomGridHitTest;
|
|
begin
|
|
Result := GetHitTest(Point(X, Y));
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.GetWidth(const AMaxSize: TPoint; var AWidth: Integer);
|
|
begin
|
|
FSizeCalculating := True;
|
|
CalculateWidth(AMaxSize, AWidth);
|
|
FSizeCalculating := False;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.MainCalculate(const ABounds: TRect);
|
|
|
|
//var ft,lt,i:integer;
|
|
|
|
begin
|
|
if FIsCalculating {or GridView.IsPattern} then Exit;
|
|
{
|
|
ft:=gettickcount;
|
|
for i:=1 to 1 + 9 * ord(not isinternaluse) do
|
|
begin
|
|
}
|
|
BeforeCalculating;
|
|
FIsCalculating := True;
|
|
try
|
|
FSite.BoundsRect := ABounds;
|
|
FBounds := FSite.ClientBounds;
|
|
Calculate;
|
|
finally
|
|
FIsCalculating := False;
|
|
AfterCalculating;
|
|
DoVisibilityChanged(True);
|
|
end;
|
|
{
|
|
end;
|
|
lt:=gettickcount;
|
|
if not isinternaluse then
|
|
application.MainForm.Caption := inttostr(lt-ft) + ' - ' + application.MainForm.Caption;
|
|
}
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.Recalculate;
|
|
begin
|
|
MainCalculate(FSite.BoundsRect);
|
|
end;
|
|
|
|
{ TcxCustomGridViewInfoCacheItem }
|
|
|
|
constructor TcxCustomGridViewInfoCacheItem.Create(AOwner: TcxCustomGridViewInfoCache;
|
|
AIndex: Integer);
|
|
begin
|
|
inherited Create;
|
|
FIndex := AIndex;
|
|
FOwner := AOwner;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfoCacheItem.UnassignValues(AKeepMaster: Boolean);
|
|
begin
|
|
end;
|
|
|
|
{ TcxCustomGridViewInfoCache }
|
|
|
|
constructor TcxCustomGridViewInfoCache.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited;
|
|
FItems := TList.Create;
|
|
end;
|
|
|
|
destructor TcxCustomGridViewInfoCache.Destroy;
|
|
begin
|
|
DestroyItems;
|
|
FItems.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxCustomGridViewInfoCache.GetCount: Integer;
|
|
begin
|
|
Result := FItems.Count;
|
|
end;
|
|
|
|
function TcxCustomGridViewInfoCache.GetInternalItem(Index: Integer): TcxCustomGridViewInfoCacheItem;
|
|
begin
|
|
Result := TcxCustomGridViewInfoCacheItem(FItems[Index]);
|
|
end;
|
|
|
|
function TcxCustomGridViewInfoCache.GetItem(Index: Integer): TcxCustomGridViewInfoCacheItem;
|
|
begin
|
|
Result := InternalItems[Index];
|
|
if Result = nil then
|
|
begin
|
|
Result := GetItemClass(Index).Create(Self, Index);
|
|
FItems[Index] := Result;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfoCache.SetCount(Value: Integer);
|
|
begin
|
|
DestroyItems;
|
|
FItems.Count := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfoCache.DestroyItems;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to Count - 1 do TObject(FItems[I]).Free;
|
|
FItems.Clear;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfoCache.UnassignValues(AKeepMaster: Boolean = False);
|
|
|
|
procedure ProcessItems;
|
|
var
|
|
I: Integer;
|
|
AItem: TcxCustomGridViewInfoCacheItem;
|
|
begin
|
|
for I := 0 to Count - 1 do
|
|
begin
|
|
AItem := InternalItems[I];
|
|
if AItem <> nil then AItem.UnassignValues(AKeepMaster);
|
|
end;
|
|
end;
|
|
|
|
procedure ProcessMasterItems;
|
|
var
|
|
AGridView: TcxCustomGridView;
|
|
AGridRecordIndex: Integer;
|
|
begin
|
|
AGridView := GridView;
|
|
while AGridView.IsDetail do
|
|
begin
|
|
AGridRecordIndex := AGridView.MasterGridRecordIndex;
|
|
AGridView := AGridView.MasterGridView;
|
|
if (AGridRecordIndex <> -1) and (AGridView.ViewInfoCache <> nil) then
|
|
AGridView.ViewInfoCache[AGridRecordIndex].UnassignValues(False);
|
|
end;
|
|
end;
|
|
|
|
begin
|
|
if FUnassigningValues then Exit;
|
|
FUnassigningValues := True;
|
|
try
|
|
ProcessItems;
|
|
if not AKeepMaster then ProcessMasterItems;
|
|
finally
|
|
FUnassigningValues := False;
|
|
end;
|
|
end;
|
|
|
|
{ TcxCustomGridOptions }
|
|
|
|
constructor TcxCustomGridOptions.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited Create(nil);
|
|
FGridView := AGridView;
|
|
if GridView <> nil then GridView.AddOptions(Self);
|
|
end;
|
|
|
|
destructor TcxCustomGridOptions.Destroy;
|
|
begin
|
|
if GridView <> nil then GridView.RemoveOptions(Self);
|
|
inherited;
|
|
end;
|
|
|
|
function TcxCustomGridOptions.GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
|
|
begin
|
|
Result := GridView.LookAndFeelPainter;
|
|
end;
|
|
|
|
procedure TcxCustomGridOptions.Changed(AChangeKind: TcxGridViewChangeKind);
|
|
begin
|
|
GridView.Changed(AChangeKind);
|
|
end;
|
|
|
|
function TcxCustomGridOptions.GetGridViewValue: TcxCustomGridView;
|
|
begin
|
|
Result := FGridView;
|
|
end;
|
|
|
|
procedure TcxCustomGridOptions.Notification(AComponent: TComponent;
|
|
AOperation: TOperation);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridOptions.GetStoredProperties(AProperties: TStrings);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridOptions.GetStoredPropertyValue(const AName: string;
|
|
var AValue: Variant);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridOptions.SetStoredPropertyValue(const AName: string;
|
|
const AValue: Variant);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridOptions.Assign(Source: TPersistent);
|
|
begin
|
|
if not (Source is TcxCustomGridOptions) then
|
|
inherited;
|
|
end;
|
|
|
|
{ TcxCustomGridBackgroundBitmaps }
|
|
|
|
constructor TcxCustomGridBackgroundBitmaps.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited;
|
|
FItems := TList.Create;
|
|
end;
|
|
|
|
destructor TcxCustomGridBackgroundBitmaps.Destroy;
|
|
|
|
procedure ClearItems;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to Count - 1 do
|
|
if FItems[I] <> nil then TBitmap(FItems[I]).Free;
|
|
end;
|
|
|
|
begin
|
|
ClearItems;
|
|
FItems.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxCustomGridBackgroundBitmaps.GetCount: Integer;
|
|
begin
|
|
Result := FItems.Count;
|
|
end;
|
|
|
|
procedure TcxCustomGridBackgroundBitmaps.BitmapChanged(Sender: TObject);
|
|
begin
|
|
Changed(vcLayout);
|
|
end;
|
|
|
|
function TcxCustomGridBackgroundBitmaps.GetBitmapStyleIndex(Index: Integer): Integer;
|
|
begin
|
|
if Index = bbBackground then
|
|
Result := vsBackground
|
|
else
|
|
Result := -1;
|
|
end;
|
|
|
|
function TcxCustomGridBackgroundBitmaps.GetDefaultBitmap(Index: Integer): TBitmap;
|
|
var
|
|
AStyleIndex: Integer;
|
|
begin
|
|
AStyleIndex := GetBitmapStyleIndex(Index);
|
|
if AStyleIndex = -1 then
|
|
Result := nil
|
|
else
|
|
Result := GridView.Styles.GetBitmap(AStyleIndex);
|
|
end;
|
|
|
|
function TcxCustomGridBackgroundBitmaps.GetValue(Index: Integer): TBitmap;
|
|
begin
|
|
if Index >= Count then
|
|
FItems.Count := Index + 1;
|
|
if FItems[Index] = nil then
|
|
begin
|
|
FItems[Index] := TBitmap.Create;
|
|
TBitmap(FItems[Index]).OnChange := BitmapChanged;
|
|
end;
|
|
Result := TBitmap(FItems[Index]);
|
|
end;
|
|
|
|
procedure TcxCustomGridBackgroundBitmaps.SetValue(Index: Integer; Value: TBitmap);
|
|
begin
|
|
Values[Index].Assign(Value);
|
|
end;
|
|
|
|
procedure TcxCustomGridBackgroundBitmaps.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxCustomGridBackgroundBitmaps then
|
|
with TcxCustomGridBackgroundBitmaps(Source) do
|
|
Self.Background := Background;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxCustomGridBackgroundBitmaps.GetBitmap(Index: Integer): TBitmap;
|
|
begin
|
|
Result := Values[Index];
|
|
if Result.Empty then
|
|
Result := GetDefaultBitmap(Index);
|
|
end;
|
|
|
|
{ TcxCustomGridOptionsBehavior }
|
|
|
|
constructor TcxCustomGridOptionsBehavior.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited;
|
|
FPostponedSynchronization := True;
|
|
end;
|
|
|
|
function TcxCustomGridOptionsBehavior.GetPostponedSynchronization: Boolean;
|
|
begin
|
|
if GridView.PatternGridView = GridView then
|
|
Result := FPostponedSynchronization
|
|
else
|
|
Result := GridView.PatternGridView.OptionsBehavior.PostponedSynchronization;
|
|
end;
|
|
|
|
procedure TcxCustomGridOptionsBehavior.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxCustomGridOptionsBehavior then
|
|
PostponedSynchronization := TcxCustomGridOptionsBehavior(Source).PostponedSynchronization;
|
|
inherited;
|
|
end;
|
|
|
|
{ TcxCustomGridOptionsView }
|
|
|
|
function TcxCustomGridOptionsView.GetScrollBars: TScrollStyle;
|
|
begin
|
|
Result := GridView.Site.ScrollBars;
|
|
end;
|
|
|
|
procedure TcxCustomGridOptionsView.SetScrollBars(Value: TScrollStyle);
|
|
begin
|
|
if ScrollBars <> Value then
|
|
begin
|
|
GridView.Site.ScrollBars := Value;
|
|
Changed(vcLayout);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridOptionsView.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxCustomGridOptionsView then
|
|
with TcxCustomGridOptionsView(Source) do
|
|
Self.ScrollBars := ScrollBars;
|
|
inherited;
|
|
end;
|
|
|
|
{ TcxCustomGridStyles }
|
|
|
|
function TcxCustomGridStyles.GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
|
|
begin
|
|
Result := GridView.LookAndFeelPainter;
|
|
end;
|
|
|
|
procedure TcxCustomGridStyles.Changed(AIndex: Integer);
|
|
begin
|
|
inherited;
|
|
if GridView <> nil then
|
|
begin
|
|
GridView.UpdateFakeLinks;
|
|
GridView.Changed(vcSize);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridStyles.GetDefaultViewParams(Index: Integer; AData: TObject;
|
|
out AParams: TcxViewParams);
|
|
var
|
|
AGrid: TcxCustomGrid;
|
|
begin
|
|
inherited;
|
|
AGrid := TcxCustomGrid(GridView.Control);
|
|
if AGrid = nil then
|
|
AParams.Font := GridView.Painter.Canvas.Font
|
|
else
|
|
AParams.Font := AGrid.Font;
|
|
end;
|
|
|
|
procedure TcxCustomGridStyles.GetFakeComponentLinks(AList: TList);
|
|
var
|
|
I: Integer;
|
|
AOwner: TComponent;
|
|
begin
|
|
for I := 0 to Count - 1 do
|
|
begin
|
|
AOwner := Items[I].Item.Owner;
|
|
if (AOwner <> GridView.Owner) and (AList.IndexOf(AOwner) = -1) then
|
|
AList.Add(AOwner);
|
|
end;
|
|
end;
|
|
|
|
{ TcxCustomGridViewStyles }
|
|
|
|
procedure TcxCustomGridViewStyles.GetDefaultViewParams(Index: Integer; AData: TObject;
|
|
out AParams: TcxViewParams);
|
|
begin
|
|
inherited;
|
|
with AParams, LookAndFeelPainter do
|
|
case Index of
|
|
vsBackground:
|
|
begin
|
|
Color := DefaultContentColor;
|
|
TextColor := clGrayText;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridViewStyles.GetGridView: TcxCustomGridView;
|
|
begin
|
|
if GetOwner is TcxCustomGridView then
|
|
Result := TcxCustomGridView(GetOwner)
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewStyles.Assign(Source: TPersistent);
|
|
begin
|
|
inherited;
|
|
if Source is TcxCustomGridViewStyles then
|
|
with TcxCustomGridViewStyles(Source) do
|
|
Self.Background := Background;
|
|
end;
|
|
|
|
{ TcxGridListenerLink }
|
|
|
|
constructor TcxGridListenerLink.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited Create;
|
|
FGridView := AGridView;
|
|
end;
|
|
|
|
destructor TcxGridListenerLink.Destroy;
|
|
begin
|
|
if FGridView <> nil then
|
|
FGridView.RemoveListenerLink(Self);
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TcxGridListenerLink.Clear;
|
|
begin
|
|
FGridView := nil;
|
|
end;
|
|
|
|
{ TcxCustomGridView }
|
|
|
|
constructor TcxCustomGridView.CreateCloned(AControl: TcxControl);
|
|
begin
|
|
CreateEx(AControl);
|
|
{$IFDEF DELPHI6}
|
|
FComponentStyle := FComponentStyle + [csTransient];
|
|
{$ENDIF}
|
|
end;
|
|
|
|
destructor TcxCustomGridView.Destroy;
|
|
begin
|
|
Focused := False;
|
|
if not IsPattern and (PatternGridView <> nil) then
|
|
PatternGridView.RemoveClone(Self);
|
|
if (FLevel <> nil) and (TcxGridLevel(FLevel).GridView = Self) then
|
|
TcxGridLevel(FLevel).GridView := nil;
|
|
if FRepository <> nil then
|
|
TcxGridViewRepositoryAccess(FRepository).RemoveItem(Self); {5}
|
|
DestroyHandlers;
|
|
DestroyOptions;
|
|
FClones.Free;
|
|
ClearListenerLinks;
|
|
FListenerLinks.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetClone(Index: Integer): TcxCustomGridView;
|
|
begin
|
|
Result := TcxCustomGridView(FClones[Index]);
|
|
end;
|
|
|
|
function TcxCustomGridView.GetCloneCount: Integer;
|
|
begin
|
|
Result := FClones.Count;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetDragMode: TDragMode;
|
|
begin
|
|
Result := Site.DragMode;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetFocused: Boolean;
|
|
begin
|
|
Result := (Control <> nil){5} and (TcxCustomGrid(Control).FocusedView = Self);
|
|
end;
|
|
|
|
function TcxCustomGridView.GetIsControlFocusedValue: Boolean;
|
|
var
|
|
AForm: TCustomForm;
|
|
begin
|
|
Result := not IsDesigning and (Control <> nil);
|
|
if Result then
|
|
begin
|
|
AForm := GetParentForm(Control);
|
|
if (AForm <> nil) and (TCustomFormAccess(AForm).FormStyle = fsMDIForm) then
|
|
Result := Control.IsFocused
|
|
else
|
|
Result := GetIsControlFocused;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetIsDetail: Boolean;
|
|
begin
|
|
Result := (DataController <> nil) and DataController.IsDetailMode;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetIsMaster: Boolean;
|
|
begin
|
|
Result := (FLevel <> nil) and TcxGridLevel(FLevel).IsMaster;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetIsPattern: Boolean;
|
|
begin
|
|
Result := {(Level = nil) or }DataController.IsPattern;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetIsStoringNameMode: Boolean;
|
|
begin
|
|
Result := FStoringName <> '';
|
|
end;
|
|
|
|
function TcxCustomGridView.GetIsUpdating: Boolean;
|
|
begin
|
|
Result := csUpdating in ComponentState;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetLookAndFeel: TcxLookAndFeel;
|
|
begin
|
|
if Control = nil then
|
|
Result := nil
|
|
else
|
|
Result := TcxCustomGrid(Control).LookAndFeel;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
|
|
begin
|
|
if Control = nil then
|
|
Result := TcxStandardLookAndFeelPainter
|
|
else
|
|
Result := TcxCustomGrid(Control).LookAndFeelPainter;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetMasterGridView: TcxCustomGridView;
|
|
begin
|
|
if IsDetail then
|
|
Result := (DataController.GetMasterDataController as IcxCustomGridDataController).GridView
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetMasterGridRecordIndex: Integer;
|
|
begin
|
|
if MasterRecordIndex <> -1 then
|
|
Result := MasterGridView.DataController.GetRowIndexByRecordIndex(MasterRecordIndex, False)
|
|
else
|
|
Result := -1;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetMasterRecordIndex: Integer;
|
|
begin
|
|
Result := DataController.GetMasterRecordIndex;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOnDblClick: TNotifyEvent;
|
|
begin
|
|
Result := Site.OnDblClick;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOnDragDrop: TDragDropEvent;
|
|
begin
|
|
Result := Site.OnDragDrop;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOnDragOver: TDragOverEvent;
|
|
begin
|
|
Result := Site.OnDragOver;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOnEndDrag: TEndDragEvent;
|
|
begin
|
|
Result := Site.OnEndDrag;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOnKeyDown: TKeyEvent;
|
|
begin
|
|
Result := Site.OnKeyDown;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOnKeyPress: TKeyPressEvent;
|
|
begin
|
|
Result := Site.OnKeyPress;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOnKeyUp: TKeyEvent;
|
|
begin
|
|
Result := Site.OnKeyUp;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOnMouseDown: TMouseEvent;
|
|
begin
|
|
Result := Site.OnMouseDown;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOnMouseEnter: TNotifyEvent;
|
|
begin
|
|
Result := Site.OnMouseEnter;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOnMouseLeave: TNotifyEvent;
|
|
begin
|
|
Result := Site.OnMouseLeave;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOnMouseMove: TMouseMoveEvent;
|
|
begin
|
|
Result := Site.OnMouseMove;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOnMouseUp: TMouseEvent;
|
|
begin
|
|
Result := Site.OnMouseUp;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOnMouseWheel: TMouseWheelEvent;
|
|
begin
|
|
Result := Site.OnMouseWheel;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOnMouseWheelDown: TMouseWheelUpDownEvent;
|
|
begin
|
|
Result := Site.OnMouseWheelDown;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOnMouseWheelUp: TMouseWheelUpDownEvent;
|
|
begin
|
|
Result := Site.OnMouseWheelUp;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOnStartDrag: TStartDragEvent;
|
|
begin
|
|
Result := Site.OnStartDrag;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetPatternGridView: TcxCustomGridView;
|
|
begin
|
|
Result := FPatternGridView;
|
|
if Result = nil then Result := Self;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetPopupMenu: TComponent;
|
|
begin
|
|
Result := Site.PopupMenu;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetSite: TcxGridSite;
|
|
begin
|
|
if FViewInfo = nil then
|
|
Result := nil
|
|
else
|
|
Result := FViewInfo.Site;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetSynchronization: Boolean;
|
|
begin
|
|
if PatternGridView = Self then
|
|
Result := FSynchronization
|
|
else
|
|
Result := PatternGridView.Synchronization;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetBackgroundBitmaps(Value: TcxCustomGridBackgroundBitmaps);
|
|
begin
|
|
FBackgroundBitmaps.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetDragMode(Value: TDragMode);
|
|
begin
|
|
if DragMode <> Value then
|
|
begin
|
|
Site.DragMode := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetFocused(Value: Boolean);
|
|
begin
|
|
if Focused <> Value then
|
|
with TcxCustomGrid(Control) do
|
|
if Value then
|
|
FocusedView := Self
|
|
else
|
|
FocusedView := nil;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetIsRestoring(Value: Boolean);
|
|
begin
|
|
if FIsRestoring <> Value then
|
|
begin
|
|
FIsRestoring := Value;
|
|
if FIsRestoring then
|
|
BeforeRestoring
|
|
else
|
|
AfterRestoring;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetSynchronization(Value: Boolean);
|
|
begin
|
|
if not IsPattern then Exit;
|
|
if FSynchronization <> Value then
|
|
begin
|
|
FSynchronization := Value;
|
|
if Value then
|
|
Synchronize
|
|
else
|
|
FSynchronizationNeeded := False;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnCustomization(Value: TNotifyEvent);
|
|
begin
|
|
if @FOnCustomization <> @Value then
|
|
begin
|
|
FOnCustomization := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnDblClick(Value: TNotifyEvent);
|
|
begin
|
|
if @OnDblClick <> @Value then
|
|
begin
|
|
Site.OnDblClick := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnDragDrop(Value: TDragDropEvent);
|
|
begin
|
|
if @OnDragDrop <> @Value then
|
|
begin
|
|
Site.OnDragDrop := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnDragOver(Value: TDragOverEvent);
|
|
begin
|
|
if @OnDragOver <> @Value then
|
|
begin
|
|
Site.OnDragOver := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnEndDrag(Value: TEndDragEvent);
|
|
begin
|
|
if @OnEndDrag <> @Value then
|
|
begin
|
|
Site.OnEndDrag := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnGetStoredProperties(Value: TcxGridViewGetStoredPropertiesEvent);
|
|
begin
|
|
if @FOnGetStoredProperties <> @Value then
|
|
begin
|
|
FOnGetStoredProperties := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnGetStoredPropertyValue(Value: TcxGridViewGetStoredPropertyValueEvent);
|
|
begin
|
|
if @FOnGetStoredPropertyValue <> @Value then
|
|
begin
|
|
FOnGetStoredPropertyValue := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnInitStoredObject(Value: TcxGridInitStoredObjectEvent);
|
|
begin
|
|
if @FOnInitStoredObject <> @Value then
|
|
begin
|
|
FOnInitStoredObject := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnKeyDown(Value: TKeyEvent);
|
|
begin
|
|
if @OnKeyDown <> @Value then
|
|
begin
|
|
Site.OnKeyDown := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnKeyPress(Value: TKeyPressEvent);
|
|
begin
|
|
if @OnKeyPress <> @Value then
|
|
begin
|
|
Site.OnKeyPress := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnKeyUp(Value: TKeyEvent);
|
|
begin
|
|
if @OnKeyUp <> @Value then
|
|
begin
|
|
Site.OnKeyUp := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnMouseDown(Value: TMouseEvent);
|
|
begin
|
|
if @OnMouseDown <> @Value then
|
|
begin
|
|
Site.OnMouseDown := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnMouseEnter(Value: TNotifyEvent);
|
|
begin
|
|
if @OnMouseEnter <> @Value then
|
|
begin
|
|
Site.OnMouseEnter := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnMouseLeave(Value: TNotifyEvent);
|
|
begin
|
|
if @OnMouseLeave <> @Value then
|
|
begin
|
|
Site.OnMouseLeave := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnMouseMove(Value: TMouseMoveEvent);
|
|
begin
|
|
if @OnMouseMove <> @Value then
|
|
begin
|
|
Site.OnMouseMove := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnMouseUp(Value: TMouseEvent);
|
|
begin
|
|
if @OnMouseUp <> @Value then
|
|
begin
|
|
Site.OnMouseUp := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnMouseWheel(Value: TMouseWheelEvent);
|
|
begin
|
|
if @OnMouseWheel <> @Value then
|
|
begin
|
|
Site.OnMouseWheel := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnMouseWheelDown(Value: TMouseWheelUpDownEvent);
|
|
begin
|
|
if @OnMouseWheelDown <> @Value then
|
|
begin
|
|
Site.OnMouseWheelDown := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnMouseWheelUp(Value: TMouseWheelUpDownEvent);
|
|
begin
|
|
if @OnMouseWheelUp <> @Value then
|
|
begin
|
|
Site.OnMouseWheelUp := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnSetStoredPropertyValue(Value: TcxGridViewSetStoredPropertyValueEvent);
|
|
begin
|
|
if @FOnSetStoredPropertyValue <> @Value then
|
|
begin
|
|
FOnSetStoredPropertyValue := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnStartDrag(Value: TStartDragEvent);
|
|
begin
|
|
if @OnStartDrag <> @Value then
|
|
begin
|
|
Site.OnStartDrag := Value;
|
|
Changed(vcProperty);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOptionsBehavior(Value: TcxCustomGridOptionsBehavior);
|
|
begin
|
|
FOptionsBehavior.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOptionsData(Value: TcxCustomGridOptionsData);
|
|
begin
|
|
FOptionsData.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOptionsSelection(Value: TcxCustomGridOptionsSelection);
|
|
begin
|
|
FOptionsSelection.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOptionsView(Value: TcxCustomGridOptionsView);
|
|
begin
|
|
FOptionsView.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetPopupMenu(Value: TComponent);
|
|
begin
|
|
if PopupMenu <> Value then
|
|
begin
|
|
Site.PopupMenu := Value;
|
|
Changed(vcProperty)
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetStyles(Value: TcxCustomGridStyles);
|
|
begin
|
|
FStyles.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.ClearListenerLinks;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := FListenerLinks.Count - 1 downto 0 do
|
|
RemoveListenerLink(TcxGridListenerLink(FListenerLinks[I]));
|
|
end;
|
|
|
|
function TcxCustomGridView.GetObjectName: string;
|
|
begin
|
|
if IsStoringNameMode then
|
|
Result := FStoringName
|
|
else
|
|
Result := Name;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetProperties(AProperties: TStrings): Boolean;
|
|
begin
|
|
AProperties.Add('Version');
|
|
if Assigned(FOnGetStoredProperties) then
|
|
FOnGetStoredProperties(Self, AProperties);
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.GetPropertyValue(const AName: string; var AValue: Variant);
|
|
begin
|
|
if AName = 'Version' then
|
|
AValue := StoringVersion;
|
|
if Assigned(FOnGetStoredPropertyValue) then
|
|
FOnGetStoredPropertyValue(Self, AName, AValue);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetPropertyValue(const AName: string; const AValue: Variant);
|
|
begin
|
|
if AName = 'Version' then
|
|
FStoredVersion := AValue;
|
|
if Assigned(FOnSetStoredPropertyValue) then
|
|
FOnSetStoredPropertyValue(Self, AName, AValue);
|
|
end;
|
|
|
|
function TcxCustomGridView.CreateChild(const AObjectName, AClassName: string): TObject;
|
|
begin
|
|
Result := CreateStoredObject(AObjectName, AClassName);
|
|
if not IsStoringNameMode and (Result is TComponent) then
|
|
TComponent(Result).Name := AObjectName;
|
|
DoInitStoredObject(Result);
|
|
end;
|
|
|
|
function TcxCustomGridView.CreateStoredObject(const AObjectName, AClassName: string): TObject;
|
|
begin
|
|
Result := nil;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.DeleteChild(const AObjectName: string; AObject: TObject);
|
|
begin
|
|
AObject.Free;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.GetStoredChildren(AChildren: TStringList);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridView.AssignLayout(ALayoutView: TcxCustomGridView);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridView.BeforeEditLayout(ALayoutView: TcxCustomGridView);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridView.DoAssignLayout(ALayoutView: TcxCustomGridView);
|
|
begin
|
|
BeginUpdate;
|
|
try
|
|
AssignLayout(ALayoutView);
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetLayoutCustomizationFormButtonCaption: string;
|
|
begin
|
|
Result := '';
|
|
end;
|
|
|
|
function TcxCustomGridView.HasLayoutCustomizationForm: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxCustomGridView.IsLayoutChangeable: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.RunLayoutCustomizationForm;
|
|
begin
|
|
Controller.Customization := True;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.GetFakeComponentLinks(AList: TList);
|
|
begin
|
|
inherited;
|
|
(FDataController as IcxCustomGridDataController).GetFakeComponentLinks(AList);
|
|
FStyles.GetFakeComponentLinks(AList);
|
|
end;
|
|
|
|
function TcxCustomGridView.GetIsDestroying: Boolean;
|
|
begin
|
|
Result := inherited GetIsDestroying or
|
|
IsDetail and MasterGridView.IsDestroying;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.Loaded;
|
|
begin
|
|
inherited;
|
|
LoadingComplete;
|
|
DataController.Loaded;
|
|
Init;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.Notification(AComponent: TComponent;
|
|
Operation: TOperation);
|
|
begin
|
|
inherited;
|
|
NotifyOptions(AComponent, Operation);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetControl(Value: TcxControl);
|
|
begin
|
|
if Control <> Value then
|
|
begin
|
|
if Control <> nil then
|
|
begin
|
|
TcxCustomGrid(Control).RemoveFontListener(FStyles); {5}
|
|
if Control.IsDesigning and (Site <> nil) then
|
|
Control.RemoveComponent(Site);
|
|
end;
|
|
inherited;
|
|
if Control <> nil then
|
|
begin
|
|
if (FStorageControl = nil) and (FRepository = nil) then
|
|
FStorageControl := Value;
|
|
if Control.IsDesigning then
|
|
Control.InsertComponent(Site);
|
|
TcxCustomGrid(Control).AddFontListener(FStyles);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetName(const NewName: TComponentName);
|
|
begin
|
|
inherited;
|
|
NotifyControl(vcnName);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.Updated;
|
|
begin
|
|
inherited;
|
|
EndUpdate;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.Updating;
|
|
begin
|
|
BeginUpdate;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.CreateHandlers;
|
|
begin
|
|
FController := GetControllerClass.Create(Self);
|
|
FDataController := GetDataControllerClass.Create(Self);
|
|
InitDataController;
|
|
FPainter := GetPainterClass.Create(Self);
|
|
FViewData := GetViewDataClass.Create(Self);
|
|
FViewInfo := CreateViewInfo;
|
|
if GetViewInfoCacheClass <> nil then
|
|
FViewInfoCache := GetViewInfoCacheClass.Create(Self);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.DestroyHandlers;
|
|
begin
|
|
FDataController.Free;
|
|
FDataController := nil;
|
|
// FreeAndNil(FViewInfoCache);
|
|
if (Control <> nil) and Control.IsDesigning then
|
|
Control.RemoveComponent(Site);
|
|
FViewInfo.Free;
|
|
FViewInfo := nil;
|
|
FreeAndNil(FViewInfoCache);
|
|
FreeAndNil(FViewData);
|
|
FreeAndNil(FPainter);
|
|
FreeAndNil(FController);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.InitDataController;
|
|
begin
|
|
FDataController.OnUpdateControl := UpdateControl;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.CreateOptions;
|
|
begin
|
|
FOptionsList := TList.Create;
|
|
FBackgroundBitmaps := GetBackgroundBitmapsClass.Create(Self);
|
|
FOptionsBehavior := GetOptionsBehaviorClass.Create(Self);
|
|
FOptionsData := GetOptionsDataClass.Create(Self);
|
|
FOptionsSelection := GetOptionsSelectionClass.Create(Self);
|
|
FOptionsView := GetOptionsViewClass.Create(Self);
|
|
FStyles := GetStylesClass.Create(Self);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.DestroyOptions;
|
|
begin
|
|
if Control <> nil then {5}
|
|
TcxCustomGrid(Control).RemoveFontListener(FStyles);
|
|
FreeAndNil(FStyles);
|
|
FreeAndNil(FOptionsView);
|
|
FreeAndNil(FOptionsSelection);
|
|
FreeAndNil(FOptionsData);
|
|
FreeAndNil(FOptionsBehavior);
|
|
FreeAndNil(FBackgroundBitmaps);
|
|
FreeAndNil(FOptionsList);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.AddOptions(AOptions: TcxCustomGridOptions);
|
|
begin
|
|
FOptionsList.Add(AOptions);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.RemoveOptions(AOptions: TcxCustomGridOptions);
|
|
begin
|
|
FOptionsList.Remove(AOptions);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.NotifyOptions(AComponent: TComponent;
|
|
AOperation: TOperation);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
if FOptionsList = nil then Exit;
|
|
for I := 0 to FOptionsList.Count - 1 do
|
|
TcxCustomGridOptions(FOptionsList[I]).Notification(AComponent, AOperation);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.AddClone(AClone: TcxCustomGridView);
|
|
begin
|
|
FClones.Add(AClone);
|
|
AClone.FPatternGridView := Self;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.RemoveClone(AClone: TcxCustomGridView);
|
|
begin
|
|
FClones.Remove(AClone);
|
|
AClone.FPatternGridView := nil;
|
|
end;
|
|
|
|
function TcxCustomGridView.AddListenerLink: TcxGridListenerLink;
|
|
begin
|
|
Result := TcxGridListenerLink.Create(Self);
|
|
FListenerLinks.Add(Result);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.RemoveListenerLink(ALink: TcxGridListenerLink);
|
|
begin
|
|
ALink.Clear;
|
|
FListenerLinks.Remove(ALink);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.Synchronize(ACheckUpdateLock: Boolean = True);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
if IsLoading or IsDestroying or (Control = nil) or
|
|
not IsSynchronization or FAssigningPattern or FSynchronizationAssignNeeded then
|
|
Exit;
|
|
if ACheckUpdateLock and IsUpdateLocked then
|
|
begin
|
|
FSynchronizationNeeded := True;
|
|
Exit;
|
|
end;
|
|
FIsSynchronizing := True;
|
|
try
|
|
if IsPattern then
|
|
begin
|
|
BeginUpdate;
|
|
try
|
|
for I := 0 to CloneCount - 1 do
|
|
Clones[I].Synchronize(Self);
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
end
|
|
else
|
|
PatternGridView.Synchronize(Self);
|
|
finally
|
|
FIsSynchronizing := False;
|
|
FSynchronizationNeeded := False;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.Synchronize(AView: TcxCustomGridView);
|
|
begin
|
|
if not IsSynchronization or FIsSynchronizing or FAssigningPattern then Exit;
|
|
if OptionsBehavior.PostponedSynchronization and not IsPattern and not Visible then
|
|
begin
|
|
FSynchronizationAssignNeeded := True;
|
|
Exit;
|
|
end;
|
|
BeginUpdate;
|
|
try
|
|
AssignPattern(AView);
|
|
if IsPattern then Synchronize;
|
|
finally
|
|
EndUpdate;
|
|
FSynchronizationAssignNeeded := False;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.AssignPattern(APattern: TcxCustomGridView);
|
|
begin
|
|
FAssigningPattern := True;
|
|
try
|
|
Assign(APattern);
|
|
finally
|
|
FAssigningPattern := False;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.BeforeAssign(ASource: TcxCustomGridView);
|
|
begin
|
|
if not AssigningSettings then
|
|
DataController.Assign(ASource.DataController);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.DoAssign(ASource: TcxCustomGridView);
|
|
begin
|
|
with ASource do
|
|
begin
|
|
Self.BackgroundBitmaps := BackgroundBitmaps;
|
|
Self.DragMode := DragMode;
|
|
Self.OptionsBehavior := OptionsBehavior;
|
|
Self.OptionsData := OptionsData;
|
|
Self.OptionsSelection := OptionsSelection;
|
|
Self.OptionsView := OptionsView;
|
|
Self.PopupMenu := PopupMenu;
|
|
Self.Styles := Styles;
|
|
Self.Synchronization := Synchronization;
|
|
Self.OnCustomization := OnCustomization;
|
|
Self.OnDblClick := OnDblClick;
|
|
Self.OnDragDrop := OnDragDrop;
|
|
Self.OnDragOver := OnDragOver;
|
|
Self.OnEndDrag := OnEndDrag;
|
|
Self.OnGetStoredProperties := OnGetStoredProperties;
|
|
Self.OnGetStoredPropertyValue := OnGetStoredPropertyValue;
|
|
Self.OnInitStoredObject := OnInitStoredObject;
|
|
Self.OnKeyDown := OnKeyDown;
|
|
Self.OnKeyPress := OnKeyPress;
|
|
Self.OnKeyUp := OnKeyUp;
|
|
Self.OnMouseDown := OnMouseDown;
|
|
Self.OnMouseEnter := OnMouseEnter;
|
|
Self.OnMouseLeave := OnMouseLeave;
|
|
Self.OnMouseMove := OnMouseMove;
|
|
Self.OnMouseUp := OnMouseUp;
|
|
Self.OnMouseWheel := OnMouseWheel;
|
|
Self.OnMouseWheelDown := OnMouseWheelDown;
|
|
Self.OnMouseWheelUp := OnMouseWheelUp;
|
|
Self.OnSetStoredPropertyValue := OnSetStoredPropertyValue;
|
|
Self.OnStartDrag := OnStartDrag;
|
|
Self.Init;
|
|
end
|
|
end;
|
|
|
|
procedure TcxCustomGridView.DoAssignSettings(ASource: TcxCustomGridView);
|
|
begin
|
|
Assign(ASource);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.AfterAssign(ASource: TcxCustomGridView);
|
|
begin
|
|
if not AssigningSettings then
|
|
DataController.Assign(ASource.DataController);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.BeforeRestoring;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridView.AfterRestoring;
|
|
begin
|
|
RestoringComplete;
|
|
end;
|
|
|
|
{procedure TcxCustomGridView.BeforeLevelChange;
|
|
begin
|
|
end;}
|
|
|
|
function TcxCustomGridView.CanTabStop: Boolean;
|
|
begin
|
|
Result := TcxCustomGrid(Control).TabStop;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.DetailDataChanged(ADetail: TcxCustomGridView);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridView.DetailVisibleChanged(ADetailLevel: TComponent;
|
|
APrevVisibleDetailCount, AVisibleDetailCount: Integer);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridView.DoChanged(AChangeKind: TcxGridViewChangeKind);
|
|
begin
|
|
if Controller <> nil then Controller.GridViewChanged;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetChangeable: Boolean;
|
|
begin
|
|
Result := (Visible or IsPattern) and (Control <> nil);
|
|
end;
|
|
|
|
function TcxCustomGridView.GetCustomVisible(ALevelVisible: Boolean): Boolean;
|
|
begin
|
|
Result := ALevelVisible and not IsPattern and
|
|
(not IsDetail or MasterGridView.Visible and MasterGridView.IsDetailVisible(Self));
|
|
end;
|
|
|
|
function TcxCustomGridView.GetIsControlFocused: Boolean;
|
|
begin
|
|
Result := Control.IsFocused;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetResizeOnBoundsChange: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetVisible: Boolean;
|
|
begin
|
|
Result := not IsDestroying and
|
|
GetCustomVisible((FLevel <> nil) and TcxGridLevel(FLevel).ActuallyVisible);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.Init;
|
|
begin
|
|
end;
|
|
|
|
function TcxCustomGridView.IsDetailVisible(AGridView: TcxCustomGridView): Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.LoadingComplete;
|
|
begin
|
|
SizeChanged;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.NotifyControl(AChangeKind: TcxGridViewChangeNotificationKind);
|
|
begin
|
|
if Control <> nil then
|
|
TcxCustomGridAccess(Control).ViewChanged(Self, AChangeKind);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.RestoringComplete;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetLevel(Value: TComponent);
|
|
begin
|
|
if FLevel <> Value then
|
|
begin
|
|
//BeforeLevelChange;
|
|
if FLevel <> nil then
|
|
Controller.VisibilityChanged(False);
|
|
FLevel := Value;
|
|
Site.InitTabStop(Site.Parent);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetTabStop(Value: Boolean);
|
|
begin
|
|
Site.TabStop := Value and CanTabStop;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.UpdateControl(AInfo: TcxUpdateControlInfo);
|
|
begin
|
|
if not (IsLoading or IsDestroying or IsPattern) and (AInfo is TcxDataChangedInfo) then
|
|
if IsDetail then
|
|
if (MasterGridView <> nil) and not MasterGridView.IsUpdateLocked and
|
|
(MasterGridView.DataController.LockCount = 0) and
|
|
(PatternGridView <> nil) and PatternGridView.HasAsClone(Self) then
|
|
MasterGridView.DetailDataChanged(Self)
|
|
else
|
|
else
|
|
if Control <> nil then // ext lookup editor
|
|
TcxCustomGrid(Control).RootViewDataChanged(Self);
|
|
end;
|
|
|
|
function TcxCustomGridView.GetViewInfoCacheClass: TcxCustomGridViewInfoCacheClass;
|
|
begin
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetBackgroundBitmapsClass: TcxCustomGridBackgroundBitmapsClass;
|
|
begin
|
|
Result := TcxCustomGridBackgroundBitmaps;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOptionsBehaviorClass: TcxCustomGridOptionsBehaviorClass;
|
|
begin
|
|
Result := TcxCustomGridOptionsBehavior;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOptionsDataClass: TcxCustomGridOptionsDataClass;
|
|
begin
|
|
Result := TcxCustomGridOptionsData;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOptionsSelectionClass: TcxCustomGridOptionsSelectionClass;
|
|
begin
|
|
Result := TcxCustomGridOptionsSelection;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetOptionsViewClass: TcxCustomGridOptionsViewClass;
|
|
begin
|
|
Result := TcxCustomGridOptionsView;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetStylesClass: TcxCustomGridViewStylesClass;
|
|
begin
|
|
Result := TcxCustomGridViewStyles;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.Initialize;
|
|
begin
|
|
inherited Initialize;
|
|
FListenerLinks := TList.Create;
|
|
FClones := TList.Create;
|
|
FSynchronization := True;
|
|
CreateOptions;
|
|
CreateHandlers;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.RefreshCustomizationForm;
|
|
begin
|
|
if Controller <> nil then
|
|
Controller.RefreshCustomizationForm;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.DoCustomization;
|
|
begin
|
|
if Assigned(FOnCustomization) then FOnCustomization(Self);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.DoInitStoredObject(AObject: TObject);
|
|
begin
|
|
if (AObject <> nil) and Assigned(FOnInitStoredObject) then
|
|
FOnInitStoredObject(Self, AObject);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TcxCustomGridView then
|
|
begin
|
|
BeginUpdate;
|
|
try
|
|
BeforeAssign(TcxCustomGridView(Source));
|
|
DoAssign(TcxCustomGridView(Source));
|
|
AfterAssign(TcxCustomGridView(Source));
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
end
|
|
else
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.AssignSettings(ASource: TcxCustomGridView);
|
|
begin
|
|
FAssigningSettings := True;
|
|
try
|
|
DoAssignSettings(ASource);
|
|
finally
|
|
FAssigningSettings := False;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridView.CanFocus: Boolean;
|
|
begin
|
|
Result := GetCustomVisible((FLevel <> nil) and TcxGridLevel(FLevel).CanBeVisible);
|
|
end;
|
|
|
|
function TcxCustomGridView.GetParentComponent: TComponent;
|
|
begin {5}
|
|
Result := FStorageControl;
|
|
if Result = nil then
|
|
Result := FRepository;
|
|
end;
|
|
|
|
function TcxCustomGridView.HasParent: Boolean;
|
|
begin {5}
|
|
Result := (FStorageControl <> nil) or (FRepository <> nil);
|
|
end;
|
|
|
|
function TcxCustomGridView.HasAsClone(AGridView: TcxCustomGridView): Boolean;
|
|
begin
|
|
Result := FClones.IndexOf(AGridView) <> -1;
|
|
end;
|
|
|
|
function TcxCustomGridView.HasAsMaster(AGridView: TcxCustomGridView): Boolean;
|
|
begin
|
|
Result := (MasterGridView = AGridView) or
|
|
(MasterGridView <> nil) and MasterGridView.HasAsMaster(AGridView);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.Invalidate(AHardUpdate: Boolean = False);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
if IsPattern then
|
|
for I := 0 to CloneCount - 1 do
|
|
Clones[I].Invalidate(AHardUpdate)
|
|
else
|
|
if AHardUpdate then
|
|
LayoutChanged
|
|
else
|
|
ViewChanged;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.RestoreDefaults;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetParentComponent(Value: TComponent);
|
|
begin {5}
|
|
inherited;
|
|
if Value is TcxGridViewRepository then
|
|
TcxGridViewRepositoryAccess(Value).AddItem(Self);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.CheckSynchronizationAssignNeeded;
|
|
begin
|
|
if FSynchronizationAssignNeeded then
|
|
begin
|
|
BeginUpdate;
|
|
try
|
|
Synchronize(PatternGridView);
|
|
finally
|
|
CancelUpdate;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridView.IsSynchronization: Boolean;
|
|
begin
|
|
Result := Synchronization or IsDesigning;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.BeginUpdate;
|
|
begin
|
|
if Control <> nil then
|
|
TcxCustomGrid(Control).BeginUpdate;
|
|
Inc(FUpdateLockCount);
|
|
if DataController <> nil then
|
|
DataController.BeginUpdate;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.CancelUpdate;
|
|
begin
|
|
try
|
|
if DataController <> nil then
|
|
DataController.EndUpdate;
|
|
if IsUpdateLocked then
|
|
begin
|
|
Dec(FUpdateLockCount);
|
|
if not IsUpdateLocked then
|
|
FSynchronizationNeeded := False;
|
|
end;
|
|
finally
|
|
if Control <> nil then {5}
|
|
TcxCustomGrid(Control).CancelUpdate;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridView.Changed(AGridChange: TObject): Boolean;
|
|
begin
|
|
Result := True;
|
|
if IsLoading or IsDestroying {or IsPattern} or
|
|
(FViewInfo = nil) or FViewInfo.IsCalculating then
|
|
begin
|
|
AGridChange.Free;
|
|
Result := False;
|
|
end
|
|
else
|
|
if Control = nil{5} then
|
|
try
|
|
with AGridChange as TcxCustomGridChange do {7}
|
|
begin
|
|
Control := nil;
|
|
Execute;
|
|
end
|
|
finally
|
|
AGridChange.Free;
|
|
end
|
|
else
|
|
TcxCustomGrid(Control).Changed(AGridChange as TcxCustomGridChange);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.EndUpdate;
|
|
begin
|
|
try
|
|
if DataController <> nil then
|
|
DataController.EndUpdate;
|
|
if IsUpdateLocked then
|
|
begin
|
|
if (FUpdateLockCount = 1) and FSynchronizationNeeded then
|
|
Synchronize(False);
|
|
Dec(FUpdateLockCount);
|
|
end;
|
|
finally
|
|
if Control <> nil then
|
|
TcxCustomGrid(Control).EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridView.IsUpdateLocked: Boolean;
|
|
begin
|
|
Result := FUpdateLockCount > 0;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
|
|
begin
|
|
Result := ViewInfo.GetHitTest(P);
|
|
end;
|
|
|
|
function TcxCustomGridView.GetHitTest(X, Y: Integer): TcxCustomGridHitTest;
|
|
begin
|
|
Result := ViewInfo.GetHitTest(X, Y);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.BoundsChanged(AUpdateSelfOnly: Boolean = False;
|
|
AKeepMaster: Boolean = False);
|
|
begin
|
|
if ResizeOnBoundsChange then
|
|
SizeChanged(AUpdateSelfOnly, AKeepMaster)
|
|
else
|
|
LayoutChanged(AUpdateSelfOnly);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.Changed(AChangeKind: TcxGridViewChangeKind);
|
|
begin
|
|
if (DataController <> nil) and DataController.IsDataLoading then Exit;
|
|
BeginUpdate;
|
|
try
|
|
case AChangeKind of
|
|
vcLayout:
|
|
LayoutChanged;
|
|
vcSize:
|
|
SizeChanged;
|
|
end;
|
|
Synchronize;
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
DoChanged(AChangeKind);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.FocusChanged(AFocused: Boolean);
|
|
begin
|
|
if AFocused then
|
|
begin
|
|
DataController.SetFocus;
|
|
Controller.DoSetFocus(True);
|
|
end
|
|
else
|
|
Controller.RemoveFocus;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.LayoutChanged(AUpdateSelfOnly: Boolean = True);
|
|
|
|
function GetParameter: TcxCustomGridView;
|
|
begin
|
|
if AUpdateSelfOnly then
|
|
Result := Self
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
begin
|
|
Changed(TcxGridLayoutChange.Create(GetParameter));
|
|
end;
|
|
|
|
procedure TcxCustomGridView.LookAndFeelChanged;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to CloneCount - 1 do
|
|
Clones[I].LookAndFeelChanged;
|
|
end;
|
|
|
|
function TcxCustomGridView.SizeChanged(AUpdateSelfOnly: Boolean = False;
|
|
AKeepMaster: Boolean = False): Boolean;
|
|
begin
|
|
Result := Changed(TcxGridSizeChange.Create(Self,
|
|
AUpdateSelfOnly or (Control = nil){7}, AKeepMaster));
|
|
end;
|
|
|
|
procedure TcxCustomGridView.ViewChanged;
|
|
begin
|
|
Changed(TcxGridViewChange.Create(Self));
|
|
end;
|
|
|
|
procedure TcxCustomGridView.ViewChanged(const AUpdateRect: TRect);
|
|
begin
|
|
if not IsRectEmpty(AUpdateRect) then
|
|
Changed(TcxGridViewChange.Create(Self, AUpdateRect));
|
|
end;
|
|
|
|
procedure TcxCustomGridView.ViewChanged(ARegion: TcxRegion);
|
|
begin
|
|
if (ARegion <> nil) and not ARegion.IsEmpty then
|
|
Changed(TcxGridViewChange.Create(Self, ARegion));
|
|
end;
|
|
|
|
procedure TcxCustomGridView.RestoreFromIniFile(const AStorageName: string;
|
|
AChildrenCreating, AChildrenDeleting: Boolean; AOptions: TcxGridStorageOptions;
|
|
const ARestoreViewName: string);
|
|
var
|
|
AStorage: TcxStorage;
|
|
AModes: TcxStorageModes;
|
|
begin
|
|
FStoringName := ARestoreViewName;
|
|
AStorage := TcxStorage.Create(AStorageName);
|
|
try
|
|
if not IsStoringNameMode then
|
|
AStorage.NamePrefix := Owner.Name;
|
|
FStorageOptions := AOptions;
|
|
AModes := [];
|
|
if AChildrenCreating then
|
|
Include(AModes, smChildrenCreating);
|
|
if AChildrenDeleting then
|
|
Include(AModes, smChildrenDeleting);
|
|
AStorage.Modes := AModes;
|
|
BeginUpdate;
|
|
try
|
|
IsRestoring := True;
|
|
try
|
|
AStorage.RestoreFromIni(Self);
|
|
finally
|
|
IsRestoring := False;
|
|
end;
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
finally
|
|
AStorage.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.RestoreFromRegistry(const AStorageName: string;
|
|
AChildrenCreating, AChildrenDeleting: Boolean; AOptions: TcxGridStorageOptions;
|
|
const ARestoreViewName: string);
|
|
var
|
|
AStorage: TcxStorage;
|
|
AModes: TcxStorageModes;
|
|
begin
|
|
FStoringName := ARestoreViewName;
|
|
AStorage := TcxStorage.Create(AStorageName);
|
|
try
|
|
if not IsStoringNameMode then
|
|
AStorage.NamePrefix := Owner.Name;
|
|
FStorageOptions := AOptions;
|
|
AModes := [];
|
|
if AChildrenCreating then
|
|
Include(AModes, smChildrenCreating);
|
|
if AChildrenDeleting then
|
|
Include(AModes, smChildrenDeleting);
|
|
AStorage.Modes := AModes;
|
|
BeginUpdate;
|
|
try
|
|
IsRestoring := True;
|
|
try
|
|
AStorage.RestoreFromRegistry(Self);
|
|
finally
|
|
IsRestoring := False;
|
|
end;
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
finally
|
|
AStorage.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.RestoreFromStream(AStream: TStream;
|
|
AChildrenCreating, AChildrenDeleting: Boolean; AOptions: TcxGridStorageOptions;
|
|
const ARestoreViewName: string);
|
|
var
|
|
AStorage: TcxStorage;
|
|
AModes: TcxStorageModes;
|
|
begin
|
|
FStoringName := ARestoreViewName;
|
|
AStorage := TcxStorage.Create(AStream);
|
|
try
|
|
if not IsStoringNameMode then
|
|
AStorage.NamePrefix := Owner.Name;
|
|
FStorageOptions := AOptions;
|
|
AModes := [];
|
|
if AChildrenCreating then
|
|
Include(AModes, smChildrenCreating);
|
|
if AChildrenDeleting then
|
|
Include(AModes, smChildrenDeleting);
|
|
AStorage.Modes := AModes;
|
|
BeginUpdate;
|
|
try
|
|
IsRestoring := True;
|
|
try
|
|
AStorage.RestoreFromStream(Self);
|
|
finally
|
|
IsRestoring := False;
|
|
end;
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
finally
|
|
AStorage.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.RestoreFromStorage(const AStorageName: string;
|
|
AReaderClass: TcxCustomReaderClass; AChildrenCreating, AChildrenDeleting: Boolean;
|
|
AOptions: TcxGridStorageOptions; const ARestoreViewName: string);
|
|
var
|
|
AStorage: TcxStorage;
|
|
AModes: TcxStorageModes;
|
|
begin
|
|
FStoringName := ARestoreViewName;
|
|
AStorage := TcxStorage.Create(AStorageName);
|
|
try
|
|
if not IsStoringNameMode then
|
|
AStorage.NamePrefix := Owner.Name;
|
|
FStorageOptions := AOptions;
|
|
AModes := [];
|
|
if AChildrenCreating then
|
|
Include(AModes, smChildrenCreating);
|
|
if AChildrenDeleting then
|
|
Include(AModes, smChildrenDeleting);
|
|
AStorage.Modes := AModes;
|
|
BeginUpdate;
|
|
try
|
|
IsRestoring := True;
|
|
try
|
|
AStorage.RestoreFrom(Self, AReaderClass);
|
|
finally
|
|
IsRestoring := False;
|
|
end;
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
finally
|
|
AStorage.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.StoreToIniFile(const AStorageName: string; AReCreate: Boolean;
|
|
AOptions: TcxGridStorageOptions; const ASaveViewName: string);
|
|
var
|
|
AStorage: TcxStorage;
|
|
begin
|
|
FStoringName := ASaveViewName;
|
|
AStorage := TcxStorage.Create(AStorageName);
|
|
try
|
|
FStorageOptions := AOptions;
|
|
if ASaveViewName = '' then
|
|
AStorage.NamePrefix := Owner.Name;
|
|
AStorage.ReCreate := AReCreate;
|
|
AStorage.StoreToIni(Self);
|
|
finally
|
|
AStorage.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.StoreToRegistry(const AStorageName: string; AReCreate: Boolean;
|
|
AOptions: TcxGridStorageOptions; const ASaveViewName: string);
|
|
var
|
|
AStorage: TcxStorage;
|
|
begin
|
|
FStoringName := ASaveViewName;
|
|
AStorage := TcxStorage.Create(AStorageName);
|
|
try
|
|
FStorageOptions := AOptions;
|
|
if ASaveViewName = '' then
|
|
AStorage.NamePrefix := Owner.Name;
|
|
AStorage.ReCreate := AReCreate;
|
|
AStorage.StoreToRegistry(Self);
|
|
finally
|
|
AStorage.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.StoreToStream(AStream: TStream; AOptions: TcxGridStorageOptions;
|
|
const ASaveViewName: string);
|
|
var
|
|
AStorage: TcxStorage;
|
|
begin
|
|
FStoringName := ASaveViewName;
|
|
AStorage := TcxStorage.Create(AStream);
|
|
try
|
|
FStorageOptions := AOptions;
|
|
if ASaveViewName = '' then
|
|
AStorage.NamePrefix := Owner.Name;
|
|
AStorage.StoreToStream(Self);
|
|
finally
|
|
AStorage.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.StoreToStorage(const AStorageName: string;
|
|
AWriterClass: TcxCustomWriterClass; AReCreate: Boolean;
|
|
AOptions: TcxGridStorageOptions; const ASaveViewName: string);
|
|
var
|
|
AStorage: TcxStorage;
|
|
begin
|
|
FStoringName := ASaveViewName;
|
|
AStorage := TcxStorage.Create(AStorageName);
|
|
try
|
|
FStorageOptions := AOptions;
|
|
if ASaveViewName = '' then
|
|
AStorage.NamePrefix := Owner.Name;
|
|
AStorage.ReCreate := AReCreate;
|
|
AStorage.StoreTo(Self, AWriterClass);
|
|
finally
|
|
AStorage.Free;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridView.CreateViewInfo: TcxCustomGridViewInfo;
|
|
begin
|
|
Result := GetViewInfoClass.Create(Self);
|
|
end;
|
|
|
|
{ functions }
|
|
|
|
function GetGridViewDataController(AView: TcxCustomGridView): TcxCustomDataController;
|
|
begin
|
|
Result := AView.FDataController;
|
|
end;
|
|
|
|
function GetParentGridView(AControl: TControl): TcxCustomGridView;
|
|
begin
|
|
while (AControl <> nil) and not (AControl is TcxGridSite) do
|
|
AControl := AControl.Parent;
|
|
if AControl = nil then
|
|
Result := nil
|
|
else
|
|
Result := TcxGridSite(AControl).GridView;
|
|
end;
|
|
|
|
procedure AddGridViewClone(AView, AClone: TcxCustomGridView);
|
|
begin
|
|
AView.AddClone(AClone);
|
|
end;
|
|
|
|
procedure AssignGridViewPattern(AView, APattern: TcxCustomGridView);
|
|
begin
|
|
AView.AssignPattern(APattern);
|
|
end;
|
|
|
|
procedure SetGridViewLevel(AView: TcxCustomGridView; Value: TComponent);
|
|
begin
|
|
AView.SetLevel(Value);
|
|
end;
|
|
|
|
procedure SiteFocusChanged(ASite: TcxGridSite);
|
|
begin
|
|
ASite.FocusChanged;
|
|
end;
|
|
|
|
{ TcxCustomGridViewAccess }
|
|
|
|
class procedure TcxCustomGridViewAccess.AddClone(AInstance: TcxCustomGridView;
|
|
AClone: TcxCustomGridView);
|
|
begin
|
|
AInstance.AddClone(AClone);
|
|
end;
|
|
|
|
class procedure TcxCustomGridViewAccess.AssignPattern(AInstance: TcxCustomGridView;
|
|
APattern: TcxCustomGridView);
|
|
begin
|
|
AInstance.AssignPattern(APattern);
|
|
end;
|
|
|
|
class function TcxCustomGridViewAccess.CanFocus(AInstance: TcxCustomGridView): Boolean;
|
|
begin
|
|
Result := AInstance.CanFocus;
|
|
end;
|
|
|
|
class procedure TcxCustomGridViewAccess.DetailVisibleChanged(AInstance: TcxCustomGridView;
|
|
ADetailLevel: TComponent; APrevVisibleDetailCount, AVisibleDetailCount: Integer);
|
|
begin
|
|
AInstance.DetailVisibleChanged(ADetailLevel, APrevVisibleDetailCount, AVisibleDetailCount);
|
|
end;
|
|
|
|
class procedure TcxCustomGridViewAccess.FocusChanged(AInstance: TcxCustomGridView;
|
|
AFocused: Boolean);
|
|
begin
|
|
AInstance.FocusChanged(AFocused);
|
|
end;
|
|
|
|
class procedure TcxCustomGridViewAccess.LookAndFeelChanged(AInstance: TcxCustomGridView);
|
|
begin
|
|
AInstance.LookAndFeelChanged;
|
|
end;
|
|
|
|
class procedure TcxCustomGridViewAccess.SetLevel(AInstance: TcxCustomGridView;
|
|
Value: TComponent);
|
|
begin
|
|
AInstance.SetLevel(Value);
|
|
end;
|
|
|
|
class function TcxCustomGridViewAccess.GetChangeable(AInstance: TcxCustomGridView): Boolean;
|
|
begin
|
|
Result := AInstance.Changeable;
|
|
end;
|
|
|
|
class function TcxCustomGridViewAccess.GetStyles(AInstance: TcxCustomGridView): TcxCustomGridStyles;
|
|
begin
|
|
Result := AInstance.Styles;
|
|
end;
|
|
|
|
{ TcxGridRegisteredViews }
|
|
|
|
type
|
|
TcxGridRegisteredViews = class(TcxRegisteredClasses)
|
|
protected
|
|
function CompareItems(AIndex1, AIndex2: Integer): Integer; override;
|
|
public
|
|
constructor Create;
|
|
end;
|
|
|
|
constructor TcxGridRegisteredViews.Create;
|
|
begin
|
|
inherited Create(True);
|
|
Sorted := True;
|
|
end;
|
|
|
|
function TcxGridRegisteredViews.CompareItems(AIndex1, AIndex2: Integer): Integer;
|
|
var
|
|
AIsDBView1, AIsDBView2: Boolean;
|
|
begin
|
|
AIsDBView1 := Pos('DB', Descriptions[AIndex1]) = 1;
|
|
AIsDBView2 := Pos('DB', Descriptions[AIndex2]) = 1;
|
|
if not AIsDBView1 and AIsDBView2 then
|
|
Result := -1
|
|
else
|
|
if AIsDBView1 and not AIsDBView2 then
|
|
Result := 1
|
|
else
|
|
Result := inherited CompareItems(AIndex1, AIndex2);
|
|
end;
|
|
|
|
initialization
|
|
GridHitTests := TGridHitTests.Create;
|
|
cxGridRegisteredViews := TcxGridRegisteredViews.Create;
|
|
|
|
finalization
|
|
FreeAndNil(cxGridRegisteredViews);
|
|
FreeAndNil(GridHitTests);
|
|
|
|
end.
|