david
960b25140d
git-svn-id: https://192.168.0.254/svn/Componentes.Terceros.DevExpressVCL@55 05c56307-c608-d34a-929d-697000501d7a
4729 lines
135 KiB
ObjectPascal
4729 lines
135 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 cxGridVer.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
Windows, Messages,
|
|
Classes, Graphics, Controls, Forms, StdCtrls, ExtCtrls,
|
|
cxClasses, cxControls, cxGraphics, cxLookAndFeelPainters, cxStyles, cxStorage,
|
|
cxGridCommon,
|
|
cxCustomData, cxData;
|
|
|
|
const
|
|
htError = -1;
|
|
htNone = 0;
|
|
|
|
bbCustomFirst = 0;
|
|
bbBackground = bbCustomFirst;
|
|
bbCustomLast = bbBackground;
|
|
|
|
vsCustomFirst = 0;
|
|
vsBackground = vsCustomFirst;
|
|
vsCustomLast = vsBackground;
|
|
|
|
CM_BOUNDSCHANGED = WM_DX + 25;
|
|
|
|
type
|
|
TcxCustomGridDragAndDropObjectClass = class of TcxCustomGridDragAndDropObject;
|
|
TcxCustomGridController = class;
|
|
TcxCustomGridPainter = class;
|
|
TcxCustomGridViewData = class;
|
|
TcxCustomGridCellViewInfo = class;
|
|
TcxCustomGridViewInfo = class;
|
|
TcxCustomGridViewInfoCache = class;
|
|
TcxGridSite = class;
|
|
TcxCustomGridView = class;
|
|
|
|
{ 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;
|
|
protected
|
|
class function GetHitTestCode: Integer; virtual;
|
|
procedure Init(const APos: TPoint);
|
|
public
|
|
class 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 FViewInfo;
|
|
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;
|
|
|
|
{ handlers }
|
|
|
|
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;
|
|
|
|
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 Init(const P: TPoint; AParams: TcxCustomGridHitTest); virtual;
|
|
property GridView: TcxCustomGridView read GetGridView;
|
|
end;
|
|
|
|
TcxCustomGridControllerClass = class of TcxCustomGridController;
|
|
|
|
TcxCustomGridController = class(TcxGridViewHandler, IcxMouseTrackingCaller)
|
|
private
|
|
FHintTextRect: TRect;
|
|
FHintWindow: THintWindow;
|
|
FIsDblClick: Boolean;
|
|
function GetDragAndDropObject: TcxCustomGridDragAndDropObject;
|
|
function GetDragAndDropObjectClass: TcxDragAndDropObjectClass;
|
|
function GetIsDragging: Boolean;
|
|
function GetMouseCaptureViewInfo: TcxCustomGridCellViewInfo;
|
|
procedure SetDragAndDropObjectClass(Value: TcxDragAndDropObjectClass);
|
|
procedure SetMouseCaptureViewInfo(Value: TcxCustomGridCellViewInfo);
|
|
protected
|
|
{ IcxMouseTrackingCaller }
|
|
procedure MouseLeave; virtual;
|
|
|
|
procedure AfterPaint; virtual;
|
|
procedure BeforeKillFocus; virtual;
|
|
procedure BeforePaint; virtual;
|
|
function CanHandleHitTest(AHitTest: TcxCustomGridHitTest): Boolean; virtual;
|
|
procedure DetailFocused(ADetail: TcxCustomGridView); virtual;
|
|
procedure DoEnter; virtual;
|
|
procedure DoExit; virtual;
|
|
function GetDesignHitTest(AHitTest: TcxCustomGridHitTest): Boolean; virtual;
|
|
function GetMouseWheelScrollingKind: TcxMouseWheelScrollingKind; virtual;
|
|
function IsPixelScrollBar(AKind: TScrollBarKind): Boolean; virtual;
|
|
function MayFocus: Boolean; virtual;
|
|
procedure RemoveFocus; virtual;
|
|
procedure SetFocus; virtual;
|
|
|
|
property DragAndDropObject: TcxCustomGridDragAndDropObject read GetDragAndDropObject;
|
|
property IsDragging: Boolean read GetIsDragging;
|
|
public
|
|
destructor Destroy; override;
|
|
procedure ControlFocusChanged; virtual;
|
|
procedure DesignerModified;
|
|
procedure DoCancelMode; virtual;
|
|
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;
|
|
|
|
procedure BeginDragAndDrop; virtual;
|
|
procedure DragAndDrop(const P: TPoint; var Accepted: Boolean); virtual;
|
|
procedure EndDragAndDrop(Accepted: Boolean); virtual;
|
|
function StartDragAndDrop(const P: TPoint): Boolean; virtual;
|
|
|
|
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 EndDrag(Target: TObject; X, Y: Integer); virtual;
|
|
procedure StartDrag(var DragObject: TDragObject); virtual;
|
|
|
|
// hints
|
|
procedure HideHint;
|
|
function GetHintWindowClass: THintWindowClass; virtual;
|
|
procedure ShowHint(const AHintAreaBounds, ATextRect: TRect; const AText: string;
|
|
AIsHintMultiLine: Boolean; AFont: TFont);
|
|
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;
|
|
|
|
procedure WndProc(var Message: TMessage); virtual;
|
|
|
|
{procedure BeginCellMouseTracking(AViewInfo: TcxCustomGridCellViewInfo);
|
|
procedure EndCellMouseTracking(AViewInfo: TcxCustomGridCellViewInfo);}
|
|
|
|
property DragAndDropObjectClass: TcxDragAndDropObjectClass read GetDragAndDropObjectClass
|
|
write SetDragAndDropObjectClass;
|
|
property IsDblClick: Boolean read FIsDblClick;
|
|
property MouseCaptureViewInfo: TcxCustomGridCellViewInfo read GetMouseCaptureViewInfo
|
|
write SetMouseCaptureViewInfo;
|
|
end;
|
|
|
|
IcxCustomGridDataController = interface
|
|
['{B9ABDC6B-1A4A-4F11-A629-09B6FB9FB4BA}']
|
|
procedure GetFakeComponentLinks(AList: TList);
|
|
function GetGridView: TcxCustomGridView;
|
|
property GridView: TcxCustomGridView read GetGridView;
|
|
end;
|
|
|
|
TcxCustomGridCellPainterClass = class of TcxCustomGridCellPainter;
|
|
|
|
TcxCustomGridCellPainter = class
|
|
private
|
|
FCanvas: TcxCanvas;
|
|
FViewInfo: TcxCustomGridCellViewInfo;
|
|
function GetIsMainCanvasInUse: Boolean;
|
|
protected
|
|
procedure AfterPaint; virtual;
|
|
procedure BeforePaint; virtual;
|
|
procedure DrawBackground; virtual;
|
|
function DrawBackgroundHandler(ACanvas: TcxCanvas; const ABounds: TRect): Boolean; virtual;
|
|
procedure DrawBorder(ABorder: TcxBorder); virtual;
|
|
procedure DrawBorders; virtual;
|
|
procedure DrawContent; virtual;
|
|
procedure DrawText; virtual;
|
|
function ExcludeFromClipRect: Boolean; virtual;
|
|
function NeedsPainting: Boolean; virtual;
|
|
procedure Paint; virtual;
|
|
property Canvas: TcxCanvas read FCanvas;
|
|
property IsMainCanvasInUse: Boolean read GetIsMainCanvasInUse;
|
|
property ViewInfo: TcxCustomGridCellViewInfo read FViewInfo;
|
|
public
|
|
constructor Create(ACanvas: TcxCanvas; AViewInfo: TcxCustomGridCellViewInfo); virtual;
|
|
procedure MainPaint; virtual;
|
|
end;
|
|
|
|
TcxCustomGridPainterClass = class of TcxCustomGridPainter;
|
|
|
|
TcxCustomGridPainter = class(TcxGridViewHandler)
|
|
private
|
|
FBackgroundRegion: TcxRegion;
|
|
FBeforePaintClipRegion: TcxRegion;
|
|
function GetCanvas: TcxCanvas;
|
|
protected
|
|
procedure DrawBackground; virtual;
|
|
procedure PaintAfter; virtual;
|
|
procedure PaintBefore; virtual;
|
|
procedure PaintContent; virtual;
|
|
property Canvas: TcxCanvas read GetCanvas;
|
|
public
|
|
procedure DrawFocusRect(const R: TRect; AHideFocusRect: Boolean); virtual;
|
|
procedure ExcludeFromBackground(const R: TRect);
|
|
procedure Paint;
|
|
procedure Invalidate; overload;
|
|
procedure Invalidate(const R: TRect); overload;
|
|
end;
|
|
|
|
TcxCustomGridViewDataClass = class of TcxCustomGridViewData;
|
|
|
|
TcxCustomGridViewData = class(TcxGridViewHandler)
|
|
public
|
|
property DataController;
|
|
end;
|
|
|
|
TcxGridSiteClass = class of TcxGridSite;
|
|
|
|
TcxGridSite = class(TcxControl)
|
|
private
|
|
FSize: TPoint;
|
|
FViewInfo: TcxCustomGridViewInfo;
|
|
function GetContainer: TcxControl;
|
|
function GetController: TcxCustomGridController;
|
|
function GetGridView: TcxCustomGridView;
|
|
function GetPainter: TcxCustomGridPainter;
|
|
procedure SendKeyDownNotification(const Message: TWMKeyDown);
|
|
procedure CMBoundsChanged(var Message: TMessage); message CM_BOUNDSCHANGED;
|
|
procedure CNKeyDown(var Message: TWMKeyDown); message CN_KEYDOWN;
|
|
procedure CNSysKeyDown(var Message: TWMKeyDown); message CN_SYSKEYDOWN;
|
|
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;
|
|
procedure DoCancelMode; override;
|
|
procedure DoEnter; override;
|
|
procedure DoExit; override;
|
|
procedure FocusChanged; override;
|
|
function FocusWhenChildIsClicked(AChild: TControl): Boolean; 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 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;
|
|
|
|
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 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 Keys; //!!!
|
|
property MouseCapture;
|
|
property ViewInfo: TcxCustomGridViewInfo read FViewInfo;
|
|
end;
|
|
|
|
TcxCustomGridCellViewInfoClass = class of TcxCustomGridCellViewInfo;
|
|
|
|
TcxCustomGridCellViewInfo = class(TObject, IUnknown, IcxMouseCaptureObject,
|
|
IcxMouseTrackingCaller)
|
|
private
|
|
FCalculated: Boolean;
|
|
FCalculatingParams: Boolean;
|
|
FContentBounds: TRect;
|
|
FAlignmentHorz: TAlignment;
|
|
FAlignmentVert: TcxAlignmentVert;
|
|
FBorders: TcxBorders;
|
|
FIsDestroying: Boolean;
|
|
FParamsCalculated: Boolean;
|
|
FState: TcxGridCellState;
|
|
FText: string;
|
|
FVisible: Boolean;
|
|
function GetBorderSize(AIndex: TcxBorder): Integer;
|
|
function GetContentBounds: TRect;
|
|
function GetTextAreaHeight: Integer;
|
|
function GetTextAreaWidth: Integer;
|
|
function GetTextHeight: Integer;
|
|
function GetTextWidth: Integer;
|
|
procedure SetState(Value: TcxGridCellState);
|
|
protected
|
|
{ IUnknown }
|
|
function QueryInterface(const IID: TGUID; out Obj): HResult; virtual; stdcall;
|
|
function _AddRef: Integer; stdcall;
|
|
function _Release: Integer; stdcall;
|
|
{ IcxMouseCaptureObject }
|
|
procedure DoCancelMode; virtual;
|
|
{ IcxMouseTrackingCaller }
|
|
procedure MouseLeave; virtual;
|
|
|
|
procedure AfterCalculateBounds(var ABounds: TRect); virtual;
|
|
procedure AfterCustomDraw(ACanvas: TcxCanvas); virtual;
|
|
procedure BeforeCustomDraw(ACanvas: TcxCanvas); virtual;
|
|
procedure BeforeStateChange; virtual;
|
|
function CalculateContentBounds: TRect; virtual;
|
|
procedure CalculateParams;
|
|
function CalculateHeight: Integer; virtual; abstract;
|
|
function CalculateWidth: Integer; virtual; abstract;
|
|
procedure Click; virtual;
|
|
function CustomDraw(ACanvas: TcxCanvas): Boolean; virtual;
|
|
function CustomDrawBackground(ACanvas: TcxCanvas): Boolean; virtual;
|
|
procedure Destroying;
|
|
procedure DoCalculateParams; virtual;
|
|
function DoCustomDraw(ACanvas: TcxCanvas): Boolean; virtual;
|
|
function DoCustomDrawBackground(ACanvas: TcxCanvas): Boolean; virtual;
|
|
function GetAlignmentHorz: TAlignment; virtual;
|
|
function GetAlignmentVert: TcxAlignmentVert; virtual;
|
|
function GetBackgroundBitmap: TBitmap; virtual;
|
|
function GetBorderBounds(AIndex: TcxBorder): TRect; virtual;
|
|
function GetBorderColor(AIndex: TcxBorder): TColor; virtual; abstract;
|
|
function GetBorders: TcxBorders; virtual;
|
|
function GetBorderWidth(AIndex: TcxBorder): Integer; virtual; abstract;
|
|
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 GetHeight: Integer; virtual;
|
|
function GetHitTestClass: TcxCustomGridHitTestClass; virtual; abstract;
|
|
function GetHotTrack: Boolean; virtual;
|
|
function GetIsCheck: 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;
|
|
function GetTextCellHeight(AGridViewInfo: TcxCustomGridViewInfo;
|
|
ALookAndFeelPainter: TcxCustomLookAndFeelPainterClass): Integer; virtual;
|
|
function GetTransparent: Boolean; virtual;
|
|
procedure GetViewParams(var AParams: TcxViewParams); virtual;
|
|
function GetVisible: Boolean; virtual;
|
|
function GetWidth: Integer; virtual;
|
|
function HasCustomDraw: Boolean; virtual;
|
|
function HasCustomDrawBackground: 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 SetMouseCapture(Value: Boolean); virtual;
|
|
procedure SetWidth(Value: Integer); virtual;
|
|
procedure StateChanged; virtual;
|
|
|
|
property BorderWidth[AIndex: TcxBorder]: Integer read GetBorderWidth;
|
|
property CalculatingParams: Boolean read FCalculatingParams;
|
|
property Canvas: TcxCanvas read GetCanvas;
|
|
property Control: TcxControl read GetControl;
|
|
property HotTrack: Boolean read GetHotTrack;
|
|
property IsCheck: Boolean read GetIsCheck;
|
|
property IsDestroying: Boolean read FIsDestroying;
|
|
property ShowEndEllipsis: Boolean read GetShowEndEllipsis;
|
|
public
|
|
Bounds: TRect;
|
|
MultiLine: Boolean;
|
|
MultiLinePainting: Boolean;
|
|
Params: TcxViewParams;
|
|
|
|
constructor Create;
|
|
destructor Destroy; override;
|
|
procedure AfterRecalculation; virtual;
|
|
procedure BeforeRecalculation; virtual;
|
|
procedure Calculate(ALeftBound, ATopBound: Integer; AWidth: Integer = -1;
|
|
AHeight: Integer = -1); overload; virtual;
|
|
procedure Calculate(const ABounds: TRect); overload; virtual;
|
|
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; 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;
|
|
|
|
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 Calculated: Boolean read FCalculated write FCalculated;
|
|
property ContentBounds: TRect read GetContentBounds;
|
|
property ContentHeight: Integer read GetContentHeight;
|
|
property ContentWidth: Integer read GetContentWidth;
|
|
property Height: Integer read GetHeight;
|
|
property MouseCapture: Boolean read GetMouseCapture write SetMouseCapture;
|
|
property State: TcxGridCellState read FState write SetState;
|
|
property Text: string read FText write FText;
|
|
property TextAreaHeight: Integer read GetTextAreaHeight;
|
|
property TextAreaWidth: Integer read GetTextAreaWidth;
|
|
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 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;
|
|
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 GetBoundsForHint: TRect; 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);
|
|
destructor Destroy; override;
|
|
procedure Invalidate; override;
|
|
function MouseMove(AHitTest: TcxCustomGridHitTest; AShift: TShiftState): Boolean; override;
|
|
property GridView: TcxCustomGridView read GetGridView;
|
|
property GridViewInfo: TcxCustomGridViewInfo read FGridViewInfo;
|
|
property LookAndFeelPainter: TcxCustomLookAndFeelPainterClass read GetLookAndFeelPainter;
|
|
end;
|
|
|
|
TcxCustomGridViewInfoClass = class of TcxCustomGridViewInfo;
|
|
|
|
TcxCustomGridViewInfo = class(TcxGridViewHandler)
|
|
private
|
|
FActiveViewInfos: TList;
|
|
FBounds: TRect;
|
|
FClientBounds: TRect;
|
|
FClientBoundsAssigned: Boolean;
|
|
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;
|
|
|
|
procedure CreateSite;
|
|
procedure DestroySite;
|
|
function GetSiteClass: TcxGridSiteClass; virtual;
|
|
function GetSiteParent: TWinControl;
|
|
|
|
procedure AddActiveViewInfo(AViewInfo: TObject);
|
|
function IsViewInfoActive(AViewInfo: TObject): Boolean;
|
|
procedure RemoveActiveViewInfo(AViewInfo: TObject);
|
|
|
|
procedure AddScrollBarHeight(var AHeight: Integer);
|
|
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;
|
|
procedure ControlFocusChanged; virtual;
|
|
function GetAllowBoundsChangedNotification: Boolean; virtual;
|
|
function GetBackgroundBitmap: TBitmap; virtual;
|
|
function GetBackgroundColor: TColor; virtual;
|
|
//function GetContentBounds: TRect; virtual;
|
|
procedure GetHScrollBarBounds(var ABounds: TRect); virtual;
|
|
function GetIsInternalUse: Boolean; virtual;
|
|
procedure InitHitTest(AHitTest: TcxCustomGridHitTest); virtual;
|
|
procedure UpdateMousePos;
|
|
procedure VisibilityChanged(AVisible: Boolean); virtual;
|
|
|
|
property AllowBoundsChangedNotification: Boolean read GetAllowBoundsChangedNotification;
|
|
property ClientBoundsAssigned: Boolean read FClientBoundsAssigned write FClientBoundsAssigned;
|
|
property SizeCalculating: Boolean read FSizeCalculating;
|
|
property VisibilityChanging: Boolean read FVisibilityChanging;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); override;
|
|
destructor Destroy; override;
|
|
procedure BeforeDestruction; override;
|
|
procedure DoVisibilityChanged(AVisible: Boolean);
|
|
function GetFontHeight(AFont: TFont): Integer;
|
|
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 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 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: TcxCustomGridViewInfoCacheItemClass; virtual;
|
|
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 }
|
|
|
|
TcxCustomGridOptions = class(TPersistent)
|
|
private
|
|
FGridView: TcxCustomGridView;
|
|
function GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
|
|
protected
|
|
procedure LayoutChanged;
|
|
procedure Notification(AComponent: TComponent; AOperation: TOperation); virtual;
|
|
property LookAndFeelPainter: TcxCustomLookAndFeelPainterClass read GetLookAndFeelPainter;
|
|
public
|
|
constructor Create(AGridView: TcxCustomGridView); virtual;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
property GridView: TcxCustomGridView read FGridView;
|
|
end;
|
|
|
|
{4}
|
|
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;
|
|
|
|
TcxCustomGridOptionsSelectionClass = class of TcxCustomGridOptionsSelection;
|
|
|
|
TcxCustomGridOptionsSelection = class(TcxCustomGridOptions);
|
|
|
|
TcxCustomGridOptionsViewClass = class of TcxCustomGridOptionsView;
|
|
|
|
TcxCustomGridOptionsView = class(TcxCustomGridOptions)
|
|
private
|
|
function GetScrollBars: TScrollStyle;
|
|
procedure SetScrollBars(Value: TScrollStyle);
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
published
|
|
property ScrollBars: TScrollStyle read GetScrollBars write SetScrollBars default ssBoth;
|
|
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;
|
|
property StyleSheet;
|
|
end;
|
|
|
|
TcxGridStorageOption = (gsoUseFilter, gsoUseSummary);
|
|
TcxGridStorageOptions = set of TcxGridStorageOption;
|
|
TcxGridViewChangeKind = (vcName{, vsRemoved});
|
|
|
|
TcxGridCellCustomDrawEvent = procedure(Sender: TcxCustomGridView; ACanvas: TcxCanvas;
|
|
AViewInfo: TcxCustomGridCellViewInfo; var ADone: Boolean) of object;
|
|
|
|
TcxCustomGridViewClass = class of TcxCustomGridView;
|
|
|
|
TcxCustomGridView = class(TcxControlChildComponent, IcxStoredObject, IcxStoredParent)
|
|
private
|
|
FAssigningPattern: Boolean;
|
|
FBackgroundBitmaps: TcxCustomGridBackgroundBitmaps;
|
|
FClones: TList;
|
|
FController: TcxCustomGridController;
|
|
FDataController: TcxCustomDataController;
|
|
FLevel: TComponent;
|
|
FListenerLinks: TList;
|
|
FOptionsList: TList;
|
|
FOptionsSelection: TcxCustomGridOptionsSelection;
|
|
FOptionsView: TcxCustomGridOptionsView;
|
|
FPainter: TcxCustomGridPainter;
|
|
FPatternGridView: TcxCustomGridView;
|
|
FRepository: TComponent; {5}
|
|
FStorageControl: TcxControl;
|
|
FStorageOptions: TcxGridStorageOptions;
|
|
FStoringName: string;
|
|
FStyles: TcxCustomGridStyles;
|
|
FViewData: TcxCustomGridViewData;
|
|
FViewInfo: TcxCustomGridViewInfo;
|
|
FViewInfoCache: TcxCustomGridViewInfoCache;
|
|
FSubClassEvents: TNotifyEvent;
|
|
|
|
function GetClone(Index: Integer): TcxCustomGridView;
|
|
function GetCloneCount: Integer;
|
|
function GetDragMode: TDragMode;
|
|
function GetFocused: Boolean;
|
|
function GetIsDetail: Boolean;
|
|
function GetIsMaster: Boolean;
|
|
function GetIsPattern: Boolean;
|
|
function GetIsStoringNameMode: Boolean;
|
|
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 GetOnMouseMove: TMouseMoveEvent;
|
|
function GetOnMouseUp: TMouseEvent;
|
|
function GetOnMouseWheel: TMouseWheelEvent;
|
|
function GetOnMouseWheelDown: TMouseWheelUpDownEvent;
|
|
function GetOnMouseWheelUp: TMouseWheelUpDownEvent;
|
|
function GetOnStartDrag: TStartDragEvent;
|
|
function GetPatternGridView: TcxCustomGridView;
|
|
function GetSite: TcxGridSite;
|
|
procedure SetBackgroundBitmaps(Value: TcxCustomGridBackgroundBitmaps);
|
|
procedure SetDragMode(Value: TDragMode);
|
|
procedure SetFocused(Value: Boolean);
|
|
procedure SetOnDblClick(Value: TNotifyEvent);
|
|
procedure SetOnDragDrop(Value: TDragDropEvent);
|
|
procedure SetOnDragOver(Value: TDragOverEvent);
|
|
procedure SetOnEndDrag(Value: TEndDragEvent);
|
|
procedure SetOnKeyDown(Value: TKeyEvent);
|
|
procedure SetOnKeyPress(Value: TKeyPressEvent);
|
|
procedure SetOnKeyUp(Value: TKeyEvent);
|
|
procedure SetOnMouseDown(Value: TMouseEvent);
|
|
procedure SetOnMouseMove(Value: TMouseMoveEvent);
|
|
procedure SetOnMouseUp(Value: TMouseEvent);
|
|
procedure SetOnMouseWheel(Value: TMouseWheelEvent);
|
|
procedure SetOnMouseWheelDown(Value: TMouseWheelUpDownEvent);
|
|
procedure SetOnMouseWheelUp(Value: TMouseWheelUpDownEvent);
|
|
procedure SetOnStartDrag(Value: TStartDragEvent);
|
|
procedure SetOptionsSelection(Value: TcxCustomGridOptionsSelection);
|
|
procedure SetOptionsView(Value: TcxCustomGridOptionsView);
|
|
procedure SetStyles(Value: TcxCustomGridStyles);
|
|
|
|
procedure ClearListenerLinks;
|
|
protected
|
|
// 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; virtual;
|
|
procedure DeleteChild(const AObjectName: string; AObject: TObject); virtual;
|
|
procedure IcxStoredParent.GetChildren = GetStoredChildren;
|
|
procedure GetStoredChildren(AChildren: TStringList); 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);
|
|
|
|
procedure AddListenerLink(ALink: Pointer);
|
|
procedure RemoveListenerLink(ALink: Pointer);
|
|
|
|
procedure AssignPattern(APattern: TcxCustomGridView);
|
|
|
|
procedure BeforeAssign(ASource: TcxCustomGridView); virtual;
|
|
procedure DoAssign(ASource: TcxCustomGridView); virtual;
|
|
procedure AfterAssign(ASource: TcxCustomGridView); virtual;
|
|
|
|
//procedure BeforeLevelChange; virtual;
|
|
function CanFocus: Boolean; virtual;
|
|
function CanTabStop: Boolean; virtual;
|
|
procedure DetailVisibleChanged(ADetailLevel: TComponent;
|
|
APrevVisibleDetailCount, AVisibleDetailCount: Integer); 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: TcxGridViewChangeKind);
|
|
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 GetOptionsSelectionClass: TcxCustomGridOptionsSelectionClass; virtual;
|
|
function GetOptionsViewClass: TcxCustomGridOptionsViewClass; virtual;
|
|
function GetStylesClass: TcxCustomGridViewStylesClass; virtual;
|
|
|
|
property AssigningPattern: Boolean read FAssigningPattern;
|
|
property BackgroundBitmaps: TcxCustomGridBackgroundBitmaps read FBackgroundBitmaps
|
|
write SetBackgroundBitmaps; {4}
|
|
property Changeable: Boolean read GetChangeable;
|
|
property IsStoringNameMode: Boolean read GetIsStoringNameMode;
|
|
property OptionsSelection: TcxCustomGridOptionsSelection read FOptionsSelection
|
|
write SetOptionsSelection;
|
|
property OptionsView: TcxCustomGridOptionsView read FOptionsView write SetOptionsView;
|
|
property ResizeOnBoundsChange: Boolean read GetResizeOnBoundsChange;
|
|
property Styles: TcxCustomGridStyles read FStyles write SetStyles;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
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 BeginUpdate;
|
|
procedure CancelUpdate;
|
|
function Changed(AGridChange: TObject): Boolean;
|
|
procedure EndUpdate;
|
|
|
|
procedure BoundsChanged(AUpdateSelfOnly: Boolean = False; AKeepMaster: Boolean = False); virtual;
|
|
procedure LayoutChanged(AUpdateSelfOnly: Boolean = True);
|
|
function SizeChanged(AUpdateSelfOnly: Boolean = False; AKeepMaster: Boolean = False): Boolean;
|
|
procedure ViewChanged; overload;
|
|
procedure ViewChanged(const AUpdateRect: TRect); overload;
|
|
|
|
procedure RestoreFromIniFile(AStorageName: string; AChildrenCreating: Boolean = False;
|
|
AChildrenDeleting: Boolean = False; AOptions: TcxGridStorageOptions = [];
|
|
const ARestoreViewName: string = '');
|
|
procedure RestoreFromRegistry(AStorageName: string; AChildrenCreating: Boolean = False;
|
|
AChildrenDeleting: Boolean = False; AOptions: TcxGridStorageOptions = [];
|
|
const ARestoreViewName: string = '');
|
|
procedure RestoreFromStream(AStream: TStream; AChildrenCreating: Boolean = False;
|
|
AChildrenDeleting: Boolean = False; AOptions: TcxGridStorageOptions = [];
|
|
const ARestoreViewName: string = '');
|
|
procedure StoreToIniFile(AStorageName: string; AReCreate: Boolean = True;
|
|
AOptions: TcxGridStorageOptions = []; const ASaveViewName: string = '');
|
|
procedure StoreToRegistry(AStorageName: string; AReCreate: Boolean = True;
|
|
AOptions: TcxGridStorageOptions = []; const ASaveViewName: string = '');
|
|
procedure StoreToStream(AStream: TStream; AOptions: TcxGridStorageOptions = [];
|
|
const ASaveViewName: string = '');
|
|
|
|
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 GetIsControlFocused;
|
|
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 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 StylesEvents: TNotifyEvent read FSubClassEvents write FSubClassEvents;
|
|
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 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;
|
|
end;
|
|
|
|
var
|
|
cxGridRegisteredViews: TcxRegisteredClasses;
|
|
|
|
function GetParentGridView(AControl: TControl): TcxCustomGridView;
|
|
|
|
implementation
|
|
|
|
uses
|
|
SysUtils, cxGrid, cxGridLevel;
|
|
|
|
type
|
|
{$IFNDEF DELPHI6}
|
|
PPointer = ^Pointer;
|
|
{$ENDIF}
|
|
THintWindowAccess = class(THintWindow);
|
|
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 := 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 }
|
|
|
|
class function TcxCustomGridHitTest.GetHitTestCode: Integer;
|
|
begin
|
|
Result := htError;
|
|
end;
|
|
|
|
procedure TcxCustomGridHitTest.Init(const APos: TPoint);
|
|
begin
|
|
FPos := APos;
|
|
end;
|
|
|
|
class 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;
|
|
|
|
{ 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
|
|
Dirty := False;
|
|
end;
|
|
|
|
procedure TcxCustomGridDragAndDropObject.BeforePaint;
|
|
begin
|
|
Dirty := True;
|
|
end;
|
|
|
|
procedure TcxCustomGridDragAndDropObject.Init(const P: TPoint; AParams: TcxCustomGridHitTest);
|
|
begin
|
|
SourcePoint := P;
|
|
end;
|
|
|
|
{ TcxCustomGridController }
|
|
|
|
destructor TcxCustomGridController.Destroy;
|
|
begin
|
|
HideHint;
|
|
inherited;
|
|
end;
|
|
|
|
function TcxCustomGridController.GetDragAndDropObject: TcxCustomGridDragAndDropObject;
|
|
begin
|
|
Result := Site.DragAndDropObject as TcxCustomGridDragAndDropObject;
|
|
end;
|
|
|
|
function TcxCustomGridController.GetDragAndDropObjectClass: TcxDragAndDropObjectClass;
|
|
begin
|
|
Result := Site.DragAndDropObjectClass;
|
|
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.SetDragAndDropObjectClass(Value: TcxDragAndDropObjectClass);
|
|
begin
|
|
Site.DragAndDropObjectClass := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.SetMouseCaptureViewInfo(Value: TcxCustomGridCellViewInfo);
|
|
begin
|
|
Site.MouseCaptureObject := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.MouseLeave;
|
|
begin
|
|
HideHint;
|
|
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.CanHandleHitTest(AHitTest: TcxCustomGridHitTest): Boolean;
|
|
begin
|
|
Result := not (AHitTest is TcxCustomGridViewHitTest) or
|
|
(TcxCustomGridViewHitTest(AHitTest).GridView = FGridView);
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DetailFocused(ADetail: TcxCustomGridView);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DoEnter;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DoExit;
|
|
begin
|
|
end;
|
|
|
|
function TcxCustomGridController.GetDesignHitTest(AHitTest: TcxCustomGridHitTest): Boolean;
|
|
begin
|
|
Result := AHitTest.DragAndDropObjectClass <> nil;
|
|
end;
|
|
|
|
function TcxCustomGridController.GetMouseWheelScrollingKind: TcxMouseWheelScrollingKind;
|
|
begin
|
|
Result := mwskNone;
|
|
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;
|
|
begin
|
|
GridView.TabStop := True;
|
|
ViewInfo.DoVisibilityChanged(True);
|
|
if Control.IsFocused and Site.CanFocusEx then
|
|
Site.SetFocus;
|
|
with GridView do
|
|
if IsDetail then
|
|
MasterGridView.Controller.DetailFocused(GridView);
|
|
end;
|
|
|
|
procedure TcxCustomGridController.ControlFocusChanged;
|
|
begin
|
|
ViewInfo.ControlFocusChanged;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DesignerModified;
|
|
begin
|
|
Site.Modified;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.DoCancelMode;
|
|
begin
|
|
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 := TcxGridViewNoneHitTest.Cursor;
|
|
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;
|
|
begin
|
|
Site.UpdateScrollBars;
|
|
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
|
|
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.EndDrag(Target: TObject; X, Y: Integer);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.StartDrag(var DragObject: TDragObject);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridController.HideHint;
|
|
begin
|
|
EndMouseTracking(Self);
|
|
FreeAndNil(FHintWindow);
|
|
end;
|
|
|
|
function TcxCustomGridController.GetHintWindowClass: THintWindowClass;
|
|
begin
|
|
Result := HintWindowClass;
|
|
end;
|
|
|
|
procedure TcxCustomGridController.ShowHint(const AHintAreaBounds, ATextRect: TRect;
|
|
const AText: string; AIsHintMultiLine: Boolean; AFont: TFont);
|
|
|
|
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 - Left + TextOffset.X;
|
|
Result.Y := Y - Top + TextOffset.Y;
|
|
end;
|
|
end;
|
|
|
|
procedure CheckBoundsOnDesktop;
|
|
var
|
|
R: TRect;
|
|
begin
|
|
R := GetDesktopWorkArea(Result.TopLeft);
|
|
with Result do
|
|
begin
|
|
if Right > R.Right then
|
|
OffsetRect(Result, R.Right - Right, 0);
|
|
if Bottom > R.Bottom then
|
|
OffsetRect(Result, 0, R.Bottom - Bottom);
|
|
if Left < R.Left then
|
|
OffsetRect(Result, R.Left - Left, 0);
|
|
if Top < R.Top then
|
|
OffsetRect(Result, 0, R.Top - Top);
|
|
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);
|
|
CheckBoundsOnDesktop;
|
|
Dec(Result.Bottom, 4);
|
|
end;
|
|
|
|
begin
|
|
if FHintWindow = nil then
|
|
begin
|
|
FHintWindow := GetHintWindowClass.Create(nil);
|
|
FHintWindow.Color := Application.HintColor;
|
|
end
|
|
else
|
|
begin
|
|
if (THintWindowAccess(FHintWindow).Caption = AText) and
|
|
CompareMem(@FHintTextRect, @ATextRect, SizeOf(TRect)) then
|
|
Exit;
|
|
EndMouseTracking(Self);
|
|
end;
|
|
FHintTextRect := ATextRect;
|
|
THintWindowAccess(FHintWindow).Canvas.Font := AFont;
|
|
FHintWindow.ActivateHint(GetHintWindowRect, AText);
|
|
BeginMouseTracking(Site, AHintAreaBounds, Self);
|
|
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;
|
|
|
|
procedure TcxCustomGridController.WndProc(var Message: TMessage);
|
|
begin
|
|
end;
|
|
|
|
{procedure TcxCustomGridController.BeginCellMouseTracking(AViewInfo: TcxCustomGridCellViewInfo);
|
|
begin
|
|
BeginMouseTracking(Site, AViewInfo.Bounds, AViewInfo);
|
|
end;
|
|
|
|
procedure TcxCustomGridController.EndCellMouseTracking(AViewInfo: TcxCustomGridCellViewInfo);
|
|
begin
|
|
EndMouseTracking(AViewInfo);
|
|
end;}
|
|
|
|
{ TcxCustomGridCellPainter }
|
|
|
|
constructor TcxCustomGridCellPainter.Create(ACanvas: TcxCanvas;
|
|
AViewInfo: TcxCustomGridCellViewInfo);
|
|
begin
|
|
inherited Create;
|
|
FCanvas := ACanvas;
|
|
FViewInfo := AViewInfo;
|
|
end;
|
|
|
|
function TcxCustomGridCellPainter.GetIsMainCanvasInUse: Boolean;
|
|
begin
|
|
Result := FCanvas = FViewInfo.Canvas;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellPainter.AfterPaint;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridCellPainter.BeforePaint;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridCellPainter.DrawBackground;
|
|
begin {4}
|
|
with Canvas, ViewInfo do
|
|
if not Transparent then
|
|
begin
|
|
Brush.Color := Params.Color;
|
|
FillRect(ContentBounds);
|
|
end
|
|
else
|
|
if BackgroundBitmap <> nil then
|
|
FillRect(ContentBounds, 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;
|
|
{var
|
|
R: TRect;}
|
|
begin
|
|
if not ViewInfo.DoCustomDrawBackground(Canvas) then
|
|
DrawBackground;
|
|
DrawText;
|
|
{with Canvas, ViewInfo do
|
|
if Text <> '' then
|
|
begin
|
|
R := TextAreaBounds; // can call font change
|
|
Font := Params.Font;
|
|
Font.Color := Params.TextColor;
|
|
Brush.Style := bsClear;
|
|
DrawText(Text, R, GetTextAttributes);
|
|
Brush.Style := bsSolid;
|
|
end;}
|
|
end;
|
|
|
|
procedure TcxCustomGridCellPainter.DrawText;
|
|
var
|
|
R: TRect;
|
|
begin
|
|
with Canvas, ViewInfo do
|
|
if Text <> '' then
|
|
begin
|
|
R := TextAreaBounds; // can call font change
|
|
Font := Params.Font;
|
|
Font.Color := Params.TextColor;
|
|
Brush.Style := bsClear;
|
|
DrawText(Text, R, GetTextAttributes(True));
|
|
Brush.Style := bsSolid;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridCellPainter.ExcludeFromClipRect: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxCustomGridCellPainter.NeedsPainting: Boolean;
|
|
begin
|
|
Result := Canvas.RectVisible(ViewInfo.Bounds);
|
|
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.MainPaint;
|
|
begin
|
|
if not NeedsPainting then Exit;
|
|
BeforePaint;
|
|
Paint;
|
|
AfterPaint;
|
|
if ExcludeFromClipRect then
|
|
Canvas.ExcludeClipRect(ViewInfo.Bounds);
|
|
end;
|
|
|
|
{ TcxCustomGridPainter }
|
|
|
|
function TcxCustomGridPainter.GetCanvas: TcxCanvas;
|
|
begin
|
|
Result := ViewInfo.Canvas;
|
|
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}
|
|
FreeAndNil(FBackgroundRegion);
|
|
Canvas.ExcludeClipRect(ViewInfo.Bounds);
|
|
end;
|
|
|
|
procedure TcxCustomGridPainter.PaintAfter;
|
|
begin
|
|
DrawBackground;
|
|
Canvas.SetClipRegion(FBeforePaintClipRegion, roSet);
|
|
Controller.AfterPaint;
|
|
end;
|
|
|
|
procedure TcxCustomGridPainter.PaintBefore;
|
|
begin
|
|
Controller.BeforePaint;
|
|
FBeforePaintClipRegion := Canvas.GetClipRegion;
|
|
FBackgroundRegion := TcxRegion.Create(ViewInfo.Bounds);
|
|
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;
|
|
|
|
//var i,ft,lt:integer;
|
|
|
|
begin {3}
|
|
|
|
//ft:=gettickcount;
|
|
{for i:=1 to 10 do
|
|
begin}
|
|
|
|
PaintBefore;
|
|
PaintContent;
|
|
PaintAfter;
|
|
|
|
{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;
|
|
|
|
{ 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(const Message: TWMKeyDown);
|
|
begin
|
|
TcxCustomGrid(GridView.Control).SendNotifications(gnkKeyDown, @Message);
|
|
end;
|
|
|
|
procedure TcxGridSite.CMBoundsChanged(var Message: TMessage);
|
|
var
|
|
AMsg: TMsg;
|
|
begin
|
|
while PeekMessage(AMsg, Handle, CM_BOUNDSCHANGED, CM_BOUNDSCHANGED, PM_REMOVE) do;
|
|
GridView.BoundsChanged(True, True);
|
|
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;
|
|
|
|
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
|
|
APrevSize := FSize;
|
|
UpdateSize;
|
|
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 not Container.IsDesigning }and
|
|
Controller.CanDrag(X, Y);
|
|
end;
|
|
|
|
procedure TcxGridSite.DoCancelMode;
|
|
begin
|
|
inherited;
|
|
Controller.DoCancelMode;
|
|
end;
|
|
|
|
procedure TcxGridSite.DoEnter;
|
|
begin
|
|
inherited;
|
|
Controller.DoEnter;
|
|
end;
|
|
|
|
procedure TcxGridSite.DoExit;
|
|
begin
|
|
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.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 (ssLeft in Shift) then
|
|
begin
|
|
AHitTest := ViewInfo.GetHitTest(X, Y);
|
|
Result := Controller.GetDesignHitTest(AHitTest);
|
|
end;
|
|
end;
|
|
|
|
function TcxGridSite.GetIsDesigning: Boolean;
|
|
begin
|
|
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);
|
|
if Key = VK_APPS then
|
|
TcxCustomGrid(GridView.Control).SendNotifications(gnkContextMenu, Pointer(True));
|
|
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 Controller.MayFocus;
|
|
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;
|
|
if Button = mbRight then
|
|
TcxCustomGrid(GridView.Control).SendNotifications(gnkContextMenu, Pointer(False));
|
|
end;
|
|
|
|
procedure TcxGridSite.Paint;
|
|
begin
|
|
if not FViewInfo.IsCalculating and (Left <> cxGridInvisibleCoordinate) then
|
|
Painter.Paint;
|
|
end;
|
|
|
|
procedure TcxGridSite.RequestAlign;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxGridSite.SetParent(AParent: TWinControl);
|
|
begin
|
|
if Parent <> AParent then
|
|
begin
|
|
if AParent <> nil then
|
|
LookAndFeel.MasterLookAndFeel := TcxCustomGrid(GridView.Control).LookAndFeel;
|
|
InitTabStop(AParent);
|
|
if (AParent = nil) and GridView.Focused and Parent.CanFocus then
|
|
Parent.SetFocus;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxGridSite.WndProc(var Message: TMessage);
|
|
begin
|
|
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;
|
|
|
|
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 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
|
|
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 HandleAllocated then
|
|
PostMessage(Handle, CM_BOUNDSCHANGED, 0, 0);
|
|
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
|
|
Destroying;
|
|
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.GetContentBounds: TRect;
|
|
begin
|
|
if IsRectEmpty(FContentBounds) then
|
|
FContentBounds := CalculateContentBounds;
|
|
Result := FContentBounds;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetTextAreaHeight: Integer;
|
|
begin
|
|
Result := TextHeight;
|
|
GetCellTextAreaSize(Result);
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetTextAreaWidth: Integer;
|
|
begin
|
|
Result := TextWidth;
|
|
GetCellTextAreaSize(Result);
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetTextHeight: Integer;
|
|
var
|
|
R: TRect;
|
|
begin
|
|
CalculateParams;
|
|
R := TextAreaBounds;
|
|
Canvas.Font := Params.Font;
|
|
Canvas.TextExtent(Text, R, GetTextAttributes(False));
|
|
Result := R.Bottom - R.Top;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetTextWidth: Integer;
|
|
begin
|
|
CalculateParams;
|
|
Canvas.Font := Params.Font;
|
|
Result := Canvas.TextWidth(Text);
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.SetState(Value: TcxGridCellState);
|
|
begin
|
|
if FState <> Value then
|
|
begin
|
|
BeforeStateChange;
|
|
FState := Value;
|
|
StateChanged;
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.QueryInterface(const IID: TGUID; out Obj): HResult;
|
|
begin
|
|
if GetInterface(IID, Obj) then
|
|
Result := S_OK
|
|
else
|
|
Result := E_NOINTERFACE;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo._AddRef: Integer;
|
|
begin
|
|
Result := -1;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo._Release: Integer;
|
|
begin
|
|
Result := -1;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.DoCancelMode;
|
|
begin
|
|
State := gcsNone;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.MouseLeave;
|
|
begin
|
|
if not MouseCapture and (FState = gcsSelected) then State := gcsNone;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.AfterCalculateBounds(var ABounds: TRect);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.AfterCustomDraw(ACanvas: TcxCanvas);
|
|
begin
|
|
with ACanvas do
|
|
begin
|
|
Params.Color := Brush.Color;
|
|
Params.Font := Font;
|
|
Params.TextColor := Font.Color;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.BeforeCustomDraw(ACanvas: TcxCanvas);
|
|
begin
|
|
with ACanvas do
|
|
begin
|
|
Brush.Color := Params.Color;
|
|
Font := Params.Font;
|
|
Font.Color := Params.TextColor;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.BeforeStateChange;
|
|
begin
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.CalculateContentBounds: 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;
|
|
|
|
procedure TcxCustomGridCellViewInfo.CalculateParams;
|
|
begin
|
|
if FParamsCalculated or FCalculatingParams then Exit;
|
|
FCalculatingParams := True;
|
|
try
|
|
DoCalculateParams;
|
|
finally
|
|
FCalculatingParams := False;
|
|
FParamsCalculated := True;
|
|
end;
|
|
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;
|
|
|
|
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.GetAlignmentHorz: TAlignment;
|
|
begin
|
|
Result := taLeftJustify;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetAlignmentVert: TcxAlignmentVert;
|
|
begin
|
|
Result := vaTop;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetBackgroundBitmap: TBitmap;
|
|
begin {4}
|
|
Result := nil;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetBorderBounds(AIndex: TcxBorder): TRect;
|
|
begin
|
|
Result := ContentBounds;
|
|
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;
|
|
|
|
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.GetHeight: Integer;
|
|
begin
|
|
with Bounds do
|
|
Result := Bottom - Top;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetHotTrack: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetIsCheck: Boolean;
|
|
begin
|
|
Result := False;
|
|
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
|
|
AlignmentsHorz: array[TAlignment] of Integer =
|
|
(cxAlignLeft, cxAlignRight, cxAlignHCenter);
|
|
AlignmentsVert: array[TcxAlignmentVert] of Integer =
|
|
(cxAlignTop, cxAlignBottom, cxAlignVCenter);
|
|
MultiLines: array[Boolean] of Integer = (cxSingleLine, cxWordBreak);
|
|
ShowEndEllipsises: array[Boolean] of Integer = (0, cxShowEndEllipsis);
|
|
begin
|
|
Result :=
|
|
AlignmentsHorz[AlignmentHorz] or AlignmentsVert[AlignmentVert] or
|
|
MultiLines[AForPainting and MultiLinePainting or not AForPainting and MultiLine] or
|
|
ShowEndEllipsises[ShowEndEllipsis];
|
|
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.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.GetWidth: Integer;
|
|
begin
|
|
with Bounds do
|
|
Result := Right - Left;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.HasCustomDraw: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.HasCustomDrawBackground: Boolean;
|
|
begin
|
|
Result := False;
|
|
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 {2}
|
|
OffsetRect(Bounds, 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.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;
|
|
begin
|
|
if InvalidateOnStateChange then Invalidate;
|
|
case State of
|
|
gcsNone:
|
|
EndMouseTracking(Self);
|
|
gcsSelected:
|
|
if Control <> nil then
|
|
BeginMouseTracking(Control, Bounds, Self);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.AfterRecalculation;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.BeforeRecalculation;
|
|
begin
|
|
FParamsCalculated := False;
|
|
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, Right - Left, Bottom - Top);
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
|
|
begin
|
|
if PtInRect(Bounds, P) and (GetHitTestClass <> nil) then
|
|
begin
|
|
Result := GetHitTestClass.Instance(P);
|
|
InitHitTest(Result);
|
|
end
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.Invalidate;
|
|
begin
|
|
if Control <> nil then
|
|
Control.InvalidateRect(Bounds, False);
|
|
end;
|
|
|
|
function TcxCustomGridCellViewInfo.MouseDown(AHitTest: TcxCustomGridHitTest;
|
|
AButton: TMouseButton; AShift: TShiftState): Boolean;
|
|
begin
|
|
Result := False;
|
|
if (AButton = mbLeft) and HotTrack 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
|
|
State := gcsSelected;
|
|
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 not IsCheck then
|
|
begin
|
|
Result := State = gcsPressed;
|
|
State := gcsNone;
|
|
if Result then Click;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridCellViewInfo.DoOffset(DX, DY: Integer);
|
|
begin
|
|
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 Visible 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(FContentBounds);
|
|
end;
|
|
|
|
{ TcxCustomGridViewCellViewInfo }
|
|
|
|
constructor TcxCustomGridViewCellViewInfo.Create(AGridViewInfo: TcxCustomGridViewInfo);
|
|
begin
|
|
inherited Create;
|
|
FGridViewInfo := AGridViewInfo;
|
|
end;
|
|
|
|
destructor TcxCustomGridViewCellViewInfo.Destroy;
|
|
begin
|
|
FGridViewInfo.RemoveActiveViewInfo(Self);
|
|
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 PtInRect(Bounds, GridViewInfo.MousePos) then
|
|
begin
|
|
AHitTest := GetHitTestClass.Instance(GridViewInfo.MousePos);
|
|
InitHitTest(AHitTest);
|
|
MouseMove(AHitTest, []);
|
|
end;
|
|
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 {9}
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewCellViewInfo.CheckHint(AHitTest: TcxCustomGridHitTest);
|
|
var
|
|
AHintText: TCaption;
|
|
AIsHintMultiLine: Boolean;
|
|
ATextRect: TRect;
|
|
begin {9}
|
|
if NeedShowHint(AHitTest.Pos, AHintText, AIsHintMultiLine, ATextRect) then
|
|
Controller.ShowHint(GetBoundsForHint, ATextRect, AHintText, AIsHintMultiLine, Params.Font)
|
|
else
|
|
Controller.HideHint;
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.GetBoundsForHint: TRect;
|
|
begin
|
|
Result := ContentBounds;
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.NeedShowHint(const AMousePos: TPoint;
|
|
out AHintText: TCaption; out AIsHintMultiLine: Boolean; out ATextRect: TRect): Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewCellViewInfo.Invalidate;
|
|
begin
|
|
if IsDestroying then Exit;
|
|
CalculateParams;
|
|
GridView.ViewChanged(Bounds);
|
|
end;
|
|
|
|
function TcxCustomGridViewCellViewInfo.MouseMove(AHitTest: TcxCustomGridHitTest;
|
|
AShift: TShiftState): Boolean;
|
|
begin
|
|
Result := inherited MouseMove(AHitTest, AShift);
|
|
if CanShowHint then
|
|
CheckHint(AHitTest); {9}
|
|
end;
|
|
|
|
{ TcxCustomGridViewInfo }
|
|
|
|
constructor TcxCustomGridViewInfo.Create(AGridView: TcxCustomGridView);
|
|
begin
|
|
inherited;
|
|
InitializeCriticalSection(FLock);
|
|
FActiveViewInfos := TList.Create;
|
|
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
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.DestroyViewInfos(AIsRecreating: Boolean);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.RecreateViewInfos;
|
|
begin
|
|
FClientBoundsAssigned := False;
|
|
DestroyViewInfos(True);
|
|
CreateViewInfos;
|
|
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);
|
|
begin
|
|
FActiveViewInfos.Remove(AViewInfo);
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.AddScrollBarHeight(var AHeight: Integer);
|
|
begin
|
|
if Site.HScrollBarVisible then
|
|
Inc(AHeight, Site.HScrollBar.Height);
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.AfterCalculating;
|
|
begin
|
|
if not IsInternalUse then Controller.UpdateScrollBars;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.BeforeCalculating;
|
|
begin
|
|
UpdateMousePos;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.Calculate;
|
|
begin
|
|
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;
|
|
|
|
procedure TcxCustomGridViewInfo.ControlFocusChanged;
|
|
begin
|
|
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;
|
|
|
|
procedure TcxCustomGridViewInfo.GetHScrollBarBounds(var ABounds: TRect);
|
|
begin
|
|
end;
|
|
|
|
function TcxCustomGridViewInfo.GetIsInternalUse: Boolean;
|
|
begin
|
|
Result := FIsInternalUse;
|
|
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 GridView.Control.IsDesigning then
|
|
FMousePos := FSite.ScreenToClient(GetMouseCursorPos)
|
|
else
|
|
FMousePos := Point(MaxInt, MaxInt);
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.VisibilityChanged(AVisible: Boolean);
|
|
begin
|
|
UpdateMousePos;
|
|
if AVisible then
|
|
begin
|
|
FSite.Parent := GetSiteParent;
|
|
end
|
|
else
|
|
if (Control = nil) or GridView.IsDestroying or
|
|
not FSite.IsFocused and ((TcxCustomGrid(Control).FocusedView = nil) or
|
|
not FSite.ContainsControl(TcxCustomGrid(Control).FocusedView.Site)) then
|
|
begin
|
|
FSite.Parent := nil;
|
|
end
|
|
else
|
|
FSite.Left := cxGridInvisibleCoordinate;
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.BeforeDestruction;
|
|
begin
|
|
inherited;
|
|
DestroyViewInfos(False);
|
|
end;
|
|
|
|
procedure TcxCustomGridViewInfo.DoVisibilityChanged(AVisible: Boolean);
|
|
begin
|
|
if not IsInternalUse and not FSizeCalculating 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.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 := TcxGridViewNoneHitTest.Instance(P);
|
|
InitHitTest(Result);
|
|
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;
|
|
{3}
|
|
|
|
{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);
|
|
}
|
|
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 := FItems[Index];
|
|
end;
|
|
|
|
function TcxCustomGridViewInfoCache.GetItem(Index: Integer): TcxCustomGridViewInfoCacheItem;
|
|
begin
|
|
Result := InternalItems[Index];
|
|
if Result = nil then
|
|
begin
|
|
Result := GetItemClass.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;
|
|
|
|
function TcxCustomGridViewInfoCache.GetItemClass: TcxCustomGridViewInfoCacheItemClass;
|
|
begin
|
|
Result := TcxCustomGridViewInfoCacheItem;
|
|
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 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;
|
|
FGridView := AGridView;
|
|
FGridView.AddOptions(Self);
|
|
end;
|
|
|
|
destructor TcxCustomGridOptions.Destroy;
|
|
begin
|
|
FGridView.RemoveOptions(Self);
|
|
inherited;
|
|
end;
|
|
|
|
function TcxCustomGridOptions.GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
|
|
begin
|
|
Result := FGridView.LookAndFeelPainter;
|
|
end;
|
|
|
|
procedure TcxCustomGridOptions.LayoutChanged;
|
|
begin
|
|
GridView.LayoutChanged;
|
|
end;
|
|
|
|
procedure TcxCustomGridOptions.Notification(AComponent: TComponent;
|
|
AOperation: TOperation);
|
|
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
|
|
GridView.LayoutChanged;
|
|
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;
|
|
|
|
{ TcxCustomGridOptionsView }
|
|
|
|
function TcxCustomGridOptionsView.GetScrollBars: TScrollStyle;
|
|
begin
|
|
Result := GridView.Site.ScrollBars;
|
|
end;
|
|
|
|
procedure TcxCustomGridOptionsView.SetScrollBars(Value: TScrollStyle);
|
|
begin
|
|
GridView.Site.ScrollBars := Value;
|
|
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
|
|
with GridView do
|
|
begin
|
|
UpdateFakeLinks;
|
|
SizeChanged;
|
|
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:
|
|
Color := DefaultContentColor;
|
|
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;
|
|
|
|
{ TcxCustomGridView }
|
|
|
|
constructor TcxCustomGridView.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FListenerLinks := TList.Create;
|
|
FClones := TList.Create;
|
|
CreateOptions;
|
|
CreateHandlers;
|
|
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.GetIsDetail: Boolean;
|
|
begin
|
|
Result := 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.GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
|
|
begin
|
|
if Control = nil then
|
|
Result := TcxStandardLookAndFeelPainter
|
|
else
|
|
Result := TcxCustomGrid(Control).LookAndFeel.Painter;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetMasterGridView: TcxCustomGridView;
|
|
var
|
|
AIDataController: IcxCustomGridDataController;
|
|
begin
|
|
if IsDetail then
|
|
begin
|
|
DataController.GetMasterDataController.GetInterface(IcxCustomGridDataController, AIDataController);
|
|
Result := AIDataController.GridView;
|
|
end
|
|
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.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.GetSite: TcxGridSite;
|
|
begin
|
|
if FViewInfo = nil then
|
|
Result := nil
|
|
else
|
|
Result := FViewInfo.Site;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetBackgroundBitmaps(Value: TcxCustomGridBackgroundBitmaps);
|
|
begin
|
|
FBackgroundBitmaps.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetDragMode(Value: TDragMode);
|
|
begin
|
|
Site.DragMode := Value;
|
|
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.SetOnDblClick(Value: TNotifyEvent);
|
|
begin
|
|
Site.OnDblClick := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnDragDrop(Value: TDragDropEvent);
|
|
begin
|
|
Site.OnDragDrop := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnDragOver(Value: TDragOverEvent);
|
|
begin
|
|
Site.OnDragOver := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnEndDrag(Value: TEndDragEvent);
|
|
begin
|
|
Site.OnEndDrag := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnKeyDown(Value: TKeyEvent);
|
|
begin
|
|
Site.OnKeyDown := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnKeyPress(Value: TKeyPressEvent);
|
|
begin
|
|
Site.OnKeyPress := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnKeyUp(Value: TKeyEvent);
|
|
begin
|
|
Site.OnKeyUp := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnMouseDown(Value: TMouseEvent);
|
|
begin
|
|
Site.OnMouseDown := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnMouseMove(Value: TMouseMoveEvent);
|
|
begin
|
|
Site.OnMouseMove := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnMouseUp(Value: TMouseEvent);
|
|
begin
|
|
Site.OnMouseUp := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnMouseWheel(Value: TMouseWheelEvent);
|
|
begin
|
|
Site.OnMouseWheel := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnMouseWheelDown(Value: TMouseWheelUpDownEvent);
|
|
begin
|
|
Site.OnMouseWheelDown := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnMouseWheelUp(Value: TMouseWheelUpDownEvent);
|
|
begin
|
|
Site.OnMouseWheelUp := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOnStartDrag(Value: TStartDragEvent);
|
|
begin
|
|
Site.OnStartDrag := Value;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOptionsSelection(Value: TcxCustomGridOptionsSelection);
|
|
begin
|
|
FOptionsSelection.Assign(Value);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetOptionsView(Value: TcxCustomGridOptionsView);
|
|
begin
|
|
FOptionsView.Assign(Value);
|
|
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
|
|
begin
|
|
PPointer(FListenerLinks[I])^ := nil;
|
|
RemoveListenerLink(FListenerLinks[I]);
|
|
end;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetObjectName: string;
|
|
begin
|
|
if IsStoringNameMode then
|
|
Result := FStoringName
|
|
else
|
|
Result := Name;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetProperties(AProperties: TStrings): Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.GetPropertyValue(const AName: string; var AValue: Variant);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetPropertyValue(const AName: string; const AValue: Variant);
|
|
begin
|
|
end;
|
|
|
|
function TcxCustomGridView.CreateChild(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.GetFakeComponentLinks(AList: TList);
|
|
var
|
|
AIDataController: IcxCustomGridDataController;
|
|
begin
|
|
inherited;
|
|
FDataController.GetInterface(IcxCustomGridDataController, AIDataController);
|
|
AIDataController.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
|
|
TcxCustomGridAccess(Control).RemoveFontListener(FStyles); {5}
|
|
if Site <> nil then
|
|
Control.RemoveComponent(Site);
|
|
end;
|
|
inherited;
|
|
if Control <> nil then
|
|
begin
|
|
if (FStorageControl = nil) and (FRepository = nil) then
|
|
FStorageControl := Value;
|
|
Control.InsertComponent(Site);
|
|
TcxCustomGridAccess(Control).AddFontListener(FStyles);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.SetName(const NewName: TComponentName);
|
|
begin
|
|
inherited;
|
|
NotifyControl(vcName);
|
|
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 := GetViewInfoClass.Create(Self);
|
|
FViewInfoCache := GetViewInfoCacheClass.Create(Self);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.DestroyHandlers;
|
|
begin
|
|
FDataController.Free;
|
|
FDataController := nil;
|
|
FreeAndNil(FViewInfoCache);
|
|
if Control <> nil then
|
|
Control.RemoveComponent(Site); {5}
|
|
FViewInfo.Free;
|
|
FViewInfo := nil;
|
|
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);
|
|
FOptionsSelection := GetOptionsSelectionClass.Create(Self);
|
|
FOptionsView := GetOptionsViewClass.Create(Self);
|
|
FStyles := GetStylesClass.Create(Self);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.DestroyOptions;
|
|
begin
|
|
if Control <> nil then {5}
|
|
TcxCustomGridAccess(Control).RemoveFontListener(FStyles);
|
|
FreeAndNil(FStyles);
|
|
FreeAndNil(FOptionsView);
|
|
FreeAndNil(FOptionsSelection);
|
|
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;
|
|
|
|
procedure TcxCustomGridView.AddListenerLink(ALink: Pointer);
|
|
begin
|
|
FListenerLinks.Add(ALink);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.RemoveListenerLink(ALink: Pointer);
|
|
begin
|
|
FListenerLinks.Remove(ALink);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.AssignPattern(APattern: TcxCustomGridView);
|
|
begin
|
|
FAssigningPattern := True;
|
|
try
|
|
Assign(APattern);
|
|
finally
|
|
FAssigningPattern := False;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.BeforeAssign(ASource: TcxCustomGridView);
|
|
begin
|
|
DataController.Assign(ASource.DataController);
|
|
end;
|
|
|
|
procedure TcxCustomGridView.DoAssign(ASource: TcxCustomGridView);
|
|
begin
|
|
with ASource do
|
|
begin
|
|
Self.BackgroundBitmaps := BackgroundBitmaps;
|
|
Self.DragMode := DragMode;
|
|
Self.OptionsSelection := OptionsSelection;
|
|
Self.OptionsView := OptionsView;
|
|
Self.Styles := Styles;
|
|
Self.OnDblClick := OnDblClick;
|
|
Self.OnDragDrop := OnDragDrop;
|
|
Self.OnDragOver := OnDragOver;
|
|
Self.OnEndDrag := OnEndDrag;
|
|
Self.OnKeyDown := OnKeyDown;
|
|
Self.OnKeyPress := OnKeyPress;
|
|
Self.OnKeyUp := OnKeyUp;
|
|
Self.OnMouseDown := OnMouseDown;
|
|
Self.OnMouseMove := OnMouseMove;
|
|
Self.OnMouseUp := OnMouseUp;
|
|
Self.OnMouseWheel := OnMouseWheel;
|
|
Self.OnMouseWheelDown := OnMouseWheelDown;
|
|
Self.OnMouseWheelUp := OnMouseWheelUp;
|
|
Self.OnStartDrag := OnStartDrag;
|
|
Self.Init;
|
|
end
|
|
end;
|
|
|
|
procedure TcxCustomGridView.AfterAssign(ASource: TcxCustomGridView);
|
|
begin
|
|
DataController.Assign(ASource.DataController);
|
|
end;
|
|
|
|
{procedure TcxCustomGridView.BeforeLevelChange;
|
|
begin
|
|
end;}
|
|
|
|
function TcxCustomGridView.CanFocus: Boolean;
|
|
begin
|
|
Result := GetCustomVisible((FLevel <> nil) and TcxGridLevel(FLevel).CanBeVisible);
|
|
end;
|
|
|
|
function TcxCustomGridView.CanTabStop: Boolean;
|
|
begin
|
|
Result := TcxCustomGridAccess(Control).TabStop;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.DetailVisibleChanged(ADetailLevel: TComponent;
|
|
APrevVisibleDetailCount, AVisibleDetailCount: Integer);
|
|
begin
|
|
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.IsDetailVisible(Self));
|
|
end;
|
|
|
|
function TcxCustomGridView.GetIsControlFocused: Boolean;
|
|
begin
|
|
Result := Control.IsFocused; {3}
|
|
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.FocusChanged(AFocused: Boolean);
|
|
begin
|
|
if AFocused then
|
|
begin
|
|
DataController.SetFocus;
|
|
Controller.SetFocus;
|
|
end
|
|
else
|
|
Controller.RemoveFocus;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.LoadingComplete;
|
|
begin
|
|
SizeChanged;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.LookAndFeelChanged;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to CloneCount - 1 do
|
|
Clones[I].LookAndFeelChanged;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.NotifyControl(AChangeKind: TcxGridViewChangeKind);
|
|
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;
|
|
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
|
|
end;
|
|
|
|
function TcxCustomGridView.GetViewInfoCacheClass: TcxCustomGridViewInfoCacheClass;
|
|
begin
|
|
Result := TcxCustomGridViewInfoCache;
|
|
end;
|
|
|
|
function TcxCustomGridView.GetBackgroundBitmapsClass: TcxCustomGridBackgroundBitmapsClass;
|
|
begin {4}
|
|
Result := TcxCustomGridBackgroundBitmaps;
|
|
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.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;
|
|
|
|
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.BeginUpdate;
|
|
begin
|
|
if Control <> nil then {5}
|
|
TcxCustomGrid(Control).BeginUpdate;
|
|
DataController.BeginUpdate;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.CancelUpdate;
|
|
begin
|
|
DataController.EndUpdate;
|
|
if Control <> nil then {5}
|
|
TcxCustomGrid(Control).CancelUpdate;
|
|
end;
|
|
|
|
function TcxCustomGridView.Changed(AGridChange: TObject): Boolean;
|
|
begin
|
|
Result := True;
|
|
if IsLoading or IsDestroying {or IsPattern} 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;
|
|
finally
|
|
if Control <> nil then {5}
|
|
TcxCustomGrid(Control).EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.BoundsChanged(AUpdateSelfOnly: Boolean = False;
|
|
AKeepMaster: Boolean = False);
|
|
begin
|
|
if ResizeOnBoundsChange then
|
|
SizeChanged(AUpdateSelfOnly, AKeepMaster)
|
|
else
|
|
LayoutChanged(AUpdateSelfOnly);
|
|
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;
|
|
|
|
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.RestoreFromIniFile(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
|
|
AStorage.RestoreFromIni(Self);
|
|
RestoringComplete;
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
finally
|
|
AStorage.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.RestoreFromRegistry(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
|
|
AStorage.RestoreFromRegistry(Self);
|
|
RestoringComplete;
|
|
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
|
|
AStorage.RestoreFromStream(Self);
|
|
RestoringComplete;
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
finally
|
|
AStorage.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxCustomGridView.StoreToIniFile(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(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;
|
|
|
|
{ functions }
|
|
|
|
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;
|
|
|
|
initialization
|
|
GridHitTests := TGridHitTests.Create;
|
|
cxGridRegisteredViews := TcxRegisteredClasses.Create(True);
|
|
|
|
finalization
|
|
FreeAndNil(cxGridRegisteredViews);
|
|
FreeAndNil(GridHitTests);
|
|
|
|
end.
|