Archivado/Componentes.Terceros.DevExpressVCL
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
f040ff20cd
Componentes.Terceros.DevExp.../internal/x.36/1/ExpressQuantumGrid 6/Sources/cxGridCustomTableView.pas
david 5678df5538 Versión x.36 oficial sin skins. 
git-svn-id: https://192.168.0.254/svn/Componentes.Terceros.DevExpressVCL@31 05c56307-c608-d34a-929d-697000501d7a
2008-09-04 11:31:51 +00:00

18820 lines
602 KiB
ObjectPascal
Raw Blame History

{********************************************************************}
{ }
{ Developer Express Visual Component Library }
{ ExpressQuantumGrid }
{ }
{ Copyright (c) 1998-2008 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 cxGridCustomTableView;
{$I cxVer.inc}
interface
uses
{$IFDEF DELPHI6}
Variants,
{$ENDIF}
Windows, Messages, Classes, Graphics, Controls, Forms, StdCtrls, Dialogs,
cxClasses, cxGraphics, cxControls, cxLookAndFeels, cxLookAndFeelPainters,
cxStorage, cxPC, cxFilterControl, cxNavigator, cxListBox, cxEdit, cxButtons,
cxDataStorage, cxCustomData, cxData, cxFilter, cxDataUtils, cxContainer,
cxCheckBox, cxCheckListBox, cxStyles, cxGridCommon, cxGridCustomView;
const
cxGridFilterDefaultItemMRUItemsListCount = 5;
cxGridFilterDefaultItemPopupMaxDropDownItemCount = 15;
cxGridFilterDefaultMRUItemsListCount = 10;
cxGridItemDefaultMinWidth = 20;
cxGridNavigatorDefaultOffset = 50;
htCustomGridTableBase = 100;
htFilter = htCustomGridTableBase + 1;
htFilterActivateButton = htCustomGridTableBase + 2;
htFilterCloseButton = htCustomGridTableBase + 3;
htFilterDropDownButton = htCustomGridTableBase + 4;
htFilterCustomizeButton = htCustomGridTableBase + 5;
htRecord = htCustomGridTableBase + 6;
htCell = htCustomGridTableBase + 7;
htExpandButton = htCustomGridTableBase + 8;
// record kind
rkNone = -1;
rkNormal = 0;
rkNewItem = 1;
isCustomItemFirst = 0;
isContent = isCustomItemFirst;
isCustomItemLast = isContent;
bbCustomTableFirst = bbCustomLast + 1;
bbContent = bbCustomTableFirst;
bbFilterBox = bbCustomTableFirst + 1;
bbCustomTableLast = bbFilterBox;
vsCustomTableFirst = vsCustomLast + 1;
vsContent = vsCustomTableFirst;
vsContentEven = vsCustomTableFirst + 1;
vsContentOdd = vsCustomTableFirst + 2;
vsFilterBox = vsCustomTableFirst + 3;
vsInactive = vsCustomTableFirst + 4;
vsIncSearch = vsCustomTableFirst + 5;
vsSelection = vsCustomTableFirst + 6;
vsCustomTableLast = vsSelection;
type
TcxGridItemDataBindingClass = class of TcxGridItemDataBinding;
TcxCustomGridDateRange = class;
TcxGridDateRanges = class;
TcxCustomGridRecord = class;
TcxCustomGridTableViewData = class;
TcxCustomGridTableItemsListBox = class;
TcxCustomGridTableCustomizationForm = class;
TcxGridFilterPopup = class;
TcxCustomGridTableController = class;
TcxCustomGridFilterButtonViewInfo = class;
TcxGridFilterActivateButtonViewInfo = class;
TcxGridFilterButtonsViewInfo = class;
TcxGridFilterViewInfo = class;
TcxGridTableDataCellViewInfo = class;
TcxCustomGridRecordViewInfoClass = class of TcxCustomGridRecordViewInfo;
TcxCustomGridRecordViewInfo = class;
TcxCustomGridRecordsViewInfo = class;
TcxCustomGridTableViewInfo = class;
TcxCustomGridTableViewInfoCacheItem = class;
TcxCustomGridTableItem = class;
TcxCustomGridTableDateTimeHandling = class;
TcxCustomGridTableFiltering = class;
TcxCustomGridTableView = class;
{ changes }
TcxGridDataChange = class(TcxCustomGridViewChange)
public
procedure Execute; override;
function IsLockable: Boolean; override;
end;
TcxGridRecordChange = class(TcxCustomGridViewChange)
private
FItem: TcxCustomGridTableItem;
FRecord: TcxCustomGridRecord;
FRecordIndex: Integer;
function GetGridView: TcxCustomGridTableView;
function GetRecordViewInfo: TcxCustomGridRecordViewInfo;
public
constructor Create(AGridView: TcxCustomGridView; ARecord: TcxCustomGridRecord;
ARecordIndex: Integer; AItem: TcxCustomGridTableItem = nil); reintroduce; virtual;
procedure Execute; override;
function IsCompatibleWith(AChange: TcxCustomGridChange): Boolean; override;
function IsEqual(AChange: TcxCustomGridChange): Boolean; override;
function IsItemVisible: Boolean;
property GridRecord: TcxCustomGridRecord read FRecord;
property GridView: TcxCustomGridTableView read GetGridView;
property Item: TcxCustomGridTableItem read FItem;
property RecordIndex: Integer read FRecordIndex;
property RecordViewInfo: TcxCustomGridRecordViewInfo read GetRecordViewInfo;
end;
TcxGridFocusedRecordChange = class(TcxCustomGridViewChange)
private
FFocusedRecordIndex: Integer;
FNewItemRecordFocusingChanged: Boolean;
FPrevFocusedRecordIndex: Integer;
public
constructor Create(AGridView: TcxCustomGridView;
APrevFocusedRecordIndex, AFocusedRecordIndex: Integer;
ANewItemRecordFocusingChanged: Boolean); reintroduce; virtual;
function CanExecuteWhenLocked: Boolean; override;
procedure Execute; override;
property FocusedRecordIndex: Integer read FFocusedRecordIndex;
property NewItemRecordFocusingChanged: Boolean read FNewItemRecordFocusingChanged;
property PrevFocusedRecordIndex: Integer read FPrevFocusedRecordIndex;
end;
{ hit tests }
TcxGridFilterHitTest = class(TcxCustomGridViewHitTest)
protected
class function GetHitTestCode: Integer; override;
end;
TcxGridFilterCloseButtonHitTest = class(TcxCustomGridViewHitTest)
protected
class function GetHitTestCode: Integer; override;
end;
TcxGridFilterActivateButtonHitTest = class(TcxCustomGridViewHitTest)
protected
class function GetHitTestCode: Integer; override;
end;
TcxGridFilterDropDownButtonHitTest = class(TcxCustomGridViewHitTest)
protected
class function GetHitTestCode: Integer; override;
end;
TcxGridFilterCustomizeButtonHitTest = class(TcxCustomGridViewHitTest)
protected
class function GetHitTestCode: Integer; override;
end;
TcxGridRecordHitTest = class(TcxCustomGridViewHitTest)
private
FGridRecordIndex: Integer;
FGridRecordKind: Integer;
FViewData: TcxCustomGridTableViewData;
function GetGridRecord: TcxCustomGridRecord;
procedure SetGridRecord(Value: TcxCustomGridRecord);
protected
class function GetHitTestCode: Integer; override;
public
class function CanClick: Boolean; virtual;
property GridRecord: TcxCustomGridRecord read GetGridRecord write SetGridRecord;
end;
TcxGridRecordCellHitTest = class(TcxGridRecordHitTest)
protected
class function GetHitTestCode: Integer; override;
public
Item: TcxCustomGridTableItem;
end;
TcxGridExpandButtonHitTest = class(TcxGridRecordHitTest)
protected
class function GetHitTestCode: Integer; override;
public
class function CanClick: Boolean; override;
end;
{ data definitions }
TcxGridDefaultValuesProvider = class(TcxCustomEditDefaultValuesProvider)
public
function IsDisplayFormatDefined(AIsCurrencyValueAccepted: Boolean): Boolean; override;
end;
IcxGridDataController = interface
['{FEEE7E69-BD54-4B5D-BA0B-B6116B69C0CC}']
procedure CheckGridModeBufferCount;
function DoScroll(AForward: Boolean): Boolean;
function DoScrollPage(AForward: Boolean): Boolean;
function GetItemDataBindingClass: TcxGridItemDataBindingClass;
function GetItemDefaultValuesProviderClass: TcxCustomEditDefaultValuesProviderClass;
function GetNavigatorIsBof: Boolean;
function GetNavigatorIsEof: Boolean;
//function GetFilterPropertyValue(const AName: string; var AValue: Variant): Boolean;
function GetScrollBarPos: Integer;
function GetScrollBarRecordCount: Integer;
//function SetFilterPropertyValue(const AName: string; const AValue: Variant): Boolean;
function SetScrollBarPos(Value: Integer): Boolean;
end;
TcxGridDataController = class(TcxDataController,
IcxCustomGridDataController, IcxGridDataController)
private
FLoadedData: TMemoryStream;
function GetGridViewValue: TcxCustomGridTableView;
procedure ReadData(Stream: TStream);
procedure WriteData(Stream: TStream);
protected
{ IcxCustomGridDataController }
procedure AssignData(ADataController: TcxCustomDataController);
procedure CreateAllItems(AMissingItemsOnly: Boolean);
procedure DeleteAllItems;
procedure GetFakeComponentLinks(AList: TList);
function GetGridView: TcxCustomGridView;
function HasAllItems: Boolean;
function IsDataChangeable: Boolean;
function IsDataLinked: Boolean;
function SupportsCreateAllItems: Boolean;
{ IcxGridDataController }
procedure CheckGridModeBufferCount;
function DoScroll(AForward: Boolean): Boolean;
function DoScrollPage(AForward: Boolean): Boolean;
//function GetFilterPropertyValue(const AName: string; var AValue: Variant): Boolean;
function GetItemDataBindingClass: TcxGridItemDataBindingClass;
function GetItemDefaultValuesProviderClass: TcxCustomEditDefaultValuesProviderClass;
function GetNavigatorIsBof: Boolean;
function GetNavigatorIsEof: Boolean;
function GetScrollBarPos: Integer;
function GetScrollBarRecordCount: Integer;
//function SetFilterPropertyValue(const AName: string; const AValue: Variant): Boolean;
function SetScrollBarPos(Value: Integer): Boolean;
function CanSelectRow(ARowIndex: Integer): Boolean; override;
function CompareByField(ARecordIndex1, ARecordIndex2: Integer;
AField: TcxCustomDataField; AMode: TcxDataControllerComparisonMode): Integer; override;
procedure DefineProperties(Filer: TFiler); override;
procedure DoValueTypeClassChanged(AItemIndex: Integer); override;
procedure FilterChanged; override;
function GetDefaultActiveRelationIndex: Integer; override;
function GetFilterDisplayText(ARecordIndex, AItemIndex: Integer): string; override;
//function GetIncrementalSearchText(ARecordIndex, AItemIndex: Integer): string; override;
function GetItemID(AItem: TObject): Integer; override;
function GetSortingBySummaryEngineClass: TcxSortingBySummaryEngineClass; override;
function GetSummaryGroupItemLinkClass: TcxDataSummaryGroupItemLinkClass; override;
function GetSummaryItemClass: TcxDataSummaryItemClass; override;
public
procedure BeginFullUpdate; override;
procedure EndFullUpdate; override;
function CreateDetailLinkObject(ARelation: TcxCustomDataRelation;
ARecordIndex: Integer): TObject; override;
procedure FocusControl(AItemIndex: Integer; var Done: Boolean); override;
function GetDetailDataControllerByLinkObject(ALinkObject: TObject): TcxCustomDataController; override;
function GetDisplayText(ARecordIndex, AItemIndex: Integer): string; override;
function GetFilterDataValue(ARecordIndex: Integer; AField: TcxCustomDataField): Variant; override;
function GetFilterItemFieldCaption(AItem: TObject): string; override;
function GetItem(Index: Integer): TObject; override;
function GetItemSortByDisplayText(AItemIndex: Integer; ASortByDisplayText: Boolean): Boolean; override;
function GetItemValueSource(AItemIndex: Integer): TcxDataEditValueSource; override;
procedure Loaded; override;
procedure UpdateData; override;
property GridView: TcxCustomGridTableView read GetGridViewValue;
published
property Filter;
property Options;
property Summary;
property OnAfterCancel;
property OnAfterDelete;
property OnAfterInsert;
property OnAfterPost;
property OnBeforeCancel;
property OnBeforeDelete;
property OnBeforeInsert;
property OnBeforePost;
property OnNewRecord;
property OnCompare;
property OnDataChanged;
property OnDetailCollapsing;
property OnDetailCollapsed;
property OnDetailExpanding;
property OnDetailExpanded;
property OnFilterRecord;
property OnGroupingChanged;
property OnRecordChanged;
property OnSortingChanged;
end;
TcxGridFilterValueListClass = class of TcxGridFilterValueList;
TcxGridFilterValueList = class(TcxDataFilterValueList)
protected
procedure AddDateTimeAbsoluteFilters(ADateRange: TcxCustomGridDateRange;
AIgnoreTime: Boolean); overload; virtual;
procedure AddDateTimeAbsoluteFilters(AItem: TcxCustomGridTableItem); overload; virtual;
procedure AddDateTimeRelativeFilters(AItem: TcxCustomGridTableItem); virtual;
function SupportedSpecialOperatorKinds: TcxFilterOperatorKinds; virtual;
public
procedure ApplyFilter(AItem: TcxCustomGridTableItem; AIndex: Integer;
AFilterList: TcxFilterCriteriaItemList; AReplaceExistent, AAddToMRUItemsList: Boolean);
function GetIndexByCriteriaItem(ACriteriaItem: TcxFilterCriteriaItem): Integer; override;
procedure Load(AItem: TcxCustomGridTableItem; AInitSortByDisplayText: Boolean = True;
AUseFilteredValues: Boolean = False); reintroduce; virtual;
end;
TcxGridFilterMRUValueItem = class(TcxMRUItem)
public
Value: Variant;
DisplayText: string;
constructor Create(const AValue: Variant; const ADisplayText: string);
function Equals(AItem: TcxMRUItem): Boolean; override;
end;
TcxGridFilterMRUValueItemsClass = class of TcxGridFilterMRUValueItems;
TcxGridFilterMRUValueItems = class(TcxMRUItems)
private
function GetItem(Index: Integer): TcxGridFilterMRUValueItem;
public
procedure Add(const AValue: Variant; const ADisplayText: string);
procedure AddItemsTo(AValueList: TcxGridFilterValueList);
property Items[Index: Integer]: TcxGridFilterMRUValueItem read GetItem; default;
end;
TcxGridItemDataBinding = class(TPersistent)
private
FData: TObject;
FDefaultValuesProvider: TcxCustomEditDefaultValuesProvider;
FItem: TcxCustomGridTableItem;
FFilterMRUValueItems: TcxGridFilterMRUValueItems;
function GetDataController: TcxCustomDataController;
function GetFilter: TcxDataFilterCriteria;
function GetFilterCriteriaItem: TcxFilterCriteriaItem;
function GetFiltered: Boolean;
function GetGridView: TcxCustomGridTableView;
function GetValueType: string;
function GetValueTypeClass: TcxValueTypeClass;
procedure SetData(Value: TObject);
procedure SetFiltered(Value: Boolean);
procedure SetValueType(const Value: string);
procedure SetValueTypeClass(Value: TcxValueTypeClass);
protected
function GetDefaultValuesProviderClass: TcxCustomEditDefaultValuesProviderClass;
function GetDefaultValueTypeClass: TcxValueTypeClass; virtual;
function GetFilterFieldName: string; virtual;
function GetFilterMRUValueItemsClass: TcxGridFilterMRUValueItemsClass; virtual;
procedure Init; virtual;
function IsValueTypeStored: Boolean; virtual;
property DefaultValuesProvider: TcxCustomEditDefaultValuesProvider read FDefaultValuesProvider;
public
constructor Create(AItem: TcxCustomGridTableItem); virtual;
destructor Destroy; override;
procedure Assign(Source: TPersistent); override;
function DefaultCaption: string; virtual;
function DefaultRepositoryItem: TcxEditRepositoryItem; virtual;
function DefaultWidth(ATakeHeaderIntoAccount: Boolean = True): Integer; virtual;
function GetDefaultValuesProvider(AProperties: TcxCustomEditProperties = nil): IcxEditDefaultValuesProvider;
function IsDisplayFormatDefined(AIsCurrencyValueAccepted: Boolean): Boolean;
function AddToFilter(AParent: TcxFilterCriteriaItemList; AOperatorKind: TcxFilterOperatorKind;
const AValue: Variant; const ADisplayText: string = '';
AReplaceExistent: Boolean = True): TcxFilterCriteriaItem;
procedure GetFilterDisplayText(const AValue: Variant; var ADisplayText: string);
procedure GetFilterStrings(AStrings: TStrings; AValueList: TcxGridFilterValueList);
procedure GetFilterValues(AValueList: TcxGridFilterValueList; AValuesOnly: Boolean = True;
AInitSortByDisplayText: Boolean = False; ACanUseFilteredValues: Boolean = False);
procedure GetFilterActiveValueIndexes(AValueList: TcxGridFilterValueList;
var AIndexes: TcxGridIndexes);
procedure SetFilterActiveValueIndexes(AValueList: TcxGridFilterValueList;
const AIndexes: TcxGridIndexes);
property Data: TObject read FData write SetData;
property DataController: TcxCustomDataController read GetDataController;
property Filter: TcxDataFilterCriteria read GetFilter;
property FilterCriteriaItem: TcxFilterCriteriaItem read GetFilterCriteriaItem;
property Filtered: Boolean read GetFiltered write SetFiltered;
property FilterFieldName: string read GetFilterFieldName;
property FilterMRUValueItems: TcxGridFilterMRUValueItems read FFilterMRUValueItems;
property GridView: TcxCustomGridTableView read GetGridView;
property Item: TcxCustomGridTableItem read FItem;
property ValueTypeClass: TcxValueTypeClass read GetValueTypeClass write SetValueTypeClass;
published
property ValueType: string read GetValueType write SetValueType stored IsValueTypeStored;
end;
{ view data }
// date ranges
TcxCustomGridDateRangeClass = class of TcxCustomGridDateRange;
TcxCustomGridDateRange = class
private
FContainer: TcxGridDateRanges;
function GetIndex: Integer;
procedure SetIndex(Value: Integer);
public
destructor Destroy; override;
function Contains(const ADate: TDateTime): Boolean; virtual; abstract;
function GetDisplayText(const ADate: TDateTime): string; virtual; abstract;
function GetRangeValue(const ADate: TDateTime; AIgnoreTime: Boolean): Variant; virtual;
function GetSortingValue(const ADate: TDateTime): Variant; virtual;
function GetValue(const ADate: TDateTime): Variant; virtual; abstract;
function NeedsSortingByTime: Boolean; virtual;
function NeedsTime: Boolean; virtual;
property Container: TcxGridDateRanges read FContainer;
property Index: Integer read GetIndex write SetIndex;
end;
TcxGridHourRange = class(TcxCustomGridDateRange)
public
function Contains(const ADate: TDateTime): Boolean; override;
function GetDisplayText(const ADate: TDateTime): string; override;
function GetValue(const ADate: TDateTime): Variant; override;
function NeedsSortingByTime: Boolean; override;
end;
TcxGridDayRange = class(TcxCustomGridDateRange)
public
function Contains(const ADate: TDateTime): Boolean; override;
function GetDisplayText(const ADate: TDateTime): string; override;
function GetValue(const ADate: TDateTime): Variant; override;
end;
TcxGridMonthRange = class(TcxCustomGridDateRange)
public
function Contains(const ADate: TDateTime): Boolean; override;
function GetDisplayText(const ADate: TDateTime): string; override;
function GetRangeValue(const ADate: TDateTime; AIgnoreTime: Boolean): Variant; override;
function GetValue(const ADate: TDateTime): Variant; override;
end;
TcxGridYearRange = class(TcxCustomGridDateRange)
public
function Contains(const ADate: TDateTime): Boolean; override;
function GetDisplayText(const ADate: TDateTime): string; override;
function GetRangeValue(const ADate: TDateTime; AIgnoreTime: Boolean): Variant; override;
function GetValue(const ADate: TDateTime): Variant; override;
end;
TcxGridYesterdayRange = class(TcxCustomGridDateRange)
public
function Contains(const ADate: TDateTime): Boolean; override;
function GetDisplayText(const ADate: TDateTime): string; override;
function GetValue(const ADate: TDateTime): Variant; override;
end;
TcxGridTodayRange = class(TcxCustomGridDateRange)
public
function Contains(const ADate: TDateTime): Boolean; override;
function GetDisplayText(const ADate: TDateTime): string; override;
function GetValue(const ADate: TDateTime): Variant; override;
end;
TcxGridTomorrowRange = class(TcxCustomGridDateRange)
public
function Contains(const ADate: TDateTime): Boolean; override;
function GetDisplayText(const ADate: TDateTime): string; override;
function GetValue(const ADate: TDateTime): Variant; override;
end;
TcxGridLastWeekRange = class(TcxCustomGridDateRange)
public
function Contains(const ADate: TDateTime): Boolean; override;
function GetDisplayText(const ADate: TDateTime): string; override;
function GetValue(const ADate: TDateTime): Variant; override;
end;
TcxGridThisWeekRange = class(TcxCustomGridDateRange)
public
function Contains(const ADate: TDateTime): Boolean; override;
function GetDisplayText(const ADate: TDateTime): string; override;
function GetValue(const ADate: TDateTime): Variant; override;
end;
TcxGridNextWeekRange = class(TcxCustomGridDateRange)
public
function Contains(const ADate: TDateTime): Boolean; override;
function GetDisplayText(const ADate: TDateTime): string; override;
function GetValue(const ADate: TDateTime): Variant; override;
end;
TcxGridLastMonthRange = class(TcxCustomGridDateRange)
public
function Contains(const ADate: TDateTime): Boolean; override;
function GetDisplayText(const ADate: TDateTime): string; override;
function GetValue(const ADate: TDateTime): Variant; override;
end;
TcxGridThisMonthRange = class(TcxCustomGridDateRange)
public
function Contains(const ADate: TDateTime): Boolean; override;
function GetDisplayText(const ADate: TDateTime): string; override;
function GetValue(const ADate: TDateTime): Variant; override;
end;
TcxGridNextMonthRange = class(TcxCustomGridDateRange)
public
function Contains(const ADate: TDateTime): Boolean; override;
function GetDisplayText(const ADate: TDateTime): string; override;
function GetValue(const ADate: TDateTime): Variant; override;
end;
TcxGridLastYearRange = class(TcxCustomGridDateRange)
public
function Contains(const ADate: TDateTime): Boolean; override;
function GetDisplayText(const ADate: TDateTime): string; override;
function GetValue(const ADate: TDateTime): Variant; override;
end;
TcxGridThisYearRange = class(TcxCustomGridDateRange)
public
function Contains(const ADate: TDateTime): Boolean; override;
function GetDisplayText(const ADate: TDateTime): string; override;
function GetValue(const ADate: TDateTime): Variant; override;
end;
TcxGridNextYearRange = class(TcxCustomGridDateRange)
public
function Contains(const ADate: TDateTime): Boolean; override;
function GetDisplayText(const ADate: TDateTime): string; override;
function GetValue(const ADate: TDateTime): Variant; override;
end;
TcxGridDateTimeFilter = (dtfRelativeDays, dtfRelativeDayPeriods, dtfRelativeWeeks,
dtfRelativeMonths, dtfRelativeYears, dtfPastFuture, dtfMonths, dtfYears);
TcxGridDateTimeFilters = set of TcxGridDateTimeFilter;
TcxGridDateTimeGrouping = (dtgDefault, dtgByDateAndTime, dtgRelativeToToday,
dtgByHour, dtgByDate, dtgByMonth, dtgByYear);
TcxGridDateRangesClass = class of TcxGridDateRanges;
TcxGridDateRanges = class
private
FDateTimeHandling: TcxCustomGridTableDateTimeHandling;
FItems: TList;
FStartOfThisWeek: TDateTime;
FThisDay: Word;
FThisMonth: Word;
FThisMonthNumber: Integer;
FThisYear: Word;
FToday: TDateTime;
function GetCount: Integer;
function GetItem(Index: Integer): TcxCustomGridDateRange;
protected
procedure AddItem(AItem: TcxCustomGridDateRange);
procedure RemoveItem(AItem: TcxCustomGridDateRange);
function GetItemIndex(AItem: TcxCustomGridDateRange): Integer;
procedure SetItemIndex(AItem: TcxCustomGridDateRange; AValue: Integer);
procedure InitConsts; virtual;
public
constructor Create; virtual;
destructor Destroy; override;
procedure Add(ARange: TcxCustomGridDateRange); overload;
procedure Add(ARangeClass: TcxCustomGridDateRangeClass); overload;
procedure Clear;
function GetRange(const ADate: TDateTime): TcxCustomGridDateRange; overload;
function GetRange(ARangeClass: TcxCustomGridDateRangeClass): TcxCustomGridDateRange; overload;
procedure Init(ADateTimeHandling: TcxCustomGridTableDateTimeHandling); virtual;
function IsEmpty: Boolean;
function NeedSortingByTime: Boolean;
function NeedTime: Boolean;
property Count: Integer read GetCount;
property Items[Index: Integer]: TcxCustomGridDateRange read GetItem; default;
property DateTimeHandling: TcxCustomGridTableDateTimeHandling read FDateTimeHandling;
property StartOfThisWeek: TDateTime read FStartOfThisWeek;
property ThisDay: Word read FThisDay;
property ThisMonth: Word read FThisMonth;
property ThisMonthNumber: Integer read FThisMonthNumber;
property ThisYear: Word read FThisYear;
property Today: TDateTime read FToday;
end;
TcxGridFilteringDateRangesClass = class of TcxGridFilteringDateRanges;
TcxGridFilteringDateRanges = class(TcxGridDateRanges)
public
procedure Init(ADateTimeHandling: TcxCustomGridTableDateTimeHandling;
ADateTimeFilters: TcxGridDateTimeFilters); reintroduce; virtual;
end;
TcxGridGroupingDateRangesClass = class of TcxGridGroupingDateRanges;
TcxGridGroupingDateRanges = class(TcxGridDateRanges)
public
procedure Init(ADateTimeHandling: TcxCustomGridTableDateTimeHandling;
ADateTimeGrouping: TcxGridDateTimeGrouping); reintroduce; virtual;
end;
// record
TcxCustomGridRecordClass = class of TcxCustomGridRecord;
TcxCustomGridRecord = class
private
//FData: Pointer;
FIndex: Integer;
FViewData: TcxCustomGridTableViewData;
FViewInfo: TcxCustomGridRecordViewInfo;
function GetController: TcxCustomGridTableController;
function GetDataController: TcxCustomDataController;
function GetDragHighlighted: Boolean;
function GetFocused: Boolean;
function GetGridView: TcxCustomGridTableView;
function GetIsEditing: Boolean;
function GetIsNewItemRecord: Boolean;
function GetIsValid: Boolean;
function GetLastParentRecordCount: Integer;
function GetLevel: Integer;
function GetPartVisible: Boolean;
function GetRecordIndex: Integer;
procedure SetExpanded(Value: Boolean);
procedure SetFocused(Value: Boolean);
protected
RecordInfo: TcxRowInfo;
procedure RefreshRecordInfo; virtual;
procedure DoCollapse(ARecurse: Boolean); virtual;
procedure DoExpand(ARecurse: Boolean); virtual;
//function GetDestroyingOnExpanding: Boolean; virtual;
function GetExpandable: Boolean; virtual;
function GetExpanded: Boolean; virtual;
procedure ToggleExpanded; virtual;
function GetHasCells: Boolean; virtual;
function GetIsData: Boolean; virtual;
function GetIsFirst: Boolean; virtual;
function GetIsLast: Boolean; virtual;
function GetIsParent: Boolean; virtual;
function GetIsParentRecordLast(AIndex: Integer): Boolean;
function GetParentRecord: TcxCustomGridRecord; virtual;
function GetSelected: Boolean; virtual;
function GetVisible: Boolean; virtual;
procedure SetSelected(Value: Boolean); virtual;
function GetDisplayText(Index: Integer): string; virtual;
function GetValueCount: Integer; virtual;
function GetValue(Index: Integer): Variant; virtual;
procedure SetDisplayText(Index: Integer; const Value: string); virtual;
procedure SetValue(Index: Integer; const Value: Variant); virtual;
procedure KeyDown(var Key: Word; Shift: TShiftState); virtual;
function GetViewInfoCacheItemClass: TcxCustomGridViewInfoCacheItemClass; virtual; abstract;
function GetViewInfoClass: TcxCustomGridRecordViewInfoClass; virtual; abstract;
property IsParent: Boolean read GetIsParent;
property IsParentRecordLast[AIndex: Integer]: Boolean read GetIsParentRecordLast;
property IsValid: Boolean read GetIsValid;
property LastParentRecordCount: Integer read GetLastParentRecordCount;
property Controller: TcxCustomGridTableController read GetController;
property DataController: TcxCustomDataController read GetDataController;
//property DestroyingOnExpanding: Boolean read GetDestroyingOnExpanding;
public
constructor Create(AViewData: TcxCustomGridTableViewData; AIndex: Integer;
const ARecordInfo: TcxRowInfo); virtual;
destructor Destroy; override;
function CanFocus: Boolean; virtual;
function CanFocusCells: Boolean; virtual;
procedure Collapse(ARecurse: Boolean);
procedure Expand(ARecurse: Boolean);
function GetFirstFocusableChild: TcxCustomGridRecord; virtual;
function GetLastFocusableChild(ARecursive: Boolean): TcxCustomGridRecord; virtual;
procedure Invalidate(AItem: TcxCustomGridTableItem = nil); virtual;
procedure MakeVisible;
//property Data: Pointer read FData write FData;
property DragHighlighted: Boolean read GetDragHighlighted;
property DisplayTexts[Index: Integer]: string read GetDisplayText write SetDisplayText;
property Expandable: Boolean read GetExpandable;
property Expanded: Boolean read GetExpanded write SetExpanded;
property Focused: Boolean read GetFocused write SetFocused;
property GridView: TcxCustomGridTableView read GetGridView;
property HasCells: Boolean read GetHasCells;
property Index: Integer read FIndex;
property IsData: Boolean read GetIsData;
property IsEditing: Boolean read GetIsEditing;
property IsFirst: Boolean read GetIsFirst;
property IsLast: Boolean read GetIsLast;
property IsNewItemRecord: Boolean read GetIsNewItemRecord;
property Level: Integer read GetLevel;
property ParentRecord: TcxCustomGridRecord read GetParentRecord;
property PartVisible: Boolean read GetPartVisible;
property RecordIndex: Integer read GetRecordIndex;
property Selected: Boolean read GetSelected write SetSelected;
property ValueCount: Integer read GetValueCount;
property Values[Index: Integer]: Variant read GetValue write SetValue;
property ViewData: TcxCustomGridTableViewData read FViewData;
property ViewInfo: TcxCustomGridRecordViewInfo read FViewInfo;
property Visible: Boolean read GetVisible;
end;
// view data
TcxGridDataOperation = (doSorting, doGrouping, doFiltering);
TcxCustomGridTableViewData = class(TcxCustomGridViewData)
private
FEditingRecord: TcxCustomGridRecord;
FNewItemRecord: TcxCustomGridRecord;
FRecords: TList;
function GetController: TcxCustomGridTableController;
function GetEditingRecord: TcxCustomGridRecord;
function GetGridView: TcxCustomGridTableView;
function GetInternalRecord(Index: Integer): TcxCustomGridRecord;
function GetRecord(Index: Integer): TcxCustomGridRecord;
function GetRecordCount: Integer;
function GetViewInfo: TcxCustomGridTableViewInfo;
function CreateRecord(AIndex: Integer): TcxCustomGridRecord;
protected
function GetFilterValueListClass: TcxGridFilterValueListClass; virtual;
function GetRecordByKind(AKind, AIndex: Integer): TcxCustomGridRecord; virtual;
function GetRecordClass(ARecordInfo: TcxRowInfo): TcxCustomGridRecordClass; virtual; abstract;
function GetRecordKind(ARecord: TcxCustomGridRecord): Integer; virtual;
procedure AssignEditingRecord;
procedure CreateNewItemRecord;
procedure DestroyNewItemRecord;
function GetNewItemRecordClass: TcxCustomGridRecordClass; virtual;
procedure RecreateNewItemRecord;
property Controller: TcxCustomGridTableController read GetController;
property InternalRecords[Index: Integer]: TcxCustomGridRecord read GetInternalRecord;
property ViewInfo: TcxCustomGridTableViewInfo read GetViewInfo;
public
constructor Create(AGridView: TcxCustomGridView); override;
destructor Destroy; override;
procedure Collapse(ARecurse: Boolean); virtual;
procedure DestroyRecords;
procedure Expand(ARecurse: Boolean); virtual;
function GetRecordByIndex(AIndex: Integer): TcxCustomGridRecord;
function GetRecordByRecordIndex(ARecordIndex: Integer): TcxCustomGridRecord;
function GetRecordIndexByRecord(ARecord: TcxCustomGridRecord): Integer;
function IsRecordIndexValid(AIndex: Integer): Boolean;
procedure Refresh(ARecordCount: Integer); virtual;
procedure RefreshRecords;
procedure CheckNewItemRecord;
function HasNewItemRecord: Boolean; virtual;
function AddItemToFilter(AParent: TcxFilterCriteriaItemList; AItem: TcxCustomGridTableItem;
AOperatorKind: TcxFilterOperatorKind; const AValue: Variant; ADisplayText: string = '';
AReplaceExistent: Boolean = True): TcxFilterCriteriaItem;
function CreateFilterValueList: TcxGridFilterValueList;
function GetDisplayText(ARecordIndex, AItemIndex: Integer; out AText: string;
AUseCustomValue: Boolean = False; ACustomValueOperation: TcxGridDataOperation = doGrouping): Boolean; virtual;
// custom data handling
function CustomCompareDataValues(AField: TcxCustomDataField; const AValue1, AValue2: Variant;
AMode: TcxDataControllerComparisonMode): Integer; virtual;
function GetCustomDataDisplayText(ARecordIndex, AItemIndex: Integer;
AOperation: TcxGridDataOperation): string; virtual;
function GetCustomDataValue(AField: TcxCustomDataField; const AValue: Variant;
AOperation: TcxGridDataOperation): Variant; overload;
function GetCustomDataValue(AItem: TcxCustomGridTableItem; const AValue: Variant;
AOperation: TcxGridDataOperation): Variant; overload; virtual;
function HasCustomDataHandling(AField: TcxCustomDataField; AOperation: TcxGridDataOperation): Boolean; overload;
function HasCustomDataHandling(AItem: TcxCustomGridTableItem; AOperation: TcxGridDataOperation): Boolean; overload; virtual;
function NeedsCustomDataComparison(AField: TcxCustomDataField; AMode: TcxDataControllerComparisonMode): Boolean; virtual;
property EditingRecord: TcxCustomGridRecord read FEditingRecord;
property GridView: TcxCustomGridTableView read GetGridView;
property NewItemRecord: TcxCustomGridRecord read FNewItemRecord;
property RecordCount: Integer read GetRecordCount;
property Records[Index: Integer]: TcxCustomGridRecord read GetRecord;
end;
{ controller }
// drag&drop objects
TcxCustomGridTableMovingObject = class(TcxCustomGridMovingObject)
private
function GetController: TcxCustomGridTableController;
function GetCustomizationForm: TcxCustomGridTableCustomizationForm;
protected
procedure DragAndDrop(const P: TPoint; var Accepted: Boolean); override;
property Controller: TcxCustomGridTableController read GetController;
property CustomizationForm: TcxCustomGridTableCustomizationForm read GetCustomizationForm;
end;
TcxGridItemContainerKind = Integer;
TcxGridItemContainerZone = class
public
ItemIndex: Integer;
constructor Create(AItemIndex: Integer);
function IsEqual(Value: TcxGridItemContainerZone): Boolean; virtual;
end;
TcxCustomGridTableItemMovingObject = class(TcxCustomGridTableMovingObject)
private
FDestItemContainerKind: TcxGridItemContainerKind;
FDestZone: TcxGridItemContainerZone;
FSourceItemContainerKind: TcxGridItemContainerKind;
procedure SetDestItemContainerKind(Value: TcxGridItemContainerKind);
procedure SetDestZone(Value: TcxGridItemContainerZone);
protected
procedure CalculateDestParams(AHitTest: TcxCustomGridHitTest;
out AContainerKind: TcxGridItemContainerKind; out AZone: TcxGridItemContainerZone); virtual;
procedure CheckDestItemContainerKind(var AValue: TcxGridItemContainerKind); virtual;
function GetCustomizationFormListBox: TcxCustomGridItemsListBox; override;
function IsSourceCustomizationForm: Boolean; override;
procedure BeginDragAndDrop; override;
procedure DragAndDrop(const P: TPoint; var Accepted: Boolean); override;
procedure EndDragAndDrop(Accepted: Boolean); override;
property DestItemContainerKind: TcxGridItemContainerKind read FDestItemContainerKind
write SetDestItemContainerKind;
property DestZone: TcxGridItemContainerZone read FDestZone write SetDestZone;
property SourceItemContainerKind: TcxGridItemContainerKind read FSourceItemContainerKind
write FSourceItemContainerKind;
public
constructor Create(AControl: TcxControl); override;
destructor Destroy; override;
end;
// customization form
TcxCustomGridTableItemsListBoxClass = class of TcxCustomGridTableItemsListBox;
TcxCustomGridTableItemsListBox = class(TcxCustomGridItemsListBox)
private
function GetGridView: TcxCustomGridTableView;
protected
procedure RefreshItemsAsTableItems;
property GridView: TcxCustomGridTableView read GetGridView;
end;
TcxCustomGridTableCustomizationForm = class(TcxCustomGridCustomizationForm)
private
FItemsListBox: TcxCustomGridTableItemsListBox;
FItemsPage: TcxTabSheet;
protected
procedure CreateControls; override;
function GetItemsListBoxClass: TcxCustomGridTableItemsListBoxClass; virtual;
function GetItemsPageCaption: string; virtual; abstract;
function GetItemsPageVisible: Boolean; virtual;
procedure InitPageControl; override;
property ItemsListBox: TcxCustomGridTableItemsListBox read FItemsListBox;
public
procedure RefreshData; override;
property ItemsPage: TcxTabSheet read FItemsPage;
end;
// popups
IcxGridFilterPopupOwner = interface(IcxCustomGridPopupOwner)
['{1FC070B2-36E5-4388-B22D-1FF5D240E95F}']
function GetItem: TcxCustomGridTableItem;
end;
TcxGridFilterPopupListBox = class(TcxGridPopupListBox)
private
function GetPopup: TcxGridFilterPopup;
protected
function CanHaveCheck(AItemIndex: Integer): Boolean; override;
procedure DrawItemContent(ACanvas: TcxCanvas; AIndex: Integer; ARect: TRect;
AState: TOwnerDrawState); override;
function HasCheck(AItemIndex: Integer): Boolean; override;
public
property Popup: TcxGridFilterPopup read GetPopup;
end;
TcxGridFilterPopupClass = class of TcxGridFilterPopup;
TcxGridFilterPopup = class(TcxCustomGridPopup)
private
FButton: TcxButton;
FFilterChangedByCheck: Boolean;
FItem: TcxCustomGridTableItem;
FListBox: TcxGridFilterPopupListBox;
FListBoxItems: TStringList;
FValueList: TcxGridFilterValueList;
function GetFilter: TcxDataFilterCriteria;
function GetGridView: TcxCustomGridTableView;
//function GetOwnerValue: IcxGridFilterPopupOwner;
//procedure SetOwnerValue(Value: IcxGridFilterPopupOwner);
procedure SetFilterChangedByCheck(Value: Boolean);
procedure ButtonClicked(Sender: TObject);
procedure ListBoxAction(Sender: TcxGridPopupListBox; AItemIndex: Integer);
protected
procedure AddListBoxItems; virtual;
procedure AdjustListBoxSize; virtual;
procedure ApplyFilterUsingCheckedItems(const AItemIndexes: TcxGridIndexes); virtual;
procedure ApplyFilterUsingClickedItem(AItemIndex: Integer); virtual;
function GetImmediateFilterUsingChecks: Boolean; virtual;
function GetListBoxCheckedItemIndexes: TcxGridIndexes; virtual;
function GetSelectedItemIndex: Integer; virtual;
procedure InitButton; virtual;
procedure InitListBox; virtual;
procedure InitPopup; override;
function IsButtonVisible: Boolean; virtual;
function IsCheck(AItemIndex: Integer): Boolean; virtual;
function IsMRUItemsListSeparator(AItemIndex: Integer): Boolean;
function SupportsChecks: Boolean; virtual;
procedure UpdateButtonEnabled; virtual;
property Button: TcxButton read FButton;
property Filter: TcxDataFilterCriteria read GetFilter;
property FilterChangedByCheck: Boolean read FFilterChangedByCheck write SetFilterChangedByCheck;
property ImmediateFilterUsingChecks: Boolean read GetImmediateFilterUsingChecks;
property ListBox: TcxGridFilterPopupListBox read FListBox;
property ListBoxItems: TStringList read FListBoxItems;
property SelectedItemIndex: Integer read GetSelectedItemIndex;
property ValueList: TcxGridFilterValueList read FValueList;
public
constructor Create(AGridView: TcxCustomGridView); override;
destructor Destroy; override;
procedure CloseUp; override;
property GridView: TcxCustomGridTableView read GetGridView;
property Item: TcxCustomGridTableItem read FItem;
// property Owner: IcxGridFilterPopupOwner read GetOwnerValue write SetOwnerValue;
end;
TcxGridFilterMRUItemsPopupClass = class of TcxGridFilterMRUItemsPopup;
TcxGridFilterMRUItemsPopup = class(TcxCustomGridPopup)
private
FListBox: TcxGridPopupListBox;
function GetFiltering: TcxCustomGridTableFiltering;
function GetGridView: TcxCustomGridTableView;
procedure ListBoxAction(Sender: TcxGridPopupListBox; AItemIndex: Integer);
protected
procedure AddFilterMRUItems(AStrings: TStrings); virtual;
procedure ApplyFilterMRUItem(AItemIndex: Integer); virtual;
function GetTextOffsetHorz: Integer; virtual;
procedure InitPopup; override;
property Filtering: TcxCustomGridTableFiltering read GetFiltering;
property ListBox: TcxGridPopupListBox read FListBox;
public
constructor Create(AGridView: TcxCustomGridView); override;
property GridView: TcxCustomGridTableView read GetGridView;
property TextOffsetHorz: Integer read GetTextOffsetHorz;
end;
TcxCustomGridCustomizationPopup = class(TcxCustomGridPopup)
private
FCheckListBox: TcxCheckListBox;
FDragItemIndex: Integer;
FScrollDirection: TcxDirection;
FScrollTimer: TcxTimer;
function GetGridView: TcxCustomGridTableView;
procedure SetScrollDirection(Value: TcxDirection);
procedure CheckListBoxClick(Sender: TObject);
procedure CheckListBoxCheckClick(Sender: TObject; AIndex: Integer;
APrevState, ANewState: TcxCheckBoxState);
procedure CheckListBoxEndDrag(Sender, Target: TObject; X, Y: Integer);
procedure CheckListBoxKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
procedure CheckListBoxMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure CheckListBoxStartDrag(Sender: TObject; var DragObject: TDragObject);
procedure CheckListBoxDragOver(Sender, Source: TObject; X, Y: Integer;
State: TDragState; var Accept: Boolean);
procedure CheckListBoxDragDrop(Sender, Source: TObject; X, Y: Integer);
procedure ScrollTimerHandler(Sender: TObject);
protected
procedure AddCheckListBoxItems; virtual; abstract;
procedure AdjustCheckListBoxSize(AFixedHeight: Boolean = False); virtual;
procedure CheckClicked(AIndex: Integer; AChecked: Boolean); virtual;
procedure CreateCheckListBox; virtual;
function GetCheckListBoxColumnWidth: Integer; virtual;
function GetDropDownCount: Integer; virtual; abstract;
function GetItemInsertionIndex(X, Y: Integer): Integer;
procedure InitPopup; override;
procedure RefreshCheckListBoxItems;
function SupportsItemMoving: Boolean; virtual; abstract;
procedure GetCheckListBoxSelectedItems(AItems: TList);
procedure SetCheckListBoxSelectedItems(AItems: TList);
procedure ItemClicked(AItem: TObject; AChecked: Boolean); virtual; abstract;
function GetItemIndex(AItem: TObject): Integer; virtual; abstract;
procedure SetItemIndex(AItem: TObject; AIndex: Integer); virtual; abstract;
property CheckListBoxColumnWidth: Integer read GetCheckListBoxColumnWidth;
property DragItemIndex: Integer read FDragItemIndex write FDragItemIndex;
property ScrollDirection: TcxDirection read FScrollDirection write SetScrollDirection;
public
constructor Create(AGridView: TcxCustomGridView); override;
procedure CloseUp; override;
procedure CorrectBoundsWithDesktopWorkArea(var APosition: TPoint); override;
procedure Popup; override;
property CheckListBox: TcxCheckListBox read FCheckListBox;
property GridView: TcxCustomGridTableView read GetGridView;
end;
TcxCustomGridItemsCustomizationPopupClass = class of TcxCustomGridItemsCustomizationPopup;
TcxCustomGridItemsCustomizationPopup = class(TcxCustomGridCustomizationPopup)
protected
procedure AddCheckListBoxItems; override;
function GetDropDownCount: Integer; override;
function SupportsItemMoving: Boolean; override;
procedure ItemClicked(AItem: TObject; AChecked: Boolean); override;
function GetItemIndex(AItem: TObject): Integer; override;
procedure SetItemIndex(AItem: TObject; AIndex: Integer); override;
end;
// controllers
TcxGridEditingControllerClass = class of TcxGridEditingController;
TcxGridEditingController = class
private
FController: TcxCustomGridTableController;
FEdit: TcxCustomEdit;
FEditHiding: Boolean;
FEditingItem: TcxCustomGridTableItem;
FEditingItemSetting: Boolean;
FEditList: TcxInplaceEditList;
FEditPreparing: Boolean;
FEditShowingTimer: TcxTimer;
FEditShowingTimerItem: TcxCustomGridTableItem;
FEditUpdateNeeded: Boolean;
FInitiatingEditing: Boolean;
FIsEditPlaced: Boolean;
FIsErrorOnEditExit: Boolean;
FPrevEditOnChange: TNotifyEvent;
FPrevEditOnEditValueChanged: TNotifyEvent;
function GetEditingProperties: TcxCustomEditProperties;
function GetGridView: TcxCustomGridTableView;
function GetIsEditing: Boolean;
procedure SetEditingItem(Value: TcxCustomGridTableItem);
procedure EditShowingTimerHandler(Sender: TObject);
protected
procedure AfterViewInfoCalculate; virtual;
procedure BeforeViewInfoCalculate; virtual;
procedure CancelEditUpdatePost;
function CanInitEditing: Boolean; virtual;
function CanRemoveEditFocus: Boolean; virtual;
function CanUpdateEditValue: Boolean; virtual;
procedure CheckEdit;
procedure CheckEditUpdatePost;
procedure DoEditChanged; virtual;
procedure DoEditKeyDown(var Key: Word; Shift: TShiftState); virtual;
procedure DoUpdateEdit;
function GetHideEditOnExit: Boolean; virtual;
function GetHideEditOnFocusedRecordChange: Boolean; virtual;
procedure InitEdit; virtual;
procedure UninitEdit; virtual;
procedure PostEditingData; virtual;
procedure PostEditUpdate;
function PrepareEdit(AItem: TcxCustomGridTableItem; AOnMouseEvent: Boolean): Boolean; virtual;
procedure UpdateEditValue;
procedure UpdateValue;
procedure AssignEditEvents; virtual;
procedure UnassignEditEvents; virtual;
procedure EditAfterKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState); virtual;
procedure EditChanged(Sender: TObject); virtual;
procedure EditEditing(Sender: TObject; var CanEdit: Boolean); virtual;
procedure EditExit(Sender: TObject); virtual;
procedure EditFocusChanged(Sender: TObject); virtual;
procedure EditKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState); virtual;
procedure EditKeyPress(Sender: TObject; var Key: Char); virtual;
procedure EditKeyUp(Sender: TObject; var Key: Word; Shift: TShiftState); virtual;
procedure EditPostEditValue(Sender: TObject); virtual;
procedure EditValueChanged(Sender: TObject); virtual;
property EditHiding: Boolean read FEditHiding;
property EditingProperties: TcxCustomEditProperties read GetEditingProperties;
property EditList: TcxInplaceEditList read FEditList;
property EditPreparing: Boolean read FEditPreparing;
property EditUpdateNeeded: Boolean read FEditUpdateNeeded;
property HideEditOnExit: Boolean read GetHideEditOnExit;
property HideEditOnFocusedRecordChange: Boolean read GetHideEditOnFocusedRecordChange;
property InitiatingEditing: Boolean read FInitiatingEditing;
property IsEditPlaced: Boolean read FIsEditPlaced;
property IsErrorOnEditExit: Boolean read FIsErrorOnEditExit;
public
constructor Create(AController: TcxCustomGridTableController); virtual;
destructor Destroy; override;
procedure HideEdit(Accept: Boolean); virtual;
procedure RemoveEdit(AProperties: TcxCustomEditProperties); virtual;
procedure ShowEdit(AItem: TcxCustomGridTableItem = nil); overload;
procedure ShowEdit(AItem: TcxCustomGridTableItem; Key: Char); overload;
procedure ShowEdit(AItem: TcxCustomGridTableItem; Shift: TShiftState; X, Y: Integer); overload;
procedure UpdateEdit;
procedure StartEditShowingTimer(AItem: TcxCustomGridTableItem);
procedure StopEditShowingTimer;
property Controller: TcxCustomGridTableController read FController;
property Edit: TcxCustomEdit read FEdit;
property EditingItem: TcxCustomGridTableItem read FEditingItem write SetEditingItem;
property GridView: TcxCustomGridTableView read GetGridView;
property IsEditing: Boolean read GetIsEditing;
end;
TcxGridDragOpenInfoExpand = class(TcxCustomGridDragOpenInfo)
public
GridRecord: TcxCustomGridRecord;
constructor Create(AGridRecord: TcxCustomGridRecord); virtual;
function Equals(AInfo: TcxCustomGridDragOpenInfo): Boolean; override;
procedure Run; override;
end;
TcxCustomGridTableCanItemFocus = function(AOwner: TcxCustomGridTableView;
AItemIndex: Integer; AData: TObject): Boolean;
TcxCustomGridTableController = class(TcxCustomGridController)
private
FAllowAppendRecord: Boolean;
FAllowCheckEdit: Boolean;
FBlockRecordKeyboardHandling: Boolean;
FCheckEditNeeded: Boolean;
FCheckingCoordinate: Boolean;
FClickedCellViewInfo: TcxGridTableDataCellViewInfo;
FDragDropText: string;
FDragScrollDirection: TcxDirection;
FDragScrollTimer: TcxTimer;
FDragHighlightedRecord: TcxCustomGridRecord;
FEatKeyPress: Boolean;
FEditingController: TcxGridEditingController;
FFilterMRUItemsPopup: TcxGridFilterMRUItemsPopup;
FFilterPopup: TcxGridFilterPopup;
FFocusedItem: TcxCustomGridTableItem;
FFocusOnRecordFocusing: Boolean;
FForcingWidthItem: TcxCustomGridTableItem;
FGridModeBufferCountUpdateNeeded: Boolean;
FGridModeBufferCountUpdateTimer: TcxTimer;
FIsPullFocusing: Boolean;
FIsReadyForImmediateEditing: Boolean;
FIsRecordUnselecting: Boolean;
FItemsCustomizationPopup: TcxCustomGridItemsCustomizationPopup;
FMovingItem: TcxCustomGridTableItem;
FPullFocusingItem: TcxCustomGridTableItem;
FPullFocusingMousePos: TPoint;
FPullFocusingOriginHitTest: TcxCustomGridHitTest;
FPullFocusingRecordId: Variant;
FPullFocusingScrollingDirection: TcxDirection;
FPullFocusingScrollingTimer: TcxTimer;
FScrollDirection: TcxDirection;
FScrollTimer: TcxTimer;
FTopRecordIndex: Integer;
FUnselectingRecordIndex: Integer;
function GetEditingItem: TcxCustomGridTableItem;
function GetFilterMRUItemsPopup: TcxGridFilterMRUItemsPopup;
function GetFilterPopup: TcxGridFilterPopup;
function GetFocusedItemIndex: Integer;
function GetFocusedRecordIndex: Integer;
function GetGridView: TcxCustomGridTableView;
function GetIncSearchingItem: TcxCustomGridTableItem;
function GetIncSearchingText: string;
function GetIsEditing: Boolean;
function GetIsIncSearching: Boolean;
function GetIsItemMoving: Boolean;
function GetItemsCustomizationPopup: TcxCustomGridItemsCustomizationPopup;
function GetMasterController: TcxCustomGridTableController;
function GetMultiSelect: Boolean;
function GetNewItemRecordFocused: Boolean;
function GetSelectedRecord(Index: Integer): TcxCustomGridRecord;
function GetSelectedRecordCount: Integer;
function GetViewData: TcxCustomGridTableViewData;
function GetViewInfo: TcxCustomGridTableViewInfo;
procedure SetDragHighlightedRecord(Value: TcxCustomGridRecord);
procedure SetEditingItem(Value: TcxCustomGridTableItem);
procedure SetFocusedItem(Value: TcxCustomGridTableItem);
procedure SetFocusedItemIndex(Value: Integer);
procedure SetFocusedRecordIndex(Value: Integer);
procedure SetIncSearchingText(const Value: string);
procedure SetInternalTopRecordIndex(Value: Integer);
procedure SetNewItemRecordFocused(Value: Boolean);
procedure SetScrollDirection(Value: TcxDirection);
procedure SetTopRecordIndex(Value: Integer);
procedure DragScrollTimerHandler(Sender: TObject);
procedure GridModeBufferCountUpdateTimerHandler(Sender: TObject);
procedure PullFocusingScrollingTimerHandler(Sender: TObject);
procedure CreateScrollTimer;
procedure DestroyScrollTimer;
procedure ScrollTimerHandler(Sender: TObject);
protected
procedure AfterPaint; override;
procedure BeforePaint; override;
function CanFocusOnClick(X, Y: Integer): Boolean; override;
procedure DetailFocused(ADetail: TcxCustomGridView); override;
procedure DoEnter; override;
procedure DoExit; override;
function MayFocus: Boolean; override;
procedure RemoveFocus; override;
procedure SetFocus(ANotifyMaster: Boolean); override;
procedure AfterOffset; virtual;
procedure BeforeKillFocus; override;
procedure BeforeOffset; virtual;
function CanAppend(ACheckOptions: Boolean): Boolean; virtual;
procedure CancelCheckEditPost;
function CanDelete(ACheckOptions: Boolean): Boolean; virtual;
function CanEdit: Boolean; virtual;
procedure CheckCoordinates; override;
function CanHScrollBarHide: Boolean; virtual;
function CanInsert(ACheckOptions: Boolean): Boolean; virtual;
procedure CheckEdit; virtual;
procedure CheckTopRecordIndex(var Value: Integer); virtual;
function FindNextCustomItem(AFocusedItemIndex, AItemCount: Integer;
AGoForward, AGoOnCycle: Boolean; ACanFocus: TcxCustomGridTableCanItemFocus;
AData: TObject; var AItemIndex: Integer; out ACycleChanged: Boolean): Boolean;
procedure FocusedItemChanged(APrevFocusedItem: TcxCustomGridTableItem); virtual;
procedure FocusedRecordChanged(APrevFocusedRecordIndex, AFocusedRecordIndex: Integer;
ANewItemRecordFocusingChanged: Boolean); virtual;
function GetCancelEditingOnExit: Boolean; virtual;
function GetFilterMRUItemsPopupClass: TcxGridFilterMRUItemsPopupClass; virtual;
function GetFilterPopupClass: TcxGridFilterPopupClass; virtual;
function GetFocusedRecord: TcxCustomGridRecord; virtual;
function GetIsRecordsScrollHorizontal: Boolean; virtual; abstract;
function GetItemsCustomizationPopupClass: TcxCustomGridItemsCustomizationPopupClass; virtual;
function GetMaxTopRecordIndexValue: Integer; virtual;
function GetPatternObject(AObject: TPersistent): TPersistent; override;
function GetScrollBarOffsetBegin: Integer; virtual;
function GetScrollBarOffsetEnd: Integer; virtual;
function GetScrollBarPos: Integer; virtual;
function GetScrollBarRecordCount: Integer; virtual;
function GetVisibleRecordCount(AFirstRecordIndex: Integer;
ACalculateDown: Boolean = True): Integer; virtual;
procedure PostCheckEdit;
procedure ProcessCheckEditPost;
procedure ScrollData(ADirection: TcxDirection); virtual;
procedure SetFocusedRecord(Value: TcxCustomGridRecord); virtual;
procedure SetScrollBarPos(Value: Integer); virtual;
procedure CancelGridModeBufferCountUpdate;
procedure CheckGridModeBufferCountUpdatePost;
procedure PostGridModeBufferCountUpdate;
property GridModeBufferCountUpdateNeeded: Boolean read FGridModeBufferCountUpdateNeeded;
// internal draganddrop data scrolling
function CanScrollData(ADirection: TcxDirection): Boolean; virtual;
function GetScrollDataTimeInterval(ADirection: TcxDirection): Integer; virtual;
property ScrollDirection: TcxDirection read FScrollDirection write SetScrollDirection;
// selection
function CanPostponeRecordSelection: Boolean; virtual;
function CanProcessMultiSelect(AIsKeyboard: Boolean): Boolean; overload; virtual;
function CanProcessMultiSelect(AHitTest: TcxCustomGridHitTest;
AShift: TShiftState): Boolean; overload; virtual;
function CanProcessMultiSelect(AKey: Word; AShift: TShiftState;
AFocusedRecordChanged: Boolean): Boolean; overload; virtual;
procedure ChangeRecordSelection(ARecord: TcxCustomGridRecord; Value: Boolean);
procedure CheckFocusedRecordSelectionWhenExit(ARecord: TcxCustomGridRecord);
procedure DoMouseNormalSelection(AHitTest: TcxCustomGridHitTest); virtual;
procedure DoMouseRangeSelection(AClearSelection: Boolean = True; AData: TObject = nil); virtual;
procedure DoNormalSelection; virtual;
procedure DoNormalSelectionWithAnchor(ASelect: Boolean = True);
procedure DoRangeSelection(AClearSelection: Boolean = True);
procedure DoToggleRecordSelection;
procedure FinishSelection; virtual;
procedure InvalidateFocusedRecord; virtual;
procedure InvalidateSelection; virtual;
function IsKeyForMultiSelect(AKey: Word; AShift: TShiftState;
AFocusedRecordChanged: Boolean): Boolean; virtual;
function IsRecordSelected(ARecord: TcxCustomGridRecord): Boolean;
procedure MultiSelectKeyDown(var Key: Word; Shift: TShiftState); virtual;
procedure MultiSelectMouseDown(AHitTest: TcxCustomGridHitTest; AShift: TShiftState); virtual;
procedure MultiSelectMouseUp(AHitTest: TcxCustomGridHitTest; AShift: TShiftState); virtual;
procedure SelectFocusedRecord;
procedure SetSelectionAnchor(AGridRecordIndex: Integer);
function SupportsAdditiveSelection: Boolean; virtual;
function SupportsRecordSelectionToggling: Boolean; virtual;
// navigation
function CanFocusNextItem(AFocusedItemIndex, ANextItemIndex: Integer;
AGoForward, AGoOnCycle, AGoToNextRecordOnCycle: Boolean): Boolean; virtual;
function FocusedRecordHasCells(ACheckCellSelectionAbility: Boolean): Boolean;
procedure FocusNextPage(ASyncSelection: Boolean); virtual;
procedure FocusPrevPage(ASyncSelection: Boolean); virtual;
function IsKeyForController(AKey: Word; AShift: TShiftState): Boolean; virtual;
procedure ScrollPage(AForward: Boolean); virtual;
procedure ScrollRecords(AForward: Boolean; ACount: Integer); virtual;
procedure ShowNextPage; virtual;
procedure ShowPrevPage; virtual;
// pull focusing
procedure DoPullFocusing(AHitTest: TcxGridRecordHitTest); virtual;
procedure DoPullFocusingScrolling(ADirection: TcxDirection); virtual;
function GetPullFocusingScrollingDirection(X, Y: Integer; out ADirection: TcxDirection): Boolean; virtual;
function IsPullFocusingPosChanged: Boolean;
procedure SavePullFocusingPos;
procedure StartPullFocusing(AHitTest: TcxCustomGridHitTest); virtual;
procedure StopPullFocusing;
procedure StartPullFocusingScrolling(ADirection: TcxDirection);
procedure StopPullFocusingScrolling;
function SupportsPullFocusing: Boolean; virtual;
property PullFocusingOriginHitTest: TcxCustomGridHitTest read FPullFocusingOriginHitTest;
// delphi drag and drop
function GetDragScrollDirection(X, Y: Integer): TcxDirection; virtual;
function GetDragScrollInterval: Integer; virtual;
function IsFirstRecordForDragScroll(ARecord: TcxCustomGridRecord): Boolean; virtual;
function IsLastRecordForDragScroll(ARecord: TcxCustomGridRecord): Boolean; virtual;
procedure ProcessDragFocusing(X, Y: Integer);
procedure StartDragScroll(ADirection: TcxDirection);
procedure StopDragScroll;
function IsDragScroll: Boolean;
//---
function GetDragOpenInfo(AHitTest: TcxCustomGridHitTest): TcxCustomGridDragOpenInfo; virtual;
function IsDragOpenHitTest(AHitTest: TcxCustomGridHitTest;
out ADragOpenInfo: TcxCustomGridDragOpenInfo): Boolean;
//---
property DragHighlightedRecord: TcxCustomGridRecord read FDragHighlightedRecord write SetDragHighlightedRecord;
// incsearching
function GetItemForIncSearching: TcxCustomGridTableItem; virtual;
procedure IncSearchKeyDown(var Key: Word; Shift: TShiftState); virtual;
property ItemForIncSearching: TcxCustomGridTableItem read GetItemForIncSearching;
function GetEditingControllerClass: TcxGridEditingControllerClass; virtual;
property AllowAppendRecord: Boolean read FAllowAppendRecord write FAllowAppendRecord;
property AllowCheckEdit: Boolean read FAllowCheckEdit write FAllowCheckEdit;
property BlockRecordKeyboardHandling: Boolean read FBlockRecordKeyboardHandling
write FBlockRecordKeyboardHandling;
property CancelEditingOnExit: Boolean read GetCancelEditingOnExit;
property EatKeyPress: Boolean read FEatKeyPress write FEatKeyPress;
property FocusOnRecordFocusing: Boolean read FFocusOnRecordFocusing write FFocusOnRecordFocusing;
property ForcingWidthItem: TcxCustomGridTableItem read FForcingWidthItem write FForcingWidthItem;
property InternalTopRecordIndex: Integer read FTopRecordIndex write SetInternalTopRecordIndex;
property IsReadyForImmediateEditing: Boolean read FIsReadyForImmediateEditing
write FIsReadyForImmediateEditing;
property IsRecordsScrollHorizontal: Boolean read GetIsRecordsScrollHorizontal;
property MultiSelect: Boolean read GetMultiSelect;
property ScrollBarOffsetBegin: Integer read GetScrollBarOffsetBegin;
property ScrollBarOffsetEnd: Integer read GetScrollBarOffsetEnd;
property ScrollBarRecordCount: Integer read GetScrollBarRecordCount;
property ScrollBarPos: Integer read GetScrollBarPos write SetScrollBarPos;
property ViewData: TcxCustomGridTableViewData read GetViewData;
property ViewInfo: TcxCustomGridTableViewInfo read GetViewInfo;
public
constructor Create(AGridView: TcxCustomGridView); override;
destructor Destroy; override;
procedure BeginDragAndDrop; override;
procedure ControlFocusChanged; override;
procedure DoCancelMode; override;
procedure DoKeyDown(var Key: Word; Shift: TShiftState); override;
procedure EndDragAndDrop(Accepted: Boolean); override;
function FindNextItem(AFocusedItemIndex: Integer;
AGoForward, AGoOnCycle: Boolean; out ACycleChanged: Boolean;
ARecord: TcxCustomGridRecord): Integer; virtual;
function FindNextRecord(AFocusedRecordIndex: Integer;
AGoForward, AGoOnCycle: Boolean; out ACycleChanged: Boolean): Integer;
function HasFilterMRUItemsPopup: Boolean;
function HasFilterPopup: Boolean;
function HasFocusedControls: Boolean; override;
function HasItemsCustomizationPopup: Boolean;
function IsClickableRecordHitTest(AHitTest: TcxCustomGridHitTest): Boolean;
function IsDataFullyVisible(AIsCallFromMaster: Boolean = False): Boolean; override;
procedure KeyDown(var Key: Word; Shift: TShiftState); override;
procedure KeyPress(var Key: Char); override;
procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;
procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
function ProcessDetailDialogChar(ADetail: TcxCustomGridView; ACharCode: Word): Boolean; override;
function ProcessDialogChar(ACharCode: Word): Boolean; override;
function SupportsTabAccelerators(AGridRecord: TcxCustomGridRecord): Boolean; virtual;
procedure BeforeStartDrag; override;
function CanDrag(X, Y: Integer): Boolean; override;
procedure DragDrop(Source: TObject; X, Y: Integer); override;
procedure DragOver(Source: TObject; X, Y: Integer; State: TDragState;
var Accept: Boolean); override;
procedure DrawDragImage(ACanvas: TcxCanvas; R: TRect); override;
procedure EndDrag(Target: TObject; X, Y: Integer); override;
function GetDragDropText(ADragObject: TDragObject): string; virtual;
procedure GetDragDropTextViewParams(out AParams: TcxViewParams); virtual;
function GetDragImagesSize: TPoint; override;
function HasDragImages: Boolean; override;
procedure StartDrag(var DragObject: TDragObject); override;
property DragDropText: string read FDragDropText;
procedure CancelIncSearching;
function CheckEditing(var AFocusedRecordIndex: Integer; AGoForward: Boolean): Boolean;
procedure CheckScrolling(const P: TPoint); virtual;
procedure ClearSelection; virtual;
procedure CreateNewRecord(AtEnd: Boolean); virtual;
procedure DeleteSelection; virtual;
function FocusFirstAvailableItem: Boolean;
function FocusNextCell(AGoForward: Boolean; AProcessCellsOnly: Boolean = True;
AAllowCellsCycle: Boolean = True): Boolean;
function FocusNextItem(AFocusedItemIndex: Integer;
AGoForward, AGoOnCycle, AGoToNextRecordOnCycle: Boolean): Boolean;
function FocusNextRecord(AFocusedRecordIndex: Integer;
AGoForward, AGoOnCycle, AGoIntoDetail, AGoOutOfDetail: Boolean): Boolean;
function FocusNextRecordWithSelection(AFocusedRecordIndex: Integer;
AGoForward, AGoOnCycle, AGoIntoDetail: Boolean; ASyncSelection: Boolean = True): Boolean;
function FocusRecord(AFocusedRecordIndex: Integer; ASyncSelection: Boolean): Boolean;
procedure MakeFocusedItemVisible;
procedure MakeFocusedRecordVisible;
procedure MakeItemVisible(AItem: TcxCustomGridTableItem); virtual; abstract;
procedure MakeRecordVisible(ARecord: TcxCustomGridRecord); virtual;
procedure SelectAll; virtual;
procedure SelectAllRecords;
function GoToFirst(ASyncSelection: Boolean = True): Boolean;
function GoToLast(AGoIntoDetail: Boolean; ASyncSelection: Boolean = True): Boolean;
function GoToNext(AGoIntoDetail: Boolean; ASyncSelection: Boolean = True): Boolean;
function GoToPrev(AGoIntoDetail: Boolean; ASyncSelection: Boolean = True): Boolean;
function IsFinish: Boolean;
function IsStart: Boolean;
property ClickedCellViewInfo: TcxGridTableDataCellViewInfo read FClickedCellViewInfo write FClickedCellViewInfo;
property EditingController: TcxGridEditingController read FEditingController;
property EditingItem: TcxCustomGridTableItem read GetEditingItem write SetEditingItem;
property FilterMRUItemsPopup: TcxGridFilterMRUItemsPopup read GetFilterMRUItemsPopup;
property FilterPopup: TcxGridFilterPopup read GetFilterPopup;
property FocusedItem: TcxCustomGridTableItem read FFocusedItem write SetFocusedItem;
property FocusedItemIndex: Integer read GetFocusedItemIndex write SetFocusedItemIndex;
property FocusedRecord: TcxCustomGridRecord read GetFocusedRecord write SetFocusedRecord;
property FocusedRecordIndex: Integer read GetFocusedRecordIndex write SetFocusedRecordIndex;
property GridView: TcxCustomGridTableView read GetGridView;
property IncSearchingItem: TcxCustomGridTableItem read GetIncSearchingItem;
property IncSearchingText: string read GetIncSearchingText write SetIncSearchingText;
property IsPullFocusing: Boolean read FIsPullFocusing;
property IsEditing: Boolean read GetIsEditing;
property IsIncSearching: Boolean read GetIsIncSearching;
property IsItemMoving: Boolean read GetIsItemMoving;
property ItemsCustomizationPopup: TcxCustomGridItemsCustomizationPopup read GetItemsCustomizationPopup;
property MasterController: TcxCustomGridTableController read GetMasterController;
property MovingItem: TcxCustomGridTableItem read FMovingItem;
property NewItemRecordFocused: Boolean read GetNewItemRecordFocused write SetNewItemRecordFocused;
property SelectedRecordCount: Integer read GetSelectedRecordCount;
property SelectedRecords[Index: Integer]: TcxCustomGridRecord read GetSelectedRecord;
property TopRecordIndex: Integer read FTopRecordIndex write SetTopRecordIndex;
end;
{ painters }
TcxCustomGridPartPainter = class(TcxCustomGridCellPainter);
// filter
TcxCustomGridFilterButtonPainter = class(TcxCustomGridCellPainter)
private
function GetViewInfo: TcxCustomGridFilterButtonViewInfo;
protected
function ExcludeFromClipRect: Boolean; override;
property ViewInfo: TcxCustomGridFilterButtonViewInfo read GetViewInfo;
end;
TcxGridFilterCloseButtonPainter = class(TcxCustomGridFilterButtonPainter)
protected
procedure DrawContent; override;
end;
TcxGridFilterActivateButtonPainter = class(TcxCustomGridFilterButtonPainter)
private
function GetViewInfo: TcxGridFilterActivateButtonViewInfo;
protected
procedure DrawContent; override;
property ViewInfo: TcxGridFilterActivateButtonViewInfo read GetViewInfo;
end;
TcxGridFilterDropDownButtonPainter = class(TcxCustomGridFilterButtonPainter)
protected
procedure DrawContent; override;
end;
TcxGridFilterCustomizeButtonPainter = class(TcxCustomGridFilterButtonPainter)
protected
procedure Paint; override;
end;
TcxGridFilterPainterClass = class of TcxGridFilterPainter;
TcxGridFilterPainter = class(TcxCustomGridPartPainter)
private
FTextWasUnderlined: Boolean;
function GetViewInfo: TcxGridFilterViewInfo;
protected
procedure DrawBackground(const R: TRect); override;
procedure DrawButtons; virtual;
function ExcludeFromClipRect: Boolean; override;
procedure Paint; override;
procedure PrepareCanvasForDrawText; override;
procedure UnprepareCanvasForDrawText; override;
property ViewInfo: TcxGridFilterViewInfo read GetViewInfo;
end;
// records
TcxGridTableDataCellPainterClass = class of TcxGridTableDataCellPainter;
TcxGridTableDataCellPainter = class(TcxCustomGridCellPainter)
private
function GetViewInfo: TcxGridTableDataCellViewInfo;
protected
procedure DrawContent; override;
procedure DrawFocusRect; virtual;
procedure Paint; override;
property ViewInfo: TcxGridTableDataCellViewInfo read GetViewInfo;
end;
TcxCustomGridRecordPainterClass = class of TcxCustomGridRecordPainter;
TcxCustomGridRecordPainter = class(TcxCustomGridCellPainter)
private
function GetViewInfo: TcxCustomGridRecordViewInfo;
protected
procedure AfterPaint; override;
procedure BeforePaint; override;
procedure DrawBackground; override;
procedure DrawExpandButton; virtual;
function DrawExpandButtonBeforePaint: Boolean; virtual;
procedure DrawFocusRect; virtual;
procedure Paint; override;
property ViewInfo: TcxCustomGridRecordViewInfo read GetViewInfo;
end;
TcxCustomGridRecordsPainterClass = class of TcxCustomGridRecordsPainter;
TcxCustomGridRecordsPainter = class
private
FCanvas: TcxCanvas;
FViewInfo: TcxCustomGridRecordsViewInfo;
protected
//procedure BeforePaint; virtual;
procedure Paint; virtual;
property Canvas: TcxCanvas read FCanvas;
property ViewInfo: TcxCustomGridRecordsViewInfo read FViewInfo;
public
constructor Create(ACanvas: TcxCanvas; AViewInfo: TcxCustomGridRecordsViewInfo); virtual;
procedure MainPaint;
end;
// view
TcxNavigatorSitePainter = class(TcxCustomGridCellPainter)
protected
function ExcludeFromClipRect: Boolean; override;
end;
TcxCustomGridTablePainter = class(TcxCustomGridPainter)
private
function GetController: TcxCustomGridTableController;
function GetViewInfo: TcxCustomGridTableViewInfo;
protected
function CanOffset(AItemsOffset, DX, DY: Integer): Boolean; virtual;
procedure DrawBackground; override;
procedure DrawFilterBar; virtual;
procedure DrawInfoText; virtual;
procedure DrawNavigator; virtual;
procedure DrawRecords; virtual;
procedure Offset(AItemsOffset: Integer); overload; virtual;
procedure Offset(DX, DY: Integer); overload; virtual;
procedure PaintBefore; override;
procedure PaintContent; override;
public
procedure DoOffset(AItemsOffset, DX, DY: Integer);
procedure DrawFocusRect(const R: TRect; AHideFocusRect: Boolean); override;
property Controller: TcxCustomGridTableController read GetController;
property ViewInfo: TcxCustomGridTableViewInfo read GetViewInfo;
end;
{ view infos }
// part
TcxGridPartAlignment = (gpaTop, gpaBottom);
TcxCustomGridPartViewInfo = class(TcxCustomGridViewCellViewInfo)
private
FHeight: Integer;
function GetGridView: TcxCustomGridTableView;
function GetGridViewInfo: TcxCustomGridTableViewInfo;
function GetIndex: Integer;
procedure SetIndex(Value: Integer);
protected
function CalculateBounds: TRect; virtual;
procedure CalculateInvisible; virtual;
procedure CalculateVisible; virtual;
function CustomDrawBackground(ACanvas: TcxCanvas): Boolean; override;
function GetAlignment: TcxGridPartAlignment; virtual; abstract;
//function GetHeight: Integer; override;
function GetIsAutoWidth: Boolean; virtual; abstract;
function GetIsPart: Boolean; virtual;
function GetIsScrollable: Boolean; virtual; abstract;
function GetPainterClass: TcxCustomGridCellPainterClass; override;
function HasCustomDrawBackground: Boolean; override;
procedure InitHitTest(AHitTest: TcxCustomGridHitTest); override;
property Height: Integer read FHeight write FHeight;
property IsPart: Boolean read GetIsPart;
public
constructor Create(AGridViewInfo: TcxCustomGridTableViewInfo); reintroduce; virtual;
destructor Destroy; override;
procedure MainCalculate;
property Alignment: TcxGridPartAlignment read GetAlignment;
property GridView: TcxCustomGridTableView read GetGridView;
property GridViewInfo: TcxCustomGridTableViewInfo read GetGridViewInfo;
property Index: Integer read GetIndex write SetIndex;
property IsAutoWidth: Boolean read GetIsAutoWidth;
property IsScrollable: Boolean read GetIsScrollable;
end;
// filter
TcxGridFilterButtonAlignment = (fbaLeft, fbaRight);
TcxCustomGridFilterButtonViewInfoClass = class of TcxCustomGridFilterButtonViewInfo;
TcxCustomGridFilterButtonViewInfo = class(TcxCustomGridViewCellViewInfo)
private
FContainer: TcxGridFilterButtonsViewInfo;
function GetFilter: TcxDataFilterCriteria;
function GetGridView: TcxCustomGridTableView;
protected
function CaptureMouseOnPress: Boolean; override;
function GetAlignment: TcxGridFilterButtonAlignment; virtual;
function GetCanvas: TcxCanvas; override;
function GetHotTrack: Boolean; override;
function GetVisible: Boolean; override;
property Container: TcxGridFilterButtonsViewInfo read FContainer;
property Filter: TcxDataFilterCriteria read GetFilter;
public
constructor Create(AContainer: TcxGridFilterButtonsViewInfo); reintroduce; virtual;
property Alignment: TcxGridFilterButtonAlignment read GetAlignment;
property GridView: TcxCustomGridTableView read GetGridView;
end;
TcxGridFilterCloseButtonViewInfo = class(TcxCustomGridFilterButtonViewInfo)
protected
function CalculateHeight: Integer; override;
function CalculateWidth: Integer; override;
procedure Click; override;
function GetHitTestClass: TcxCustomGridHitTestClass; override;
function GetPainterClass: TcxCustomGridCellPainterClass; override;
end;
TcxGridFilterActivateButtonViewInfo = class(TcxCustomGridFilterButtonViewInfo)
private
function GetChecked: Boolean;
protected
function CalculateHeight: Integer; override;
function CalculateWidth: Integer; override;
procedure Click; override;
function GetHitTestClass: TcxCustomGridHitTestClass; override;
function GetPainterClass: TcxCustomGridCellPainterClass; override;
public
property Checked: Boolean read GetChecked;
end;
TcxGridFilterDropDownButtonViewInfo = class(TcxCustomGridFilterButtonViewInfo)
private
function GetDropDownWindowValue: TcxGridFilterMRUItemsPopup;
protected
procedure BeforeStateChange; override;
function CalculateHeight: Integer; override;
function CalculateWidth: Integer; override;
function CaptureMouseOnPress: Boolean; override;
function GetAlignment: TcxGridFilterButtonAlignment; override;
function GetHitTestClass: TcxCustomGridHitTestClass; override;
function GetPainterClass: TcxCustomGridCellPainterClass; override;
function GetVisible: Boolean; override;
function DropDownWindowExists: Boolean; override;
function GetDropDownWindow: TcxCustomGridPopup; override;
function GetDropDownWindowOwnerBounds: TRect; override;
property DropDownWindow: TcxGridFilterMRUItemsPopup read GetDropDownWindowValue;
public
procedure Calculate(ALeftBound, ATopBound: Integer; AWidth: Integer = -1;
AHeight: Integer = -1); override;
end;
TcxGridFilterCustomizeButtonViewInfo = class(TcxCustomGridFilterButtonViewInfo)
protected
function CalculateHeight: Integer; override;
function CalculateWidth: Integer; override;
procedure Click; override;
function GetAlignment: TcxGridFilterButtonAlignment; override;
function GetAlignmentHorz: TAlignment; override;
function GetAlignmentVert: TcxAlignmentVert; override;
function GetBorders: TcxBorders; override;
function GetBorderWidth(AIndex: TcxBorder): Integer; override;
function GetHitTestClass: TcxCustomGridHitTestClass; override;
function GetPainterClass: TcxCustomGridCellPainterClass; override;
function GetText: string; override;
procedure GetViewParams(var AParams: TcxViewParams); override;
function GetVisible: Boolean; override;
end;
TcxGridFilterButtonsViewInfoClass = class of TcxGridFilterButtonsViewInfo;
TcxGridFilterButtonsViewInfo = class
private
FFilterViewInfo: TcxGridFilterViewInfo;
FItems: TList;
function GetCount: Integer;
function GetGridView: TcxCustomGridTableView;
function GetHeight: Integer;
function GetItem(Index: Integer): TcxCustomGridFilterButtonViewInfo;
function GetWidth(AAlignment: TcxGridFilterButtonAlignment): Integer;
function GetWidthLeftPart: Integer;
function GetWidthRightPart: Integer;
protected
FDropDownButtonViewInfo: TcxGridFilterDropDownButtonViewInfo;
procedure AddItems; virtual;
procedure DestroyItems; virtual;
property FilterViewInfo: TcxGridFilterViewInfo read FFilterViewInfo;
property GridView: TcxCustomGridTableView read GetGridView;
public
constructor Create(AFilterViewInfo: TcxGridFilterViewInfo); virtual;
destructor Destroy; override;
function AddItem(AItemClass: TcxCustomGridFilterButtonViewInfoClass): TcxCustomGridFilterButtonViewInfo;
procedure Calculate(const ABounds: TRect); virtual;
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; virtual;
property Count: Integer read GetCount;
property DropDownButtonViewInfo: TcxGridFilterDropDownButtonViewInfo read FDropDownButtonViewInfo;
property Height: Integer read GetHeight;
property Items[Index: Integer]: TcxCustomGridFilterButtonViewInfo read GetItem; default;
property WidthLeftPart: Integer read GetWidthLeftPart;
property WidthRightPart: Integer read GetWidthRightPart;
end;
TcxGridFilterViewInfoClass = class of TcxGridFilterViewInfo;
TcxGridFilterViewInfo = class(TcxCustomGridPartViewInfo)
private
FButtonsViewInfo: TcxGridFilterButtonsViewInfo;
function GetFilter: TcxDataFilterCriteria;
function GetFiltering: TcxCustomGridTableFiltering;
procedure CreateButtonsViewInfo;
procedure DestroyButtonsViewInfo;
protected
function CalculateButtonsViewInfoBounds: TRect; virtual;
function CalculateHeight: Integer; override;
function CalculateWidth: Integer; override;
function GetAlignment: TcxGridPartAlignment; override;
function GetAlignmentVert: TcxAlignmentVert; override;
function GetBackgroundBitmap: TBitmap; override;
function GetHitTestClass: TcxCustomGridHitTestClass; override;
function GetHotTrack: Boolean; override;
function GetIsAutoWidth: Boolean; override;
function GetIsCheck: Boolean; override;
function GetIsScrollable: Boolean; override;
function GetPainterClass: TcxCustomGridCellPainterClass; override;
function GetText: string; override;
function GetTextAreaBounds: TRect; override;
procedure GetViewParams(var AParams: TcxViewParams); override;
function GetVisible: Boolean; override;
function HasMouse(AHitTest: TcxCustomGridHitTest): Boolean; override;
function InvalidateOnStateChange: Boolean; override;
procedure StateChanged(APrevState: TcxGridCellState); override;
function GetButtonsViewInfoClass: TcxGridFilterButtonsViewInfoClass; virtual;
property Filter: TcxDataFilterCriteria read GetFilter;
property Filtering: TcxCustomGridTableFiltering read GetFiltering;
public
constructor Create(AGridViewInfo: TcxCustomGridTableViewInfo); override;
destructor Destroy; override;
procedure Calculate(ALeftBound, ATopBound: Integer; AWidth: Integer = -1;
AHeight: Integer = -1); override;
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; override;
property ButtonsViewInfo: TcxGridFilterButtonsViewInfo read FButtonsViewInfo;
end;
// cells
TcxGridTableCellViewInfo = class(TcxCustomGridViewCellViewInfo)
private
FRecordViewInfo: TcxCustomGridRecordViewInfo;
FSelected: Boolean;
FSelectedCalculated: Boolean;
function GetCacheItem: TcxCustomGridTableViewInfoCacheItem;
function GetController: TcxCustomGridTableController;
function GetGridView: TcxCustomGridTableView;
function GetGridRecord: TcxCustomGridRecord;
function GetSelected: Boolean;
protected
function CalculateSelected: Boolean; virtual;
function GetAlwaysSelected: Boolean; virtual;
function GetCanvas: TcxCanvas; override;
function GetGridViewInfo: TcxCustomGridTableViewInfo;
function GetHitTestClass: TcxCustomGridHitTestClass; override;
function GetTransparent: Boolean; override;
procedure InitHitTest(AHitTest: TcxCustomGridHitTest); override;
property AlwaysSelected: Boolean read GetAlwaysSelected;
property CacheItem: TcxCustomGridTableViewInfoCacheItem read GetCacheItem;
property Controller: TcxCustomGridTableController read GetController;
public
constructor Create(ARecordViewInfo: TcxCustomGridRecordViewInfo); reintroduce; virtual;
procedure Calculate(ALeftBound, ATopBound: Integer; AWidth: Integer = -1;
AHeight: Integer = -1); override;
function CanDrawSelected: Boolean; virtual;
function MouseDown(AHitTest: TcxCustomGridHitTest; AButton: TMouseButton;
AShift: TShiftState): Boolean; override;
property GridRecord: TcxCustomGridRecord read GetGridRecord;
property GridView: TcxCustomGridTableView read GetGridView;
property GridViewInfo: TcxCustomGridTableViewInfo read GetGridViewInfo;
property RecordViewInfo: TcxCustomGridRecordViewInfo read FRecordViewInfo;
property Selected: Boolean read GetSelected;
end;
TcxGridTableDataCellViewInfo = class(TcxGridTableCellViewInfo)
private
FEditViewData: TcxCustomEditViewData;
FEditViewInfo: TcxCustomEditViewInfo;
FIsLocalCopyOfEditViewData: Boolean;
FItem: TcxCustomGridTableItem;
FProperties: TcxCustomEditProperties;
FStyle: TcxEditStyle;
FWasFocusedBeforeClick: Boolean;
function GetEditing: Boolean;
function GetMousePos: TPoint;
function GetProperties: TcxCustomEditProperties;
function GetShowButtons: Boolean;
protected
procedure AfterCustomDraw(ACanvas: TcxCanvas); override;
procedure BeforeCustomDraw(ACanvas: TcxCanvas); override;
procedure CalculateEditViewInfo(AEditViewInfo: TcxCustomEditViewInfo;
const AMousePos: TPoint); virtual;
function CalculateHeight: Integer; override;
function CalculateSelected: Boolean; override;
function CanActivateEditOnMouseDown(AButton: TMouseButton): Boolean; virtual;
function CanShowEdit: Boolean; virtual;
procedure CheckEditHotTrack(const AMousePos: TPoint);
function CustomDraw(ACanvas: TcxCanvas): Boolean; override;
procedure DoCalculateParams; override;
procedure EditHotTrackChanged;
function GetAreaBounds: TRect; override;
function GetAutoHeight: Boolean; virtual;
function GetDisplayValue: TcxEditValue; virtual;
function GetEditBounds: TRect; virtual;
function GetEditViewDataBounds: TRect; virtual;
procedure GetEditViewDataContentOffsets(var R: TRect); virtual;
function GetFocused: Boolean; virtual;
function GetHitTestClass: TcxCustomGridHitTestClass; override;
function GetHotTrack: Boolean; override;
function GetMaxLineCount: Integer; virtual;
function GetMultiLine: Boolean; override;
function GetPainterClass: TcxCustomGridCellPainterClass; override;
function GetShowEndEllipsis: Boolean; override;
function GetText: string; override;
function GetValue: Variant; virtual;
procedure GetViewParams(var AParams: TcxViewParams); override;
function HasCustomDraw: Boolean; override;
function HasFocusRect: Boolean; virtual;
procedure InitHitTest(AHitTest: TcxCustomGridHitTest); override;
procedure InitTextSelection; virtual;
function InvalidateOnStateChange: Boolean; override;
function IsTextSelected: Boolean; virtual;
procedure MouseLeave; override;
procedure Offset(DX, DY: Integer); override;
procedure RestoreParams(const AParams: TcxViewParams); override;
procedure SaveParams(out AParams: TcxViewParams); override;
procedure StateChanged(APrevState: TcxGridCellState); override;
function SupportsZeroHeight: Boolean; virtual;
function CanShowAutoHint: Boolean; virtual;
function CanShowCustomHint: Boolean; virtual;
function CanShowHint: Boolean; override;
function GetCellBoundsForHint: TRect; override;
function NeedShowHint(const AMousePos: TPoint; out AHintText: TCaption;
out AIsHintMultiLine: Boolean; out ATextRect: TRect): Boolean; override;
function UseStandardNeedShowHint: Boolean; virtual;
procedure InitStyle; virtual;
function CreateEditViewInfo: TcxCustomEditViewInfo;
procedure CreateEditViewData;
procedure DestroyEditViewData;
property EditViewData: TcxCustomEditViewData read FEditViewData;
procedure UpdateEdit;
property AutoHeight: Boolean read GetAutoHeight;
property EditViewDataBounds: TRect read GetEditViewDataBounds;
property MaxLineCount: Integer read GetMaxLineCount;
property MousePos: TPoint read GetMousePos;
property ShowButtons: Boolean read GetShowButtons;
property WasFocusedBeforeClick: Boolean read FWasFocusedBeforeClick;
public
constructor Create(ARecordViewInfo: TcxCustomGridRecordViewInfo;
AItem: TcxCustomGridTableItem); reintroduce; virtual;
destructor Destroy; override;
procedure BeforeRecalculation; override;
procedure Calculate(ALeftBound, ATopBound: Integer; AWidth: Integer = -1;
AHeight: Integer = -1); override;
function CanDrawSelected: Boolean; override;
function GetInplaceEditPosition: TcxInplaceEditPosition;
procedure Invalidate(ARecalculate: Boolean); reintroduce; virtual;
function MouseDown(AHitTest: TcxCustomGridHitTest; AButton: TMouseButton;
AShift: TShiftState): Boolean; override;
function MouseMove(AHitTest: TcxCustomGridHitTest; AShift: TShiftState): Boolean; override;
function MouseUp(AHitTest: TcxCustomGridHitTest; AButton: TMouseButton;
AShift: TShiftState): Boolean; override;
property DisplayValue: TcxEditValue read GetDisplayValue;
//property Edit: TcxCustomEdit read GetEdit;
property EditBounds: TRect read GetEditBounds;
property Editing: Boolean read GetEditing;
property EditViewInfo: TcxCustomEditViewInfo read FEditViewInfo;
property Focused: Boolean read GetFocused;
property Item: TcxCustomGridTableItem read FItem;
property Properties: TcxCustomEditProperties read GetProperties;
property Style: TcxEditStyle read FStyle;
property Value: Variant read GetValue;
end;
// records
TcxCustomGridRecordViewInfo = class(TcxCustomGridViewCellViewInfo)
private
FExpandButtonBounds: TRect;
FExpanded: Boolean;
FExpandedCalculated: Boolean;
FIsRecordViewInfoAssigned: Boolean;
FRecordsViewInfo: TcxCustomGridRecordsViewInfo;
FSelected: Boolean;
FSelectedCalculated: Boolean;
function GetCacheItem: TcxCustomGridTableViewInfoCacheItem;
function GetExpanded: Boolean;
function GetFocused: Boolean;
function GetGridView: TcxCustomGridTableView;
function GetGridViewInfo: TcxCustomGridTableViewInfo;
function GetIndex: Integer;
function GetSelected: Boolean;
protected
FRecord: TcxCustomGridRecord;
procedure CalculateExpandButtonBounds(var ABounds: TRect); virtual; abstract;
function CalculateSelected: Boolean; virtual;
function CanGenerateExpandButtonHitTest: Boolean; virtual;
procedure ControlFocusChanged; virtual;
function GetAutoHeight: Boolean; virtual;
function GetBackgroundBitmap: TBitmap; override;
function GetBackgroundBitmapBounds: TRect; virtual;
function GetCanvas: TcxCanvas; override;
function GetCellTransparent(ACell: TcxGridTableCellViewInfo): Boolean; virtual;
function GetContentBounds: TRect; virtual;
function GetExpandButtonAreaBounds: TRect; virtual;
function GetFocusRectBounds: TRect; virtual;
function GetHeight: Integer; override;
function GetHideFocusRectOnExit: Boolean; virtual;
function GetHitTestClass: TcxCustomGridHitTestClass; override;
function GetVisible: Boolean; override;
function HasFocusRect: Boolean; virtual;
procedure InitHitTest(AHitTest: TcxCustomGridHitTest); override;
function IsClickHitTest(AHitTest: TcxCustomGridHitTest): Boolean; virtual;
function IsDetailVisible(ADetail: TcxCustomGridView): Boolean; virtual;
procedure Offset(DX, DY: Integer); override;
procedure VisibilityChanged(AVisible: Boolean); virtual;
property AutoHeight: Boolean read GetAutoHeight;
property BackgroundBitmapBounds: TRect read GetBackgroundBitmapBounds;
property CacheItem: TcxCustomGridTableViewInfoCacheItem read GetCacheItem;
property ExpandButtonAreaBounds: TRect read GetExpandButtonAreaBounds;
property Expanded: Boolean read GetExpanded;
public
constructor Create(ARecordsViewInfo: TcxCustomGridRecordsViewInfo;
ARecord: TcxCustomGridRecord); reintroduce; virtual;
destructor Destroy; override;
procedure BeforeRecalculation; override;
function Click(AHitTest: TcxCustomGridHitTest; AButton: TMouseButton;
AShift: TShiftState): Boolean; reintroduce; virtual;
function GetBoundsForInvalidate(AItem: TcxCustomGridTableItem): TRect; virtual;
function GetBoundsForItem(AItem: TcxCustomGridTableItem): TRect; virtual;
function GetCellViewInfoByItem(AItem: TcxCustomGridTableItem): TcxGridTableDataCellViewInfo; virtual;
{procedure GetDataCellViewParams(AItem: TcxCustomGridTableItem;
ACellViewInfo: TcxGridTableCellViewInfo; var AParams: TcxViewParams); virtual;}
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; override;
procedure MainCalculate(ALeftBound, ATopBound: Integer); virtual;
function MouseDown(AHitTest: TcxCustomGridHitTest; AButton: TMouseButton;
AShift: TShiftState): Boolean; override;
function ProcessDialogChar(ACharCode: Word): Boolean; virtual;
procedure Recalculate;
property ContentBounds: TRect read GetContentBounds;
property ExpandButtonBounds: TRect read FExpandButtonBounds;
property Focused: Boolean read GetFocused;
property FocusRectBounds: TRect read GetFocusRectBounds;
property GridView: TcxCustomGridTableView read GetGridView;
property GridRecord: TcxCustomGridRecord read FRecord;
property GridViewInfo: TcxCustomGridTableViewInfo read GetGridViewInfo;
property Index: Integer read GetIndex;
property HideFocusRectOnExit: Boolean read GetHideFocusRectOnExit;
property RecordsViewInfo: TcxCustomGridRecordsViewInfo read FRecordsViewInfo;
property Selected: Boolean read GetSelected;
end;
TcxCustomGridRecordsViewInfoClass = class of TcxCustomGridRecordsViewInfo;
TcxCustomGridRecordsViewInfo = class
private
FBackgroundBitmap: TBitmap;
FBounds: TRect;
FContentBounds: TRect;
FGridViewInfo: TcxCustomGridTableViewInfo;
FIncSearchingCellViewInfo: TcxGridTableDataCellViewInfo;
FIsIncSearchingCellViewInfoCalculated: Boolean;
FItems: TList;
FItemsOffset: Integer;
function GetCanvas: TcxCanvas;
function GetController: TcxCustomGridTableController;
function GetCount: Integer;
function GetFirstRecordIndex: Integer;
function GetGridView: TcxCustomGridTableView;
function GetIncSearchingCellViewInfo: TcxGridTableDataCellViewInfo;
function GetItem(Index: Integer): TcxCustomGridRecordViewInfo;
function GetMaxCount: Integer;
function GetTopRecordIndex: Integer;
function GetViewData: TcxCustomGridTableViewData;
procedure CreateItems;
procedure DestroyItems;
function CreateRecordViewInfo(AIndex: Integer): TcxCustomGridRecordViewInfo;
protected
FVisibleCount: Integer;
procedure AfterCalculate; virtual;
procedure BeforeCalculate; virtual;
procedure BeforeItemRecalculation; virtual;
procedure AfterOffset; virtual;
procedure BeforeOffset; virtual;
procedure Calculate; virtual;
function CalculateBounds: TRect; virtual;
function CalculateContentBounds: TRect; virtual;
function CalculateIncSearchingCellViewInfo: TcxGridTableDataCellViewInfo; virtual;
procedure CalculateVisibleCount; virtual;
procedure CreateEditViewDatas;
procedure DestroyEditViewDatas;
function GetAreaBoundsForCell(ACellViewInfo: TcxGridTableDataCellViewInfo): TRect; virtual;
function GetAutoDataCellHeight: Boolean; virtual;
function GetAutoDataRecordHeight: Boolean; virtual;
function GetAutoRecordHeight: Boolean; virtual;
function GetBackgroundBitmap: TBitmap; virtual;
function GetItemLeftBound(AIndex: Integer): Integer; virtual; abstract;
function GetItemsOffset(AItemCountDelta: Integer): Integer; virtual; abstract;
function GetItemTopBound(AIndex: Integer): Integer; virtual; abstract;
function GetRecordIndex(AViewInfoIndex: Integer): Integer;
function GetViewInfoIndex(ARecordIndex: Integer): Integer;
function IsEmpty: Boolean; virtual;
procedure OffsetItem(AIndex, AOffset: Integer); virtual; abstract;
procedure ControlFocusChanged; virtual;
procedure VisibilityChanged(AVisible: Boolean); virtual;
function GetPainterClass: TcxCustomGridRecordsPainterClass; virtual;
property Canvas: TcxCanvas read GetCanvas;
property Controller: TcxCustomGridTableController read GetController;
property FirstRecordIndex: Integer read GetFirstRecordIndex;
property GridViewInfo: TcxCustomGridTableViewInfo read FGridViewInfo;
property IncSearchingCellViewInfo: TcxGridTableDataCellViewInfo read GetIncSearchingCellViewInfo;
property MaxCount: Integer read GetMaxCount;
property TopRecordIndex: Integer read GetTopRecordIndex;
property ViewData: TcxCustomGridTableViewData read GetViewData;
public
constructor Create(AGridViewInfo: TcxCustomGridTableViewInfo); virtual;
destructor Destroy; override;
function CanOffset(AItemCountDelta: Integer): Boolean; virtual;
function GetCellHeight(ACellContentHeight: Integer): Integer; virtual;
function GetHitTest(const P: TPoint): TcxCustomGridHitTest; virtual;
function GetRealItem(ARecord: TcxCustomGridRecord): TcxCustomGridRecordViewInfo; virtual;
function IsCellMultiLine(AItem: TcxCustomGridTableItem): Boolean; virtual;
procedure MainCalculate; virtual;
procedure Offset(AItemCountDelta: Integer); overload; virtual;
procedure Offset(DX, DY: Integer); overload; virtual;
procedure Paint;
property AutoDataCellHeight: Boolean read GetAutoDataCellHeight;
property AutoDataRecordHeight: Boolean read GetAutoDataRecordHeight;
property AutoRecordHeight: Boolean read GetAutoRecordHeight;
property BackgroundBitmap: TBitmap read FBackgroundBitmap write FBackgroundBitmap;
property Bounds: TRect read FBounds;
property ContentBounds: TRect read FContentBounds;
property Count: Integer read GetCount;
property GridView: TcxCustomGridTableView read GetGridView;
property Items[Index: Integer]: TcxCustomGridRecordViewInfo read GetItem; default;
property ItemsOffset: Integer read FItemsOffset;
property VisibleCount: Integer read FVisibleCount;
end;
// view
TcxNavigatorSiteViewInfoClass = class of TcxNavigatorSiteViewInfo;
TcxNavigatorSiteViewInfo = class(TcxCustomGridViewCellViewInfo)
private
function GetGridViewInfo: TcxCustomGridTableViewInfo;
function GetNavigatorViewInfo: TcxNavigatorViewInfo;
protected
function CalculateHeight: Integer; override;
function CalculateWidth: Integer; override;
function GetHeight: Integer; override;
function GetHitTestClass: TcxCustomGridHitTestClass; override;
function GetHotTrack: Boolean; override;
function GetPainterClass: TcxCustomGridCellPainterClass; override;
function GetVisible: Boolean; override;
procedure MouseLeave; override;
procedure GetViewParams(var AParams: TcxViewParams); override;
function GetWidth: Integer; override;
public
destructor Destroy; override;
function MouseDown(AHitTest: TcxCustomGridHitTest; AButton: TMouseButton;
AShift: TShiftState): Boolean; override;
function MouseMove(AHitTest: TcxCustomGridHitTest; AShift: TShiftState): Boolean; override;
function MouseUp(AHitTest: TcxCustomGridHitTest; AButton: TMouseButton;
AShift: TShiftState): Boolean; override;
property GridViewInfo: TcxCustomGridTableViewInfo read GetGridViewInfo;
property NavigatorViewInfo: TcxNavigatorViewInfo read GetNavigatorViewInfo;
end;
TcxCustomGridTableViewInfo = class(TcxCustomGridViewInfo, IcxNavigatorOwner)
private
FCalculateDown: Boolean;
FFilterViewInfo: TcxGridFilterViewInfo;
FFirstRecordIndex: Integer;
FNavigatorSize: TPoint;
FNavigatorSiteViewInfo: TcxNavigatorSiteViewInfo;
FNavigatorViewInfo: TcxNavigatorViewInfo;
FParts: TList;
FRecordsViewInfo: TcxCustomGridRecordsViewInfo;
function GetController: TcxCustomGridTableController;
function GetExpandButtonSize: Integer;
function GetFirstRecordIndex: Integer;
function GetGridView: TcxCustomGridTableView;
function GetPart(Index: Integer): TcxCustomGridPartViewInfo;
function GetPartCount: Integer;
function GetPartsBottomHeight: Integer;
function GetPartsCustomHeight(AAlignment: TcxGridPartAlignment): Integer;
function GetPartsTopHeight: Integer;
function GetScrollableAreaWidth: Integer;
function GetViewData: TcxCustomGridTableViewData;
function GetVisibleRecordCount: Integer;
procedure AddPart(AItem: TcxCustomGridPartViewInfo);
procedure RemovePart(AItem: TcxCustomGridPartViewInfo);
protected
// IcxNavigatorOwner
function GetNavigatorBounds: TRect; virtual;
function GetNavigatorButtons: TcxCustomNavigatorButtons;
function GetNavigatorCanvas: TCanvas;
function GetNavigatorControl: TWinControl;
function GetNavigatorFocused: Boolean;
function GetNavigatorLookAndFeel: TcxLookAndFeel;
function GetNavigatorOwner: TComponent;
function GetNavigatorShowHint: Boolean;
function GetNavigatorTabStop: Boolean;
procedure NavigatorButtonsStateChanged;
procedure NavigatorChanged(AChangeType: TcxNavigatorChangeType);
procedure RefreshNavigator;
procedure CreateViewInfos; override;
procedure DestroyViewInfos(AIsRecreating: Boolean); override;
procedure AdjustClientBounds(var ABounds: TRect); override;
procedure AfterCalculating; override;
procedure AfterOffset; virtual;
procedure BeforeOffset; virtual;
procedure Calculate; override;
function CalculateClientBounds: TRect; override;
procedure CalculateHeight(const AMaxSize: TPoint; var AHeight: Integer;
var AFullyVisible: Boolean); override;
function CalculatePartBounds(APart: TcxCustomGridPartViewInfo): TRect; virtual;
function CalculateVisibleEqualHeightRecordCount: Integer; virtual;
procedure ControlFocusChanged; override;
function DoGetHitTest(const P: TPoint): TcxCustomGridHitTest; override;
function GetDefaultGridModeBufferCount: Integer; virtual;
procedure GetHScrollBarBounds(var ABounds: TRect); override;
function GetFilterViewInfoClass: TcxGridFilterViewInfoClass; virtual;
function GetIsInternalUse: Boolean; override;
function GetNavigatorOffset: Integer; virtual;
function GetNavigatorSiteBounds: TRect; virtual;
function GetNavigatorSiteViewInfoClass: TcxNavigatorSiteViewInfoClass; virtual;
function GetNavigatorViewInfoClass: TcxNavigatorViewInfoClass; virtual;
function GetNoDataInfoText: string; virtual;
function GetNoDataInfoTextAreaBounds: TRect; virtual;
procedure GetNoDataInfoTextParams(out AParams: TcxViewParams); virtual;
function GetNoDataInfoTextAreaVisible: Boolean; virtual;
function GetNonRecordsAreaHeight(ACheckScrollBar: Boolean): Integer; virtual;
function GetRecordsViewInfoClass: TcxCustomGridRecordsViewInfoClass; virtual; abstract;
function GetScrollableAreaBounds: TRect; virtual;
function GetScrollableAreaBoundsForEdit: TRect; virtual;
function GetScrollableAreaBoundsHorz: TRect; virtual;
function GetScrollableAreaBoundsVert: TRect; virtual;
function FirstRecordIndexAssigned: Boolean;
procedure Offset(ARecordCountDelta: Integer); overload; virtual;
procedure Offset(DX, DY: Integer); overload; virtual;
procedure VisibilityChanged(AVisible: Boolean); override;
property Controller: TcxCustomGridTableController read GetController;
property PartCount: Integer read GetPartCount;
property Parts[Index: Integer]: TcxCustomGridPartViewInfo read GetPart;
property ViewData: TcxCustomGridTableViewData read GetViewData;
public
constructor Create(AGridView: TcxCustomGridView); override;
destructor Destroy; override;
function CanOffset(ARecordCountDelta, DX, DY: Integer): Boolean; virtual;
function CanOffsetView(ARecordCountDelta: Integer): Boolean; virtual;
procedure DoOffset(ARecordCountDelta, DX, DY: Integer); virtual;
// for extended lookup edit
function GetNearestPopupHeight(AHeight: Integer; AAdditionalRecord: Boolean = False): Integer; virtual;
function GetPopupHeight(ADropDownRecordCount: Integer): Integer; virtual;
property CalculateDown: Boolean read FCalculateDown write FCalculateDown;
property ExpandButtonSize: Integer read GetExpandButtonSize;
property FilterViewInfo: TcxGridFilterViewInfo read FFilterViewInfo;
property FirstRecordIndex: Integer read GetFirstRecordIndex write FFirstRecordIndex;
property GridView: TcxCustomGridTableView read GetGridView;
property NavigatorBounds: TRect read GetNavigatorBounds;
property NavigatorOffset: Integer read GetNavigatorOffset;
property NavigatorSize: TPoint read FNavigatorSize;
property NavigatorSiteViewInfo: TcxNavigatorSiteViewInfo read FNavigatorSiteViewInfo;
property NavigatorViewInfo: TcxNavigatorViewInfo read FNavigatorViewInfo;
property NoDataInfoText: string read GetNoDataInfoText;
property NoDataInfoTextAreaBounds: TRect read GetNoDataInfoTextAreaBounds;
property NoDataInfoTextAreaVisible: Boolean read GetNoDataInfoTextAreaVisible;
property PartsBottomHeight: Integer read GetPartsBottomHeight;
property PartsTopHeight: Integer read GetPartsTopHeight;
property RecordsViewInfo: TcxCustomGridRecordsViewInfo read FRecordsViewInfo;
property ScrollableAreaBounds: TRect read GetScrollableAreaBounds;
property ScrollableAreaBoundsForEdit: TRect read GetScrollableAreaBoundsForEdit;
property ScrollableAreaBoundsHorz: TRect read GetScrollableAreaBoundsHorz;
property ScrollableAreaBoundsVert: TRect read GetScrollableAreaBoundsVert;
property ScrollableAreaWidth: Integer read GetScrollableAreaWidth;
property VisibleRecordCount: Integer read GetVisibleRecordCount;
end;
// cache
TcxCustomGridTableViewInfoCacheItem = class(TcxCustomGridViewInfoCacheItem)
private
FHeight: Integer;
FIsHeightAssigned: Boolean;
function GetGridRecord: TcxCustomGridRecord;
procedure SetHeight(Value: Integer);
protected
property GridRecord: TcxCustomGridRecord read GetGridRecord;
public
procedure UnassignValues(AKeepMaster: Boolean); override;
property Height: Integer read FHeight write SetHeight;
property IsHeightAssigned: Boolean read FIsHeightAssigned write FIsHeightAssigned;
end;
TcxCustomGridTableViewInfoCache = class(TcxCustomGridViewInfoCache)
private
function GetViewData: TcxCustomGridTableViewData;
protected
function GetItemClass(Index: Integer): TcxCustomGridViewInfoCacheItemClass; override;
property ViewData: TcxCustomGridTableViewData read GetViewData;
end;
{ view }
// custom item
TcxGridTableItemChange = (ticProperty, ticLayout, ticSize);
TcxCustomGridTableItemCustomOptions = class(TPersistent)
private
FItem: TcxCustomGridTableItem;
function GetGridView: TcxCustomGridTableView;
protected
procedure Changed(AChange: TcxGridTableItemChange = ticLayout); virtual;
public
constructor Create(AItem: TcxCustomGridTableItem); virtual;
procedure Assign(Source: TPersistent); override;
property GridView: TcxCustomGridTableView read GetGridView;
property Item: TcxCustomGridTableItem read FItem;
end;
TcxGridItemShowEditButtons = (isebDefault, isebNever, isebAlways);
TcxGridItemSortByDisplayText = (isbtDefault, isbtOn, isbtOff);
TcxCustomGridTableItemOptionsClass = class of TcxCustomGridTableItemOptions;
TcxCustomGridTableItemOptions = class(TcxCustomGridTableItemCustomOptions)
private
FEditing: Boolean;
FFiltering: Boolean;
FFilteringFilteredItemsList: Boolean;
FFilteringMRUItemsList: Boolean;
FFilteringPopup: Boolean;
FFilteringPopupMultiSelect: Boolean;
FFocusing: Boolean;
FGrouping: Boolean;
FIgnoreTimeForFiltering: Boolean;
FIncSearch: Boolean;
FMoving: Boolean;
FShowCaption: Boolean;
FShowEditButtons: TcxGridItemShowEditButtons;
FSortByDisplayText: TcxGridItemSortByDisplayText;
FSorting: Boolean;
procedure SetEditing(Value: Boolean);
procedure SetFiltering(Value: Boolean);
procedure SetFilteringFilteredItemsList(Value: Boolean);
procedure SetFilteringMRUItemsList(Value: Boolean);
procedure SetFilteringPopup(Value: Boolean);
procedure SetFilteringPopupMultiSelect(Value: Boolean);
procedure SetFocusing(Value: Boolean);
procedure SetGrouping(Value: Boolean);
procedure SetIgnoreTimeForFiltering(Value: Boolean);
procedure SetIncSearch(Value: Boolean);
procedure SetMoving(Value: Boolean);
procedure SetShowCaption(Value: Boolean);
procedure SetShowEditButtons(Value: TcxGridItemShowEditButtons);
procedure SetSortByDisplayText(Value: TcxGridItemSortByDisplayText);
procedure SetSorting(Value: Boolean);
protected
procedure BeforeShowCaptionChange; virtual;
property Grouping: Boolean read FGrouping write SetGrouping default True;
property Moving: Boolean read FMoving write SetMoving default True;
property ShowCaption: Boolean read FShowCaption write SetShowCaption default True;
property SortByDisplayText: TcxGridItemSortByDisplayText read FSortByDisplayText
write SetSortByDisplayText default isbtDefault;
property Sorting: Boolean read FSorting write SetSorting default True;
public
constructor Create(AItem: TcxCustomGridTableItem); override;
procedure Assign(Source: TPersistent); override;
published
property Editing: Boolean read FEditing write SetEditing default True;
property Filtering: Boolean read FFiltering write SetFiltering default True;
property FilteringFilteredItemsList: Boolean read FFilteringFilteredItemsList
write SetFilteringFilteredItemsList default True;
property FilteringMRUItemsList: Boolean read FFilteringMRUItemsList write SetFilteringMRUItemsList default True;
property FilteringPopup: Boolean read FFilteringPopup write SetFilteringPopup default True;
property FilteringPopupMultiSelect: Boolean read FFilteringPopupMultiSelect
write SetFilteringPopupMultiSelect default True;
property Focusing: Boolean read FFocusing write SetFocusing default True;
property IgnoreTimeForFiltering: Boolean read FIgnoreTimeForFiltering write SetIgnoreTimeForFiltering default True;
property IncSearch: Boolean read FIncSearch write SetIncSearch default True;
property ShowEditButtons: TcxGridItemShowEditButtons read FShowEditButtons
write SetShowEditButtons default isebDefault;
end;
TcxGridGetCellStyleEvent = procedure(Sender: TcxCustomGridTableView; ARecord: TcxCustomGridRecord;
AItem: TcxCustomGridTableItem; {$IFDEF BCB}var{$ELSE}out{$ENDIF} AStyle: TcxStyle) of object;
TcxGridGetRecordStyleEvent = procedure(Sender: TcxCustomGridTableView; ARecord: TcxCustomGridRecord;
{$IFDEF BCB}var{$ELSE}out{$ENDIF} AStyle: TcxStyle) of object;
TcxCustomGridTableItemStylesClass = class of TcxCustomGridTableItemStyles;
TcxCustomGridTableItemStyles = class(TcxCustomGridStyles)
private
FOnGetContentStyle: TcxGridGetCellStyleEvent;
function GetGridViewValue: TcxCustomGridTableView;
function GetItem: TcxCustomGridTableItem;
procedure SetOnGetContentStyle(Value: TcxGridGetCellStyleEvent);
protected
procedure GetDefaultViewParams(Index: Integer; AData: TObject; out AParams: TcxViewParams); override;
function GetGridView: TcxCustomGridView; override;
public
procedure Assign(Source: TPersistent); override;
procedure GetContentParams(ARecord: TcxCustomGridRecord; out AParams: TcxViewParams); virtual;
property GridView: TcxCustomGridTableView read GetGridViewValue;
property Item: TcxCustomGridTableItem read GetItem;
published
property Content: TcxStyle index isContent read GetValue write SetValue;
property OnGetContentStyle: TcxGridGetCellStyleEvent read FOnGetContentStyle write SetOnGetContentStyle;
end;
TcxGridSortOrder = TcxDataSortOrder;
TcxGridTableDataCellCustomDrawEvent = procedure(Sender: TcxCustomGridTableView;
ACanvas: TcxCanvas; AViewInfo: TcxGridTableDataCellViewInfo; var ADone: Boolean) of object;
TcxGridGetCellHintEvent = procedure(Sender: TcxCustomGridTableItem; ARecord: TcxCustomGridRecord;
ACellViewInfo: TcxGridTableDataCellViewInfo; const AMousePos: TPoint;
var AHintText: TCaption; var AIsHintMultiLine: Boolean; var AHintTextRect: TRect) of object;
TcxGridGetDataTextEvent = procedure(Sender: TcxCustomGridTableItem;
ARecordIndex: Integer; var AText: string) of object;
TcxGridGetDisplayTextEvent = procedure(Sender: TcxCustomGridTableItem;
ARecord: TcxCustomGridRecord; var AText: string) of object;
TcxGridGetFilterDisplayTextEvent = procedure(Sender: TcxCustomGridTableItem;
const AValue: Variant; var ADisplayText: string) of object;
TcxGridGetFilterValuesEvent = procedure(Sender: TcxCustomGridTableItem;
AValueList: TcxDataFilterValueList) of object;
TcxGridGetPropertiesEvent = procedure(Sender: TcxCustomGridTableItem;
ARecord: TcxCustomGridRecord; var AProperties: TcxCustomEditProperties) of object;
TcxGridInitDateRangesEvent = procedure(Sender: TcxCustomGridTableItem; ADateRanges: TcxGridDateRanges) of object;
TcxGridTableItemGetStoredPropertiesEvent = procedure(Sender: TcxCustomGridTableItem;
AProperties: TStrings) of object;
TcxGridTableItemGetStoredPropertyValueEvent = procedure(Sender: TcxCustomGridTableItem;
const AName: string; var AValue: Variant) of object;
TcxGridTableItemSetStoredPropertyValueEvent = procedure(Sender: TcxCustomGridTableItem;
const AName: string; const AValue: Variant) of object;
TcxGridUserFilteringEvent = procedure(Sender: TcxCustomGridTableItem;
const AValue: Variant; const ADisplayText: string) of object;
TcxCustomGridTableItemClass = class of TcxCustomGridTableItem;
TcxCustomGridTableItem = class(TcxComponent, IcxEditRepositoryItemListener, IcxStoredObject)
private
FAlternateCaption: string;
FBestFitMaxWidth: Integer;
FCaption: string;
FCells: TList;
FCellStyle: TcxEditStyle;
FCellStyleUseCounter: Integer;
FDataBinding: TcxGridItemDataBinding;
FDateTimeGrouping: TcxGridDateTimeGrouping;
FEditData: TcxCustomEditData;
FEditViewData: TcxCustomEditViewData;
FFilteringDateRanges: TcxGridFilteringDateRanges;
FGridView: TcxCustomGridTableView;
FGroupingDateRanges: TcxGridGroupingDateRanges;
FHeaderAlignmentHorz: TAlignment;
FHeaderAlignmentVert: TcxAlignmentVert;
FID: Integer;
FIgnoreLoadingStatus: Boolean;
FIndex: Integer;
FIsCaptionAssigned: Boolean;
FIsHeaderAlignmentHorzAssigned: Boolean;
FIsHeaderAlignmentVertAssigned: Boolean;
FIsWidthAssigned: Boolean;
FLastUsedDefaultRepositoryItem: TcxEditRepositoryItem;
FMinWidth: Integer;
FOptions: TcxCustomGridTableItemOptions;
FProperties: TcxCustomEditProperties;
FPropertiesClass: TcxCustomEditPropertiesClass;
FPropertiesValue: TcxCustomEditProperties;
FRepositoryItem: TcxEditRepositoryItem;
FSavedVisible: Boolean;
FStyles: TcxCustomGridTableItemStyles;
FVisible: Boolean;
FVisibleForCustomization: Boolean;
FVisibleIndex: Integer;
FWasVisibleBeforeGrouping: Boolean;
FWidth: Integer;
FOnCustomDrawCell: TcxGridTableDataCellCustomDrawEvent;
FOnGetCellHint: TcxGridGetCellHintEvent;
FOnGetDataText: TcxGridGetDataTextEvent;
FOnGetDisplayText: TcxGridGetDisplayTextEvent;
FOnGetFilterDisplayText: TcxGridGetFilterDisplayTextEvent;
FOnGetFilterValues: TcxGridGetFilterValuesEvent;
FOnGetProperties: TcxGridGetPropertiesEvent;
FOnGetPropertiesForEdit: TcxGridGetPropertiesEvent;
FOnGetStoredProperties: TcxGridTableItemGetStoredPropertiesEvent;
FOnGetStoredPropertyValue: TcxGridTableItemGetStoredPropertyValueEvent;
FOnInitFilteringDateRanges: TcxGridInitDateRangesEvent;
FOnInitGroupingDateRanges: TcxGridInitDateRangesEvent;
FOnSetStoredPropertyValue: TcxGridTableItemSetStoredPropertyValueEvent;
FOnUserFiltering: TcxGridUserFilteringEvent;
FSubClassEvents: TNotifyEvent;
function GetActualMinWidth: Integer;
function GetCaption: string;
function GetCell(Index: Integer): TcxGridTableDataCellViewInfo;
function GetCellCount: Integer;
function GetController: TcxCustomGridTableController;
function GetDataController: TcxCustomDataController;
function GetEditing: Boolean;
function GetEditingProperties: TcxCustomEditProperties;
function GetFilterCaption: string;
function GetFiltered: Boolean;
function GetFocused: Boolean;
function GetGroupIndex: Integer;
function GetHeaderAlignmentHorz: TAlignment;
function GetHeaderAlignmentVert: TcxAlignmentVert;
function GetHidden: Boolean;
function GetIsLoading: Boolean;
function GetIncSearching: Boolean;
function GetIsDestroying: Boolean;
function GetIsFirst: Boolean;
function GetIsLast: Boolean;
function GetIsReading: Boolean;
function GetIsUpdating: Boolean;
function GetMinWidth: Integer;
function GetPropertiesClassName: string;
function GetSortIndex: Integer;
function GetSortOrder: TcxGridSortOrder;
function GetTag: TcxTag;
function GetViewData: TcxCustomGridTableViewData;
function GetWidth: Integer;
procedure SetAlternateCaption(const Value: string);
procedure SetBestFitMaxWidth(Value: Integer);
procedure SetCaption(const Value: string);
procedure SetDataBinding(Value: TcxGridItemDataBinding);
procedure SetDateTimeGrouping(Value: TcxGridDateTimeGrouping);
procedure SetEditing(Value: Boolean);
procedure SetFiltered(Value: Boolean);
procedure SetFocused(Value: Boolean);
procedure SetGroupIndex(Value: Integer);
procedure SetHeaderAlignmentHorz(Value: TAlignment);
procedure SetHeaderAlignmentVert(Value: TcxAlignmentVert);
procedure SetHidden(Value: Boolean);
procedure SetIndex(Value: Integer);
procedure SetMinWidth(Value: Integer);
procedure SetOnCustomDrawCell(Value: TcxGridTableDataCellCustomDrawEvent);
procedure SetOnGetCellHint(Value: TcxGridGetCellHintEvent);
procedure SetOnGetDataText(Value: TcxGridGetDataTextEvent);
procedure SetOnGetDisplayText(Value: TcxGridGetDisplayTextEvent);
procedure SetOnGetFilterDisplayText(Value: TcxGridGetFilterDisplayTextEvent);
procedure SetOnGetFilterValues(Value: TcxGridGetFilterValuesEvent);
procedure SetOnGetProperties(Value: TcxGridGetPropertiesEvent);
procedure SetOnGetPropertiesForEdit(Value: TcxGridGetPropertiesEvent);
procedure SetOnGetStoredProperties(Value: TcxGridTableItemGetStoredPropertiesEvent);
procedure SetOnGetStoredPropertyValue(Value: TcxGridTableItemGetStoredPropertyValueEvent);
procedure SetOnInitFilteringDateRanges(Value: TcxGridInitDateRangesEvent);
procedure SetOnInitGroupingDateRanges(Value: TcxGridInitDateRangesEvent);
procedure SetOnSetStoredPropertyValue(Value: TcxGridTableItemSetStoredPropertyValueEvent);
procedure SetOnUserFiltering(Value: TcxGridUserFilteringEvent);
procedure SetOptions(Value: TcxCustomGridTableItemOptions);
procedure SetProperties(Value: TcxCustomEditProperties);
procedure SetPropertiesClass(Value: TcxCustomEditPropertiesClass);
procedure SetPropertiesClassName(const Value: string);
procedure SetRepositoryItem(Value: TcxEditRepositoryItem);
procedure SetSortIndex(Value: Integer);
procedure SetSortOrder(Value: TcxGridSortOrder);
procedure SetStyles(Value: TcxCustomGridTableItemStyles);
procedure SetTag(Value: TcxTag);
procedure SetVisible(Value: Boolean);
procedure SetVisibleForCustomization(Value: Boolean);
procedure SetWidth(Value: Integer);
procedure ReadHidden(Reader: TReader);
procedure ReadIsCaptionAssigned(Reader: TReader);
procedure WriteIsCaptionAssigned(Writer: TWriter);
function IsCaptionStored: Boolean;
function IsSortOrderStored: Boolean;
function IsTagStored: Boolean;
function IsWidthStored: Boolean;
function GetDataBindingClass: TcxGridItemDataBindingClass;
procedure CreateProperties;
procedure DestroyProperties;
procedure RecreateProperties;
protected
procedure DefineProperties(Filer: TFiler); override;
procedure SetParentComponent(AParent: TComponent); override;
// IcxEditRepositoryItemListener
procedure ItemRemoved(Sender: TcxEditRepositoryItem);
procedure IcxEditRepositoryItemListener.PropertiesChanged = RepositoryItemPropertiesChanged;
procedure RepositoryItemPropertiesChanged(Sender: TcxEditRepositoryItem);
// IcxStoredObject
function GetObjectName: string; virtual;
function IcxStoredObject.GetProperties = GetStoredProperties;
function GetStoredProperties(AProperties: TStrings): Boolean; virtual;
procedure GetPropertyValue(const AName: string; var AValue: Variant); virtual;
procedure SetPropertyValue(const AName: string; const AValue: Variant); virtual;
procedure CreateDataBinding; virtual;
procedure DestroyDataBinding; virtual;
procedure CreateSubClasses; virtual;
procedure DestroySubClasses; virtual;
function GetFilteringDateRangesClass: TcxGridFilteringDateRangesClass; virtual;
function GetGroupingDateRangesClass: TcxGridGroupingDateRangesClass; virtual;
function GetOptionsClass: TcxCustomGridTableItemOptionsClass; virtual;
function GetStylesClass: TcxCustomGridTableItemStylesClass; virtual;
function IsHeaderAlignmentHorzStored: Boolean;
function IsHeaderAlignmentVertStored: Boolean;
procedure BestFitApplied(AFireEvents: Boolean); virtual;
function CalculateBestFitWidth: Integer; virtual;
function CanAutoHeight: Boolean; virtual;
function CanEdit: Boolean; virtual;
function CanFilter(AVisually: Boolean): Boolean; virtual;
function CanFilterUsingChecks: Boolean; virtual;
function CanFilterMRUValueItems: Boolean; virtual;
function CanFocus(ARecord: TcxCustomGridRecord): Boolean; virtual;
function CanGroup: Boolean; virtual;
function CanHide: Boolean; virtual;
function CanHorzSize: Boolean; virtual;
function CanIgnoreTimeForFiltering: Boolean; virtual;
function CanIncSearch: Boolean; virtual;
function CanInitEditing: Boolean; virtual;
function CanMove: Boolean; virtual;
function CanScroll: Boolean; virtual;
function CanSort: Boolean; virtual;
procedure CaptionChanged; virtual;
procedure Changed(AChange: TcxGridTableItemChange); virtual;
procedure ChangeGroupIndex(Value: Integer);
procedure ChangeSortIndex(Value: Integer);
procedure CheckWidthValue(var Value: Integer);
procedure DataChanged; virtual;
procedure DateTimeGroupingChanged; virtual;
procedure ForceWidth(Value: Integer); virtual;
function GetActuallyVisible: Boolean; virtual;
function GetBestFitWidth: Integer; virtual;
function GetDateTimeFilters: TcxGridDateTimeFilters; virtual;
function GetDateTimeGrouping: TcxGridDateTimeGrouping;
function GetEditable: Boolean; virtual;
function GetEditPartVisible: Boolean; virtual;
function GetEditValue: Variant; virtual;
function GetFilterable: Boolean; virtual;
procedure GetFilterDisplayText(const AValue: Variant; var ADisplayText: string); virtual;
function GetFixed: Boolean; virtual;
function GetFocusedCellViewInfo: TcxGridTableDataCellViewInfo; virtual;
function GetPropertiesForEdit: TcxCustomEditProperties; virtual;
function GetPropertiesValue: TcxCustomEditProperties;
function GetVisible: Boolean; virtual;
function GetVisibleCaption: string; virtual;
function GetVisibleForCustomization: Boolean; virtual;
function GetVisibleIndex: Integer;
function GetVisibleInQuickCustomizationPopup: Boolean; virtual;
procedure GroupingChanging; virtual;
function HasCustomDrawCell: Boolean;
function HasFixedWidth: Boolean; virtual;
procedure InitFilteringDateRanges; virtual;
procedure InitGroupingDateRanges; virtual;
procedure InitProperties(AProperties: TcxCustomEditProperties); virtual;
function IsSortingByDisplayText(ASortByDisplayText: Boolean): Boolean;
function IsVisibleStored: Boolean; virtual;
function IsVisibleForCustomizationStored: Boolean; virtual;
procedure PropertiesChanged;
procedure PropertiesChangedHandler(Sender: TObject);
procedure PropertiesValueChanged;
procedure RecalculateDefaultWidth;
procedure SetEditValue(const Value: Variant); virtual;
procedure SetGridView(Value: TcxCustomGridTableView); virtual;
function ShowButtons(AFocused: Boolean): Boolean; virtual;
function ShowOnUngrouping: Boolean; virtual;
function SupportsDateTimeFilters(ARelativeFilters: Boolean): Boolean; virtual;
function SupportsGroupingDateRanges(ACheckCustomHandlers: Boolean): Boolean; virtual;
function UseFilteredValuesForFilterValueList: Boolean; virtual;
function UseOwnProperties: Boolean;
procedure ValueTypeClassChanged; virtual;
procedure VisibleChanged; virtual;
procedure VisibleForCustomizationChanged; virtual;
function DefaultAlternateCaption: string; virtual;
function DefaultCaption: string; virtual;
function DefaultHeaderAlignmentHorz: TAlignment;
function DefaultHeaderAlignmentVert: TcxAlignmentVert;
function DefaultRepositoryItem: TcxEditRepositoryItem;
function DefaultWidth: Integer; virtual;
function GetCellStyle: TcxEditStyle;
procedure InitStyle(AStyle: TcxCustomEditStyle; const AParams: TcxViewParams;
AFocused: Boolean); virtual;
procedure ReleaseCellStyle;
procedure AddCell(ACell: TcxGridTableDataCellViewInfo);
procedure RemoveCell(ACell: TcxGridTableDataCellViewInfo);
property CellCount: Integer read GetCellCount;
property Cells[Index: Integer]: TcxGridTableDataCellViewInfo read GetCell;
function CreateEditViewData(AProperties: TcxCustomEditProperties): TcxCustomEditViewData;
procedure DestroyEditViewData(var AEditViewData: TcxCustomEditViewData);
procedure DoCreateEditViewData;
procedure DoDestroyEditViewData;
procedure EditViewDataGetDisplayTextHandler(Sender: TcxCustomEditViewData; var AText: string);
function GetEditViewData(AProperties: TcxCustomEditProperties;
out AIsLocalCopy: Boolean): TcxCustomEditViewData;
procedure ReleaseEditViewData(var AEditViewData: TcxCustomEditViewData; AIsLocalCopy: Boolean);
property EditViewData: TcxCustomEditViewData read FEditViewData;
procedure CheckVisible;
procedure SaveVisible;
property SavedVisible: Boolean read FSavedVisible;
procedure DoCustomDrawCell(ACanvas: TcxCanvas; AViewInfo: TcxGridTableDataCellViewInfo;
var ADone: Boolean); virtual;
procedure DoGetCellHint(ARecord: TcxCustomGridRecord; ACellViewInfo: TcxGridTableDataCellViewInfo;
const AMousePos: TPoint; var AHintText: TCaption; var AIsHintMultiLine: Boolean;
var AHintTextRect: TRect); virtual;
procedure DoGetDataText(ARecordIndex: Integer; var AText: string); virtual;
procedure DoGetDisplayText(ARecord: TcxCustomGridRecord; var AText: string); virtual;
procedure DoGetFilterValues(AValueList: TcxDataFilterValueList); virtual;
function DoGetProperties(ARecord: TcxCustomGridRecord): TcxCustomEditProperties; virtual;
procedure DoGetPropertiesForEdit(ARecord: TcxCustomGridRecord; var AProperties: TcxCustomEditProperties); virtual;
procedure DoInitFilteringDateRanges; virtual;
procedure DoInitGroupingDateRanges; virtual;
procedure DoUserFiltering(const AValue: Variant; const ADisplayText: string); virtual;
function HasCellHintHandler: Boolean;
function HasCustomPropertiesForEditHandler: Boolean;
function HasCustomPropertiesHandler: Boolean;
function HasDataTextHandler: Boolean;
function HasInitFilteringDateRangesHandler: Boolean;
function HasInitFilteringDateRangesHandlers: Boolean;
function HasInitGroupingDateRangesHandler: Boolean;
function HasInitGroupingDateRangesHandlers: Boolean;
property IsDestroying: Boolean read GetIsDestroying;
property IsLoading: Boolean read GetIsLoading;
property IsReading: Boolean read GetIsReading;
property IsUpdating: Boolean read GetIsUpdating;
property ActualMinWidth: Integer read GetActualMinWidth;
property Controller: TcxCustomGridTableController read GetController;
property DataController: TcxCustomDataController read GetDataController;
property DateTimeGrouping: TcxGridDateTimeGrouping read FDateTimeGrouping write SetDateTimeGrouping default dtgDefault;
property EditingProperties: TcxCustomEditProperties read GetEditingProperties;
property EditPartVisible: Boolean read GetEditPartVisible;
property Filterable: Boolean read GetFilterable;
property FilterCaption: string read GetFilterCaption;
property Fixed: Boolean read GetFixed;
property GroupIndex: Integer read GetGroupIndex write SetGroupIndex default -1;
property GroupingDateRanges: TcxGridGroupingDateRanges read FGroupingDateRanges;
property HeaderAlignmentHorz: TAlignment read GetHeaderAlignmentHorz write SetHeaderAlignmentHorz
stored IsHeaderAlignmentHorzStored;
property HeaderAlignmentVert: TcxAlignmentVert read GetHeaderAlignmentVert
write SetHeaderAlignmentVert stored IsHeaderAlignmentVertStored;
property Hidden: Boolean read GetHidden write SetHidden; // obsolete, use VisibleForCustomization
property IgnoreLoadingStatus: Boolean read FIgnoreLoadingStatus write FIgnoreLoadingStatus;
property InternalVisible: Boolean read FVisible;
property MinWidth: Integer read GetMinWidth write SetMinWidth
default cxGridItemDefaultMinWidth;
property ViewData: TcxCustomGridTableViewData read GetViewData;
property VisibleForCustomization: Boolean read GetVisibleForCustomization
write SetVisibleForCustomization stored IsVisibleForCustomizationStored;
property VisibleInQuickCustomizationPopup: Boolean read GetVisibleInQuickCustomizationPopup;
property WasVisibleBeforeGrouping: Boolean read FWasVisibleBeforeGrouping;
property Width: Integer read GetWidth write SetWidth stored IsWidthStored;
property OnInitGroupingDateRanges: TcxGridInitDateRangesEvent read FOnInitGroupingDateRanges write SetOnInitGroupingDateRanges;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
procedure Assign(Source: TPersistent); override;
function GetParentComponent: TComponent; override;
function HasParent: Boolean; override;
procedure ApplyBestFit(ACheckSizingAbility: Boolean = False; AFireEvents: Boolean = False); virtual;
function CalculateDefaultCellHeight(ACanvas: TcxCanvas; AFont: TFont): Integer; virtual;
function CreateEditStyle: TcxEditStyle; virtual;
procedure FocusWithSelection; virtual;
function GetAlternateCaption: string;
function GetDefaultValuesProvider(AProperties: TcxCustomEditProperties = nil): IcxEditDefaultValuesProvider;
function GetProperties: TcxCustomEditProperties; overload;
function GetProperties(ARecord: TcxCustomGridRecord): TcxCustomEditProperties; overload;
function GetProperties(ARecordIndex: Integer): TcxCustomEditProperties; overload;
function GetRepositoryItem: TcxEditRepositoryItem;
procedure MakeVisible;
procedure RestoreDefaults; virtual;
property ActuallyVisible: Boolean read GetActuallyVisible;
property BestFitMaxWidth: Integer read FBestFitMaxWidth write SetBestFitMaxWidth default 0;
property Editable: Boolean read GetEditable;
property Editing: Boolean read GetEditing write SetEditing;
property EditValue: Variant read GetEditValue write SetEditValue;
property Filtered: Boolean read GetFiltered write SetFiltered;
property FilteringDateRanges: TcxGridFilteringDateRanges read FFilteringDateRanges;
property Focused: Boolean read GetFocused write SetFocused;
property FocusedCellViewInfo: TcxGridTableDataCellViewInfo read GetFocusedCellViewInfo;
property GridView: TcxCustomGridTableView read FGridView;
property Hideable: Boolean read CanHide;
property ID: Integer read FID;
property IncSearching: Boolean read GetIncSearching;
property Index: Integer read FIndex write SetIndex;
property IsFirst: Boolean read GetIsFirst;
property IsLast: Boolean read GetIsLast;
property Options: TcxCustomGridTableItemOptions read FOptions write SetOptions;
property PropertiesClass: TcxCustomEditPropertiesClass read FPropertiesClass write SetPropertiesClass;
property SortIndex: Integer read GetSortIndex write SetSortIndex default -1;
property SortOrder: TcxGridSortOrder read GetSortOrder write SetSortOrder stored IsSortOrderStored;
property Styles: TcxCustomGridTableItemStyles read FStyles write SetStyles;
property VisibleCaption: string read GetVisibleCaption;
property VisibleIndex: Integer read FVisibleIndex;
published
property AlternateCaption: string read FAlternateCaption write SetAlternateCaption;
property Caption: string read GetCaption write SetCaption stored IsCaptionStored;
property DataBinding: TcxGridItemDataBinding read FDataBinding write SetDataBinding;
property PropertiesClassName: string read GetPropertiesClassName write SetPropertiesClassName;
property Properties: TcxCustomEditProperties read FProperties write SetProperties;
property RepositoryItem: TcxEditRepositoryItem read FRepositoryItem write SetRepositoryItem;
property Visible: Boolean read GetVisible write SetVisible stored IsVisibleStored default True;
property PropertiesEvents: TNotifyEvent read FSubClassEvents write FSubClassEvents;
property StylesEvents: TNotifyEvent read FSubClassEvents write FSubClassEvents;
property Tag: TcxTag read GetTag write SetTag stored IsTagStored;
property OnCustomDrawCell: TcxGridTableDataCellCustomDrawEvent read FOnCustomDrawCell write SetOnCustomDrawCell;
property OnGetCellHint: TcxGridGetCellHintEvent read FOnGetCellHint write SetOnGetCellHint;
property OnGetDataText: TcxGridGetDataTextEvent read FOnGetDataText write SetOnGetDataText;
property OnGetDisplayText: TcxGridGetDisplayTextEvent read FOnGetDisplayText write SetOnGetDisplayText;
property OnGetFilterDisplayText: TcxGridGetFilterDisplayTextEvent read FOnGetFilterDisplayText write SetOnGetFilterDisplayText;
property OnGetFilterValues: TcxGridGetFilterValuesEvent read FOnGetFilterValues write SetOnGetFilterValues;
property OnGetProperties: TcxGridGetPropertiesEvent read FOnGetProperties write SetOnGetProperties;
property OnGetPropertiesForEdit: TcxGridGetPropertiesEvent read FOnGetPropertiesForEdit write SetOnGetPropertiesForEdit;
property OnGetStoredProperties: TcxGridTableItemGetStoredPropertiesEvent read FOnGetStoredProperties write SetOnGetStoredProperties;
property OnGetStoredPropertyValue: TcxGridTableItemGetStoredPropertyValueEvent read FOnGetStoredPropertyValue write SetOnGetStoredPropertyValue;
property OnInitFilteringDateRanges: TcxGridInitDateRangesEvent read FOnInitFilteringDateRanges write SetOnInitFilteringDateRanges;
property OnSetStoredPropertyValue: TcxGridTableItemSetStoredPropertyValueEvent read FOnSetStoredPropertyValue write SetOnSetStoredPropertyValue;
property OnUserFiltering: TcxGridUserFilteringEvent read FOnUserFiltering write SetOnUserFiltering;
end;
// grid view options
TcxCustomGridTableBackgroundBitmaps = class(TcxCustomGridBackgroundBitmaps)
protected
function GetBitmapStyleIndex(Index: Integer): Integer; override;
public
procedure Assign(Source: TPersistent); override;
published
property Content: TBitmap index bbContent read GetValue write SetValue;
property FilterBox: TBitmap index bbFilterBox read GetValue write SetValue;
end;
TcxCustomGridTableDateTimeHandlingClass = class of TcxCustomGridTableDateTimeHandling;
TcxCustomGridTableDateTimeHandling = class(TcxCustomGridOptions)
private
FDateFormat: string;
FFilters: TcxGridDateTimeFilters;
FGrouping: TcxGridDateTimeGrouping;
FHourFormat: string;
FIgnoreTimeForFiltering: Boolean;
FMonthFormat: string;
FUseLongDateFormat: Boolean;
FUseShortTimeFormat: Boolean;
FYearFormat: string;
function GetGridView: TcxCustomGridTableView;
procedure SetDateFormat(const Value: string);
procedure SetFilters(Value: TcxGridDateTimeFilters);
procedure SetGrouping(Value: TcxGridDateTimeGrouping);
procedure SetHourFormat(const Value: string);
procedure SetIgnoreTimeForFiltering(Value: Boolean);
procedure SetMonthFormat(const Value: string);
procedure SetUseLongDateFormat(Value: Boolean);
procedure SetUseShortTimeFormat(Value: Boolean);
procedure SetYearFormat(const Value: string);
protected
property DateFormat: string read FDateFormat write SetDateFormat;
property Grouping: TcxGridDateTimeGrouping read FGrouping write SetGrouping default dtgByDateAndTime;
property HourFormat: string read FHourFormat write SetHourFormat;
property UseLongDateFormat: Boolean read FUseLongDateFormat write SetUseLongDateFormat default True;
property UseShortTimeFormat: Boolean read FUseShortTimeFormat write SetUseShortTimeFormat default True;
public
constructor Create(AGridView: TcxCustomGridView); override;
procedure Assign(Source: TPersistent); override;
function GetDateFormat: string;
function GetHourFormat: string;
function GetMonthFormat: string;
function GetYearFormat: string;
procedure GroupingChanged;
property GridView: TcxCustomGridTableView read GetGridView;
published
property Filters: TcxGridDateTimeFilters read FFilters write SetFilters default [];
property IgnoreTimeForFiltering: Boolean read FIgnoreTimeForFiltering write SetIgnoreTimeForFiltering default False;
property MonthFormat: string read FMonthFormat write SetMonthFormat;
property YearFormat: string read FYearFormat write SetYearFormat;
end;
TcxGridFilterMRUItem = class(TcxMRUItem)
private
function GetCaption: string;
protected
function StreamEquals(AStream: TMemoryStream): Boolean;
public
Filter: TcxDataFilterCriteria;
constructor Create(AFilter: TcxDataFilterCriteria);
destructor Destroy; override;
procedure AssignTo(AFilter: TcxDataFilterCriteria);
function Equals(AItem: TcxMRUItem): Boolean; override;
function FilterEquals(AFilter: TcxDataFilterCriteria): Boolean;
function GetStream: TMemoryStream;
property Caption: string read GetCaption;
end;
TcxGridFilterMRUItemsClass = class of TcxGridFilterMRUItems;
TcxGridFilterMRUItems = class(TcxMRUItems)
private
FFiltering: TcxCustomGridTableFiltering;
FVisibleItems: TList;
function GetItem(Index: Integer): TcxGridFilterMRUItem;
function GetVisibleCount: Integer;
function GetVisibleItem(Index: Integer): TcxGridFilterMRUItem;
protected
procedure DeleteEmptyItems;
procedure FilterChanged;
procedure RefreshVisibleItemsList;
public
constructor Create(AFiltering: TcxCustomGridTableFiltering); reintroduce; virtual;
destructor Destroy; override;
procedure Add(AFilter: TcxDataFilterCriteria);
property Filtering: TcxCustomGridTableFiltering read FFiltering;
property Items[Index: Integer]: TcxGridFilterMRUItem read GetItem; default;
property VisibleCount: Integer read GetVisibleCount;
property VisibleItems[Index: Integer]: TcxGridFilterMRUItem read GetVisibleItem;
end;
TcxGridFilterPosition = (fpTop, fpBottom);
TcxGridFilterVisible = (fvNever, fvNonEmpty, fvAlways);
TcxGridFilterBoxClass = class of TcxGridFilterBox;
TcxGridFilterBox = class(TcxCustomGridOptions)
private
FCustomizeDialog: Boolean;
FMRUItemsListDropDownCount: Integer;
FPosition: TcxGridFilterPosition;
FVisible: TcxGridFilterVisible;
procedure SetCustomizeDialog(Value: Boolean);
procedure SetMRUItemsListDropDownCount(Value: Integer);
procedure SetPosition(Value: TcxGridFilterPosition);
procedure SetVisible(Value: TcxGridFilterVisible);
public
constructor Create(AGridView: TcxCustomGridView); override;
procedure Assign(Source: TPersistent); override;
published
property CustomizeDialog: Boolean read FCustomizeDialog write SetCustomizeDialog default True;
property MRUItemsListDropDownCount: Integer read FMRUItemsListDropDownCount
write SetMRUItemsListDropDownCount default 0;
property Position: TcxGridFilterPosition read FPosition write SetPosition default fpBottom;
property Visible: TcxGridFilterVisible read FVisible write SetVisible default fvNonEmpty;
end;
TcxGridItemFilterPopupApplyChangesMode = (fpacImmediately, fpacOnButtonClick);
TcxGridItemFilterPopupOptionsClass = class of TcxGridItemFilterPopupOptions;
TcxGridItemFilterPopupOptions = class(TcxCustomGridOptions)
private
FApplyMultiSelectChanges: TcxGridItemFilterPopupApplyChangesMode;
FDropDownWidth: Integer;
FMaxDropDownItemCount: Integer;
FMultiSelect: Boolean;
procedure SetApplyMultiSelectChanges(Value: TcxGridItemFilterPopupApplyChangesMode);
procedure SetDropDownWidth(Value: Integer);
procedure SetMaxDropDownItemCount(Value: Integer);
procedure SetMultiSelect(Value: Boolean);
public
constructor Create(AGridView: TcxCustomGridView); override;
procedure Assign(Source: TPersistent); override;
published
property ApplyMultiSelectChanges: TcxGridItemFilterPopupApplyChangesMode read FApplyMultiSelectChanges
write SetApplyMultiSelectChanges default fpacImmediately;
property DropDownWidth: Integer read FDropDownWidth write SetDropDownWidth default 0;
property MaxDropDownItemCount: Integer read FMaxDropDownItemCount
write SetMaxDropDownItemCount default cxGridFilterDefaultItemPopupMaxDropDownItemCount;
property MultiSelect: Boolean read FMultiSelect write SetMultiSelect default True;
end;
TcxCustomGridTableFilteringClass = class of TcxCustomGridTableFiltering;
TcxCustomGridTableFiltering = class(TcxCustomGridOptions)
private
FItemFilteredItemsList: Boolean;
FItemMRUItemsList: Boolean;
FItemMRUItemsListCount: Integer;
FItemPopup: TcxGridItemFilterPopupOptions;
FMRUItems: TcxGridFilterMRUItems;
FMRUItemsList: Boolean;
FMRUItemsListCount: Integer;
function GetCustomizeDialog: Boolean;
function GetGridView: TcxCustomGridTableView;
function GetMRUItemsListDropDownCount: Integer;
function GetPosition: TcxGridFilterPosition;
function GetVisible: TcxGridFilterVisible;
procedure SetCustomizeDialog(Value: Boolean);
procedure SetItemFilteredItemsList(Value: Boolean);
procedure SetItemMRUItemsList(Value: Boolean);
procedure SetItemMRUItemsListCount(Value: Integer);
procedure SetItemPopup(Value: TcxGridItemFilterPopupOptions);
procedure SetMRUItemsList(Value: Boolean);
procedure SetMRUItemsListCount(Value: Integer);
procedure SetMRUItemsListDropDownCount(Value: Integer);
procedure SetPosition(Value: TcxGridFilterPosition);
procedure SetVisible(Value: TcxGridFilterVisible);
procedure FilterControlDialogApply(Sender: TObject);
procedure ReadCustomizeDialog(Reader: TReader);
procedure ReadMRUItemsListDropDownCount(Reader: TReader);
procedure ReadPosition(Reader: TReader);
procedure ReadVisible(Reader: TReader);
protected
procedure DefineProperties(Filer: TFiler); override;
procedure FilterChanged; virtual;
function GetItemPopupClass: TcxGridItemFilterPopupOptionsClass; virtual;
function GetMRUItemsClass: TcxGridFilterMRUItemsClass; virtual;
function IsMRUItemsListAvailable: Boolean; virtual;
procedure MRUItemsVisibleCountChanged(AOldCount, ANewCount: Integer); virtual;
property ItemFilteredItemsList: Boolean read FItemFilteredItemsList write SetItemFilteredItemsList default False;
property ItemMRUItemsList: Boolean read FItemMRUItemsList write SetItemMRUItemsList default True;
property ItemMRUItemsListCount: Integer read FItemMRUItemsListCount write SetItemMRUItemsListCount
default cxGridFilterDefaultItemMRUItemsListCount;
property ItemPopup: TcxGridItemFilterPopupOptions read FItemPopup write SetItemPopup;
function GetItemPopupDropDownWidth: Integer;
function GetItemPopupMaxDropDownItemCount: Integer;
procedure SetItemPopupDropDownWidth(Value: Integer);
procedure SetItemPopupMaxDropDownItemCount(Value: Integer);
procedure ReadItemPopupDropDownWidth(Reader: TReader);
procedure ReadItemPopupMaxDropDownCount(Reader: TReader);
// obsolete - use ItemPopup.DropDownWidth
property DropDownWidth: Integer read GetItemPopupDropDownWidth write SetItemPopupDropDownWidth;
// obsolete - use ItemPopup.MaxDropDownItemCount
property MaxDropDownCount: Integer read GetItemPopupMaxDropDownItemCount write SetItemPopupMaxDropDownItemCount;
public
constructor Create(AGridView: TcxCustomGridView); override;
destructor Destroy; override;
procedure AddFilterToMRUItems(AFilter: TcxDataFilterCriteria = nil);
procedure Assign(Source: TPersistent); override;
procedure RunCustomizeDialog(AItem: TcxCustomGridTableItem = nil);
property GridView: TcxCustomGridTableView read GetGridView;
property MRUItems: TcxGridFilterMRUItems read FMRUItems;
// obsolete - use GridView.FilterBox
property CustomizeDialog: Boolean read GetCustomizeDialog write SetCustomizeDialog;
property MRUItemsListDropDownCount: Integer read GetMRUItemsListDropDownCount write SetMRUItemsListDropDownCount;
property Position: TcxGridFilterPosition read GetPosition write SetPosition;
property Visible: TcxGridFilterVisible read GetVisible write SetVisible;
published
property MRUItemsList: Boolean read FMRUItemsList write SetMRUItemsList default True;
property MRUItemsListCount: Integer read FMRUItemsListCount write SetMRUItemsListCount
default cxGridFilterDefaultMRUItemsListCount;
end;
TcxGridDragFocusing = (dfNone, dfDragOver, dfDragDrop);
TcxCustomGridTableOptionsBehavior = class(TcxCustomGridOptionsBehavior)
private
FAlwaysShowEditor: Boolean;
FBestFitMaxRecordCount: Integer;
FCellHints: Boolean;
FCopyCaptionsToClipboard: Boolean;
FDragDropText: Boolean;
FDragFocusing: TcxGridDragFocusing;
FDragHighlighting: Boolean;
FDragOpening: Boolean;
FDragScrolling: Boolean;
FFocusCellOnCycle: Boolean;
FFocusCellOnTab: Boolean;
FFocusFirstCellOnNewRecord: Boolean;
FGoToNextCellOnEnter: Boolean;
FImmediateEditor: Boolean;
FIncSearch: Boolean;
FIncSearchItem: TcxCustomGridTableItem;
FNavigatorHints: Boolean;
FPullFocusing: Boolean;
function GetGridView: TcxCustomGridTableView;
procedure SetAlwaysShowEditor(Value: Boolean);
procedure SetBestFitMaxRecordCount(Value: Integer);
procedure SetCellHints(Value: Boolean);
procedure SetCopyCaptionsToClipboard(Value: Boolean);
procedure SetDragDropText(Value: Boolean);
procedure SetDragFocusing(Value: TcxGridDragFocusing);
procedure SetDragHighlighting(Value: Boolean);
procedure SetDragOpening(Value: Boolean);
procedure SetDragScrolling(Value: Boolean);
procedure SetFocusCellOnCycle(Value: Boolean);
procedure SetFocusCellOnTab(Value: Boolean);
procedure SetFocusFirstCellOnNewRecord(Value: Boolean);
procedure SetGoToNextCellOnEnter(Value: Boolean);
procedure SetImmediateEditor(Value: Boolean);
procedure SetIncSearch(Value: Boolean);
procedure SetIncSearchItem(Value: TcxCustomGridTableItem);
procedure SetNavigatorHints(Value: Boolean);
procedure SetPullFocusing(Value: Boolean);
protected
property FocusCellOnCycle: Boolean read FFocusCellOnCycle write SetFocusCellOnCycle default False;
property PullFocusing: Boolean read FPullFocusing write SetPullFocusing default False;
public
constructor Create(AGridView: TcxCustomGridView); override;
procedure Assign(Source: TPersistent); override;
property BestFitMaxRecordCount: Integer read FBestFitMaxRecordCount write SetBestFitMaxRecordCount default 0;
property GridView: TcxCustomGridTableView read GetGridView;
published
property AlwaysShowEditor: Boolean read FAlwaysShowEditor write SetAlwaysShowEditor default False;
property CellHints: Boolean read FCellHints write SetCellHints default False;
property CopyCaptionsToClipboard: Boolean read FCopyCaptionsToClipboard write SetCopyCaptionsToClipboard default True;
property DragDropText: Boolean read FDragDropText write SetDragDropText default False;
property DragFocusing: TcxGridDragFocusing read FDragFocusing write SetDragFocusing default dfNone;
property DragHighlighting: Boolean read FDragHighlighting write SetDragHighlighting default True;
property DragOpening: Boolean read FDragOpening write SetDragOpening default True;
property DragScrolling: Boolean read FDragScrolling write SetDragScrolling default True;
property FocusCellOnTab: Boolean read FFocusCellOnTab write SetFocusCellOnTab default False;
property FocusFirstCellOnNewRecord: Boolean read FFocusFirstCellOnNewRecord
write SetFocusFirstCellOnNewRecord default False;
property GoToNextCellOnEnter: Boolean read FGoToNextCellOnEnter write SetGoToNextCellOnEnter default False;
property ImmediateEditor: Boolean read FImmediateEditor write SetImmediateEditor default True;
property IncSearch: Boolean read FIncSearch write SetIncSearch default False;
property IncSearchItem: TcxCustomGridTableItem read FIncSearchItem write SetIncSearchItem;
property NavigatorHints: Boolean read FNavigatorHints write SetNavigatorHints default False;
end;
TcxGridQuickCustomizationReordering = (qcrDefault, qcrEnabled, qcrDisabled);
TcxCustomGridTableOptionsCustomizeClass = class of TcxCustomGridTableOptionsCustomize;
TcxCustomGridTableOptionsCustomize = class(TcxCustomGridOptions)
private
FItemFiltering: Boolean;
FItemGrouping: Boolean;
FItemHiding: Boolean;
FItemMoving: Boolean;
FItemSorting: Boolean;
FItemsQuickCustomization: Boolean;
FItemsQuickCustomizationMaxDropDownCount: Integer;
FItemsQuickCustomizationReordering: TcxGridQuickCustomizationReordering;
procedure SetItemFiltering(Value: Boolean);
procedure SetItemGrouping(Value: Boolean);
procedure SetItemHiding(Value: Boolean);
procedure SetItemMoving(Value: Boolean);
procedure SetItemSorting(Value: Boolean);
procedure SetItemsQuickCustomization(Value: Boolean);
procedure SetItemsQuickCustomizationMaxDropDownCount(Value: Integer);
procedure SetItemsQuickCustomizationReordering(Value: TcxGridQuickCustomizationReordering);
protected
property ItemFiltering: Boolean read FItemFiltering write SetItemFiltering default True;
property ItemGrouping: Boolean read FItemGrouping write SetItemGrouping default True;
property ItemHiding: Boolean read FItemHiding write SetItemHiding default False;
property ItemMoving: Boolean read FItemMoving write SetItemMoving default True;
property ItemSorting: Boolean read FItemSorting write SetItemSorting default True;
property ItemsQuickCustomization: Boolean read FItemsQuickCustomization
write SetItemsQuickCustomization default False;
property ItemsQuickCustomizationMaxDropDownCount: Integer read FItemsQuickCustomizationMaxDropDownCount
write SetItemsQuickCustomizationMaxDropDownCount default 0;
property ItemsQuickCustomizationReordering: TcxGridQuickCustomizationReordering
read FItemsQuickCustomizationReordering write SetItemsQuickCustomizationReordering default qcrDefault;
public
constructor Create(AGridView: TcxCustomGridView); override;
procedure Assign(Source: TPersistent); override;
function SupportsItemsQuickCustomizationReordering: Boolean; virtual;
end;
TcxCustomGridTableOptionsData = class(TcxCustomGridOptionsData)
private
FAppending: Boolean;
FCancelOnExit: Boolean;
FDeleting: Boolean;
FDeletingConfirmation: Boolean;
FEditing: Boolean;
FInserting: Boolean;
function GetGridView: TcxCustomGridTableView;
procedure SetAppending(Value: Boolean);
procedure SetCancelOnExit(Value: Boolean);
procedure SetDeleting(Value: Boolean);
procedure SetDeletingConfirmation(Value: Boolean);
procedure SetEditing(Value: Boolean);
procedure SetInserting(Value: Boolean);
public
constructor Create(AGridView: TcxCustomGridView); override;
procedure Assign(Source: TPersistent); override;
property GridView: TcxCustomGridTableView read GetGridView;
published
property Appending: Boolean read FAppending write SetAppending default False;
property CancelOnExit: Boolean read FCancelOnExit write SetCancelOnExit default True;
property Deleting: Boolean read FDeleting write SetDeleting default True;
property DeletingConfirmation: Boolean read FDeletingConfirmation
write SetDeletingConfirmation default True;
property Editing: Boolean read FEditing write SetEditing default True;
property Inserting: Boolean read FInserting write SetInserting default True;
end;
TcxCustomGridTableOptionsSelection = class(TcxCustomGridOptionsSelection)
private
FCellSelect: Boolean;
FHideFocusRectOnExit: Boolean;
FHideSelection: Boolean;
FInvertSelect: Boolean;
FUnselectFocusedRecordOnExit: Boolean;
function GetGridView: TcxCustomGridTableView;
function GetMultiSelect: Boolean;
procedure SetHideFocusRectOnExit(Value: Boolean);
procedure SetHideSelection(Value: Boolean);
procedure SetUnselectFocusedRecordOnExit(Value: Boolean);
protected
function IsInvertSelectStored: Boolean; virtual;
function IsMultiSelectStored: Boolean; virtual;
procedure SetCellSelect(Value: Boolean); virtual;
procedure SetInvertSelect(Value: Boolean); virtual;
procedure SetMultiSelect(Value: Boolean); virtual;
property GridView: TcxCustomGridTableView read GetGridView;
public
constructor Create(AGridView: TcxCustomGridView); override;
procedure Assign(Source: TPersistent); override;
published
property CellSelect: Boolean read FCellSelect write SetCellSelect default True;
property HideFocusRect: Boolean read FHideFocusRectOnExit write SetHideFocusRectOnExit stored False; // for compatibility
property HideFocusRectOnExit: Boolean read FHideFocusRectOnExit write SetHideFocusRectOnExit default True;
property HideSelection: Boolean read FHideSelection write SetHideSelection default False;
property InvertSelect: Boolean read FInvertSelect write SetInvertSelect stored IsInvertSelectStored;
property MultiSelect: Boolean read GetMultiSelect write SetMultiSelect stored IsMultiSelectStored;
property UnselectFocusedRecordOnExit: Boolean read FUnselectFocusedRecordOnExit
write SetUnselectFocusedRecordOnExit default True;
end;
TcxGridShowEditButtons = (gsebNever, gsebForFocusedRecord, gsebAlways);
TcxGridShowItemFilterButtons = (sfbAlways, sfbWhenSelected);
TcxCustomGridTableOptionsView = class(TcxCustomGridOptionsView)
private
FCellAutoHeight: Boolean;
FCellEndEllipsis: Boolean;
FCellTextMaxLineCount: Integer;
FFocusRect: Boolean;
FItemCaptionAutoHeight: Boolean;
FItemCaptionEndEllipsis: Boolean;
FNavigator: Boolean;
FNavigatorOffset: Integer;
FNoDataToDisplayInfoText: string;
FShowEditButtons: TcxGridShowEditButtons;
FShowItemFilterButtons: TcxGridShowItemFilterButtons;
function GetGridView: TcxCustomGridTableView;
procedure SetCellAutoHeight(Value: Boolean);
procedure SetCellEndEllipsis(Value: Boolean);
procedure SetCellTextMaxLineCount(Value: Integer);
procedure SetFocusRect(Value: Boolean);
procedure SetItemCaptionAutoHeight(Value: Boolean);
procedure SetItemCaptionEndEllipsis(Value: Boolean);
procedure SetNavigator(Value: Boolean);
procedure SetNavigatorOffset(Value: Integer);
procedure SetNoDataToDisplayInfoText(const Value: string);
procedure SetShowEditButtons(Value: TcxGridShowEditButtons);
procedure SetShowItemFilterButtons(Value: TcxGridShowItemFilterButtons);
function IsNoDataToDisplayInfoTextAssigned: Boolean;
protected
procedure ItemCaptionAutoHeightChanged; dynamic;
property CellAutoHeight: Boolean read FCellAutoHeight write SetCellAutoHeight default False;
property CellTextMaxLineCount: Integer read FCellTextMaxLineCount write SetCellTextMaxLineCount default 0;
property ItemCaptionAutoHeight: Boolean read FItemCaptionAutoHeight
write SetItemCaptionAutoHeight default False;
property ItemCaptionEndEllipsis: Boolean read FItemCaptionEndEllipsis
write SetItemCaptionEndEllipsis default False;
property ShowItemFilterButtons: TcxGridShowItemFilterButtons read FShowItemFilterButtons
write SetShowItemFilterButtons default sfbWhenSelected;
public
constructor Create(AGridView: TcxCustomGridView); override;
procedure Assign(Source: TPersistent); override;
function GetNoDataToDisplayInfoText: string;
property GridView: TcxCustomGridTableView read GetGridView;
published
property CellEndEllipsis: Boolean read FCellEndEllipsis write SetCellEndEllipsis default False;
property FocusRect: Boolean read FFocusRect write SetFocusRect default True;
property Navigator: Boolean read FNavigator write SetNavigator default False;
property NavigatorOffset: Integer read FNavigatorOffset write SetNavigatorOffset default cxGridNavigatorDefaultOffset;
property NoDataToDisplayInfoText: string read FNoDataToDisplayInfoText
write SetNoDataToDisplayInfoText stored IsNoDataToDisplayInfoTextAssigned;
property ScrollBars;
property ShowEditButtons: TcxGridShowEditButtons read FShowEditButtons
write SetShowEditButtons default gsebNever;
end;
TcxGridCellPos = class
GridRecord: TcxCustomGridRecord;
Item: TObject;
constructor Create(AGridRecord: TcxCustomGridRecord; AItem: TObject);
end;
TcxGridDataCellPos = class
GridRecord: TcxCustomGridRecord;
Item: TcxCustomGridTableItem;
constructor Create(AGridRecord: TcxCustomGridRecord; AItem: TcxCustomGridTableItem); overload;
end;
TcxCustomGridTableViewStyles = class(TcxCustomGridViewStyles)
private
FOnGetContentStyle: TcxGridGetCellStyleEvent;
function GetGridViewValue: TcxCustomGridTableView;
procedure SetOnGetContentStyle(Value: TcxGridGetCellStyleEvent);
protected
procedure GetDefaultViewParams(Index: Integer; AData: TObject; out AParams: TcxViewParams); override;
procedure GetSelectionParams(ARecord: TcxCustomGridRecord; AItem: TObject;
out AParams: TcxViewParams);
public
procedure Assign(Source: TPersistent); override;
procedure GetCellContentParams(ARecord: TcxCustomGridRecord; AItem: TObject;
out AParams: TcxViewParams); virtual;
procedure GetContentParams(ARecord: TcxCustomGridRecord; AItem: TcxCustomGridTableItem;
out AParams: TcxViewParams); virtual;
procedure GetDataCellContentParams(ARecord: TcxCustomGridRecord; AItem: TcxCustomGridTableItem;
out AParams: TcxViewParams); virtual;
procedure GetDataCellParams(ARecord: TcxCustomGridRecord; AItem: TcxCustomGridTableItem;
out AParams: TcxViewParams; AUseViewInfo: Boolean = False; ACellViewInfo: TcxGridTableCellViewInfo = nil;
AIgnoreSelection: Boolean = False); virtual;
procedure GetRecordContentParams(ARecord: TcxCustomGridRecord; AItem: TcxCustomGridTableItem;
out AParams: TcxViewParams); virtual;
property GridView: TcxCustomGridTableView read GetGridViewValue;
published
property Content: TcxStyle index vsContent read GetValue write SetValue;
property ContentEven: TcxStyle index vsContentEven read GetValue write SetValue;
property ContentOdd: TcxStyle index vsContentOdd read GetValue write SetValue;
property FilterBox: TcxStyle index vsFilterBox read GetValue write SetValue;
property Inactive: TcxStyle index vsInactive read GetValue write SetValue;
property IncSearch: TcxStyle index vsIncSearch read GetValue write SetValue;
property Selection: TcxStyle index vsSelection read GetValue write SetValue;
property OnGetContentStyle: TcxGridGetCellStyleEvent read FOnGetContentStyle write SetOnGetContentStyle;
end;
// grid view
TcxGridOpenTableItemList = class(TcxOpenList)
private
function GetItem(Index: Integer): TcxCustomGridTableItem;
procedure SetItem(Index: Integer; Value: TcxCustomGridTableItem);
public
property Items[Index: Integer]: TcxCustomGridTableItem read GetItem write SetItem; default;
end;
TcxGridTableCellCustomDrawEvent = procedure(Sender: TcxCustomGridTableView;
ACanvas: TcxCanvas; AViewInfo: TcxGridTableCellViewInfo; var ADone: Boolean) of object;
TcxGridAllowRecordOperationEvent = procedure(Sender: TcxCustomGridTableView;
ARecord: TcxCustomGridRecord; var AAllow: Boolean) of object;
TcxGridCellClickEvent = procedure(Sender: TcxCustomGridTableView;
ACellViewInfo: TcxGridTableDataCellViewInfo; AButton: TMouseButton;
AShift: TShiftState; var AHandled: Boolean) of object;
TcxGridCustomTableViewEvent = procedure(Sender: TcxCustomGridTableView) of object;
TcxGridEditingEvent = procedure(Sender: TcxCustomGridTableView;
AItem: TcxCustomGridTableItem; var AAllow: Boolean) of object;
TcxGridEditKeyEvent = procedure(Sender: TcxCustomGridTableView; AItem: TcxCustomGridTableItem;
AEdit: TcxCustomEdit; var Key: Word; Shift: TShiftState) of object;
TcxGridEditKeyPressEvent = procedure(Sender: TcxCustomGridTableView;
AItem: TcxCustomGridTableItem; AEdit: TcxCustomEdit; var Key: Char) of object;
TcxGridCustomTableItemEvent = procedure(Sender: TcxCustomGridTableView;
AItem: TcxCustomGridTableItem) of object;
TcxGridFilterCustomizationEvent = procedure(Sender: TcxCustomGridTableView;
var ADone: Boolean) of object;
TcxGridFilterDialogShowEvent = procedure(Sender: TcxCustomGridTableView;
AItem: TcxCustomGridTableItem; var ADone: Boolean) of object;
TcxGridFocusedItemChangedEvent = procedure(Sender: TcxCustomGridTableView;
APrevFocusedItem, AFocusedItem: TcxCustomGridTableItem) of object;
TcxGridFocusedRecordChangedEvent = procedure(Sender: TcxCustomGridTableView;
APrevFocusedRecord, AFocusedRecord: TcxCustomGridRecord; ANewItemRecordFocusingChanged: Boolean) of object;
TcxGridGetCellHeightEvent = procedure(Sender: TcxCustomGridTableView;
ARecord: TcxCustomGridRecord; AItem: TcxCustomGridTableItem;
ACellViewInfo: TcxGridTableDataCellViewInfo; var AHeight: Integer) of object;
TcxGridGetDragDropTextEvent = procedure(Sender: TcxCustomGridTableView;
ARecord: TcxCustomGridRecord; AItem: TcxCustomGridTableItem; var AText: string) of object;
TcxGridInitEditEvent = procedure(Sender: TcxCustomGridTableView;
AItem: TcxCustomGridTableItem; AEdit: TcxCustomEdit) of object;
TcxGridInitEditValueEvent = procedure(Sender: TcxCustomGridTableView;
AItem: TcxCustomGridTableItem; AEdit: TcxCustomEdit; var AValue: TcxEditValue) of object;
TcxGridPartCustomDrawBackgroundEvent = procedure(Sender: TcxCustomGridTableView;
ACanvas: TcxCanvas; AViewInfo: TcxCustomGridCellViewInfo; var ADone: Boolean) of object;
TcxGridRecordEvent = procedure(Sender: TcxCustomGridTableView; ARecord: TcxCustomGridRecord) of object;
TcxGridDataControllerChange = (dccItemAdded, dccItemRemoved, dccIndexesChanged);
TcxCustomGridTableView = class(TcxCustomGridView, IcxFilterControl, IcxNavigator)
private
FAssigningGroupedItems: TcxGridOpenTableItemList;
FAssigningSortedItems: TcxGridOpenTableItemList;
FCopyToClipboardItems: TList;
FCopyToClipboardStr: string;
FDateTimeHandling: TcxCustomGridTableDateTimeHandling;
FDontMakeMasterRecordVisible: Boolean;
FFilterableItems: TList;
FFilterBox: TcxGridFilterBox;
FFiltering: TcxCustomGridTableFiltering;
FIgnorePropertiesChanges: Boolean;
FIsAfterAssigningItems: Boolean;
FIsAssigningItems: Boolean;
FItems: TList;
FNavigatorButtons: TcxNavigatorControlButtons;
FNavigatorNotifier: TcxNavigatorControlNotifier;
FNextID: Integer;
FOptionsCustomize: TcxCustomGridTableOptionsCustomize;
FRestoringItems: TcxGridOpenTableItemList;
FVisibleItems: TList;
FOnCanFocusRecord: TcxGridAllowRecordOperationEvent;
FOnCanSelectRecord: TcxGridAllowRecordOperationEvent;
FOnCellClick: TcxGridCellClickEvent;
FOnCellDblClick: TcxGridCellClickEvent;
FOnCustomDrawCell: TcxGridTableDataCellCustomDrawEvent;
FOnCustomDrawPartBackground: TcxGridPartCustomDrawBackgroundEvent;
FOnEditing: TcxGridEditingEvent;
FOnEditChanged: TcxGridCustomTableItemEvent;
FOnEditKeyDown: TcxGridEditKeyEvent;
FOnEditKeyPress: TcxGridEditKeyPressEvent;
FOnEditKeyUp: TcxGridEditKeyEvent;
FOnEditValueChanged: TcxGridCustomTableItemEvent;
FOnFilterControlDialogShow: TNotifyEvent;
FOnFilterCustomization: TcxGridFilterCustomizationEvent;
FOnFilterDialogShow: TcxGridFilterDialogShowEvent;
FOnFocusedItemChanged: TcxGridFocusedItemChangedEvent;
FOnFocusedRecordChanged: TcxGridFocusedRecordChangedEvent;
FOnGetCellHeight: TcxGridGetCellHeightEvent;
FOnGetDragDropText: TcxGridGetDragDropTextEvent;
FOnInitFilteringDateRanges: TcxGridInitDateRangesEvent;
FOnInitGroupingDateRanges: TcxGridInitDateRangesEvent;
FOnInitEdit: TcxGridInitEditEvent;
FOnInitEditValue: TcxGridInitEditValueEvent;
//FOnRecordCreated: TcxGridRecordEvent;
//FOnRecordDestroying: TcxGridRecordEvent;
FOnSelectionChanged: TcxGridCustomTableViewEvent;
FOnTopRecordIndexChanged: TNotifyEvent;
function GetBackgroundBitmaps: TcxCustomGridTableBackgroundBitmaps;
function GetController: TcxCustomGridTableController;
function GetFilterableItem(Index: Integer): TcxCustomGridTableItem;
function GetFilterableItemCount: Integer;
function GetGroupedItem(Index: Integer): TcxCustomGridTableItem;
function GetGroupedItemCount: Integer;
function GetItem(Index: Integer): TcxCustomGridTableItem;
function GetItemCount: Integer;
function GetMasterGridRecord: TcxCustomGridRecord;
function GetOptionsBehavior: TcxCustomGridTableOptionsBehavior;
function GetOptionsData: TcxCustomGridTableOptionsData;
function GetOptionsSelection: TcxCustomGridTableOptionsSelection;
function GetOptionsView: TcxCustomGridTableOptionsView;
function GetPainter: TcxCustomGridTablePainter;
function GetPatternGridView: TcxCustomGridTableView;
function GetNavigatorButtonsControl: IcxNavigator;
function GetSortedItem(Index: Integer): TcxCustomGridTableItem;
function GetSortedItemCount: Integer;
function GetStyles: TcxCustomGridTableViewStyles;
function GetViewData: TcxCustomGridTableViewData;
function GetViewInfo: TcxCustomGridTableViewInfo;
function GetVisibleItem(Index: Integer): TcxCustomGridTableItem;
function GetVisibleItemCount: Integer;
procedure SetBackgroundBitmaps(Value: TcxCustomGridTableBackgroundBitmaps);
procedure SetDateTimeHandling(Value: TcxCustomGridTableDateTimeHandling);
procedure SetFilterBox(Value: TcxGridFilterBox);
procedure SetFiltering(Value: TcxCustomGridTableFiltering);
procedure SetItem(Index: Integer; Value: TcxCustomGridTableItem);
procedure SetNavigatorButtons(Value: TcxNavigatorControlButtons);
procedure SetOnCanFocusRecord(Value: TcxGridAllowRecordOperationEvent);
procedure SetOnCanSelectRecord(Value: TcxGridAllowRecordOperationEvent);
procedure SetOnCellClick(Value: TcxGridCellClickEvent);
procedure SetOnCellDblClick(Value: TcxGridCellClickEvent);
procedure SetOnCustomDrawCell(Value: TcxGridTableDataCellCustomDrawEvent);
procedure SetOnCustomDrawPartBackground(Value: TcxGridPartCustomDrawBackgroundEvent);
procedure SetOnEditChanged(Value: TcxGridCustomTableItemEvent);
procedure SetOnEditing(Value: TcxGridEditingEvent);
procedure SetOnEditKeyDown(Value: TcxGridEditKeyEvent);
procedure SetOnEditKeyPress(Value: TcxGridEditKeyPressEvent);
procedure SetOnEditKeyUp(Value: TcxGridEditKeyEvent);
procedure SetOnEditValueChanged(Value: TcxGridCustomTableItemEvent);
procedure SetOnFilterControlDialogShow(Value: TNotifyEvent);
procedure SetOnFilterCustomization(Value: TcxGridFilterCustomizationEvent);
procedure SetOnFilterDialogShow(Value: TcxGridFilterDialogShowEvent);
procedure SetOnFocusedItemChanged(Value: TcxGridFocusedItemChangedEvent);
procedure SetOnFocusedRecordChanged(Value: TcxGridFocusedRecordChangedEvent);
procedure SetOnGetCellHeight(Value: TcxGridGetCellHeightEvent);
procedure SetOnGetDragDropText(Value: TcxGridGetDragDropTextEvent);
procedure SetOnInitFilteringDateRanges(Value: TcxGridInitDateRangesEvent);
procedure SetOnInitGroupingDateRanges(Value: TcxGridInitDateRangesEvent);
procedure SetOnInitEdit(Value: TcxGridInitEditEvent);
procedure SetOnInitEditValue(Value: TcxGridInitEditValueEvent);
procedure SetOnSelectionChanged(Value: TcxGridCustomTableViewEvent);
procedure SetOnTopRecordIndexChanged(Value: TNotifyEvent);
procedure SetOptionsBehavior(Value: TcxCustomGridTableOptionsBehavior);
procedure SetOptionsCustomize(Value: TcxCustomGridTableOptionsCustomize);
procedure SetOptionsData(Value: TcxCustomGridTableOptionsData);
procedure SetOptionsSelection(Value: TcxCustomGridTableOptionsSelection);
procedure SetOptionsView(Value: TcxCustomGridTableOptionsView);
procedure SetStyles(Value: TcxCustomGridTableViewStyles);
procedure CopyForEachRowProc(ARowIndex: Integer; ARowInfo: TcxRowInfo);
procedure RefreshItemIndexes;
protected
// IcxFilterControl
function IcxFilterControl.GetCaption = GetFilterCaption;
function IcxFilterControl.GetCount = GetFilterCount;
function IcxFilterControl.GetCriteria = GetFilterCriteria;
function IcxFilterControl.GetFieldName = GetFilterFieldName;
function IcxFilterControl.GetItemLink = GetFilterItemLink;
function IcxFilterControl.GetItemLinkID = GetFilterItemLinkID;
function IcxFilterControl.GetItemLinkName = GetFilterItemLinkName;
function IcxFilterControl.GetProperties = GetFilterProperties;
function IcxFilterControl.GetValueType = GetFilterValueType;
function GetFilterCaption(Index: Integer): string;
function GetFilterCount: Integer;
function GetFilterCriteria: TcxFilterCriteria;
function GetFilterFieldName(Index: Integer): string;
function GetFilterItemLink(Index: Integer): TObject;
function GetFilterItemLinkID(Index: Integer): Integer;
function GetFilterItemLinkName(Index: Integer): string;
function GetFilterProperties(Index: Integer): TcxCustomEditProperties;
function GetFilterValueType(Index: Integer): cxDataStorage.TcxValueTypeClass;
// IcxNavigator
function IcxNavigator.IsActive = NavigatorIsActive;
function IcxNavigator.IsBof = NavigatorIsBof;
function IcxNavigator.IsEof = NavigatorIsEof;
function IcxNavigator.CanAppend = NavigatorCanAppend;
function IcxNavigator.CanEdit = NavigatorCanEdit;
function IcxNavigator.CanDelete = NavigatorCanDelete;
function IcxNavigator.CanInsert = NavigatorCanInsert;
function IcxNavigator.IsEditing = NavigatorIsEditing;
procedure IcxNavigator.ClearBookmark = NavigatorClearBookmark;
function IcxNavigator.IsBookmarkAvailable = NavigatorIsBookmarkAvailable;
procedure IcxNavigator.DoAction = NavigatorDoAction;
function IcxNavigator.GetNotifier = NavigatorGetNotifier;
function IcxNavigator.IsActionSupported = NavigatorIsActionSupported;
function NavigatorIsActive: Boolean;
function NavigatorIsBof: Boolean;
function NavigatorIsEof: Boolean;
function NavigatorCanAppend: Boolean;
function NavigatorCanEdit: Boolean;
function NavigatorCanDelete: Boolean;
function NavigatorCanInsert: Boolean;
function NavigatorIsEditing: Boolean;
procedure NavigatorClearBookmark;
function NavigatorIsBookmarkAvailable: Boolean;
procedure NavigatorDoAction(AButtonIndex: Integer);
function NavigatorGetNotifier: TcxNavigatorControlNotifier;
function NavigatorIsActionSupported(AButtonIndex: Integer): Boolean;
// IcxStoredObject
function GetProperties(AProperties: TStrings): Boolean; override;
procedure GetPropertyValue(const AName: string; var AValue: Variant); override;
procedure SetPropertyValue(const AName: string; const AValue: Variant); override;
// IcxStoredParent
function CreateStoredObject(const AObjectName, AClassName: string): TObject; override;
procedure GetStoredChildren(AChildren: TStringList); override;
// IcxGridViewLayoutEditorSupport - for design-time layout editor
procedure AssignLayout(ALayoutView: TcxCustomGridView); override;
procedure BeforeEditLayout(ALayoutView: TcxCustomGridView); override;
function HasLayoutCustomizationForm: Boolean; override;
procedure BeforeRestoring; override;
procedure AfterRestoring; override;
procedure ReadState(Reader: TReader); override;
property RestoringItems: TcxGridOpenTableItemList read FRestoringItems;
procedure BeginAssignItems;
procedure DoBeforeAssignItems; virtual;
procedure DoItemsAssigned; virtual;
procedure EndAssignItems;
property AssigningGroupedItems: TcxGridOpenTableItemList read FAssigningGroupedItems;
property AssigningSortedItems: TcxGridOpenTableItemList read FAssigningSortedItems;
property IsAssigningItems: Boolean read FIsAssigningItems;
property IsAfterAssigningItems: Boolean read FIsAfterAssigningItems;
function CanOffset(ARecordCountDelta: Integer): Boolean; virtual;
function CanSelectRecord(ARecordIndex: Integer): Boolean; virtual;
function CanTabStop: Boolean; override;
procedure DetailVisibleChanged(ADetailLevel: TComponent;
APrevVisibleDetailCount, AVisibleDetailCount: Integer); override;
procedure DoAssign(ASource: TcxCustomGridView); override;
function FindItemByObjectName(const AObjectName: string): TcxCustomGridTableItem;
procedure FocusEdit(AItemIndex: Integer; var ADone: Boolean); virtual;
procedure GetChildren(Proc: TGetChildProc; Root: TComponent); override;
function GetDefaultActiveDetailIndex: Integer; virtual;
procedure GetFakeComponentLinks(AList: TList); override;
function GetIsControlFocused: Boolean; override;
procedure GetItemsListForClipboard(AItems: TList; ACopyAll: Boolean); virtual;
function GetItemSortByDisplayText(AItemIndex: Integer; ASortByDisplayText: Boolean): Boolean;
function GetItemValueSource(AItemIndex: Integer): TcxDataEditValueSource;
procedure GetVisibleItemsList(AItems: TList); virtual;
function HasCustomDrawCell: Boolean;
function HasCustomDrawPartBackground: Boolean;
procedure Init; override;
function IsDetailVisible(AGridView: TcxCustomGridView): Boolean; override;
function IsEqualHeightRecords: Boolean; virtual;
function IsRecordHeightDependsOnData: Boolean; virtual;
function IsRecordHeightDependsOnFocus: Boolean; virtual;
procedure LoadingComplete; override;
procedure Offset(ARecordCountDelta, DX, DY: Integer); virtual;
procedure SetChildOrder(Child: TComponent; Order: Integer); override;
procedure SetName(const NewName: TComponentName); override;
procedure UpdateControl(AInfo: TcxUpdateControlInfo); override;
procedure UpdateDataController(AChange: TcxGridDataControllerChange;
AItem: TcxCustomGridTableItem = nil);
procedure UpdateRecord; virtual;
procedure CreateHandlers; override;
procedure DestroyHandlers; override;
procedure CreateOptions; override;
procedure DestroyOptions; override;
procedure AddItem(AItem: TcxCustomGridTableItem); virtual;
procedure RemoveItem(AItem: TcxCustomGridTableItem); virtual;
procedure AssignVisibleItemsIndexes;
procedure ChangeItemIndex(AItem: TcxCustomGridTableItem; Value: Integer); virtual;
procedure CheckItemVisibles;
procedure SaveItemVisibles;
procedure ItemIndexChanged(AItem: TcxCustomGridTableItem; AOldIndex: Integer); virtual;
procedure ItemVisibilityChanged(AItem: TcxCustomGridTableItem; Value: Boolean); virtual;
procedure RefreshVisibleItemsList; virtual;
function GetItemClass: TcxCustomGridTableItemClass; virtual; abstract;
function GetItemDataBindingClass: TcxGridItemDataBindingClass; virtual;
function GetNextID: Integer;
procedure ReleaseID(AID: Integer);
procedure DataChanged; virtual;
procedure DataLayoutChanged; virtual;
function DoCellClick(ACellViewInfo: TcxGridTableDataCellViewInfo;
AButton: TMouseButton; AShift: TShiftState): Boolean; virtual;
function DoCellDblClick(ACellViewInfo: TcxGridTableDataCellViewInfo;
AButton: TMouseButton; AShift: TShiftState): Boolean; virtual;
function DoEditing(AItem: TcxCustomGridTableItem): Boolean; virtual;
procedure DoTopRecordIndexChanged; virtual;
procedure FilterChanged; virtual;
procedure FocusedItemChanged(APrevFocusedItem, AFocusedItem: TcxCustomGridTableItem); virtual;
procedure FocusedRecordChanged(APrevFocusedRecordIndex, AFocusedRecordIndex: Integer;
ANewItemRecordFocusingChanged: Boolean); virtual;
procedure GroupingChanging; virtual;
procedure ItemCaptionChanged(AItem: TcxCustomGridTableItem); virtual;
procedure ItemValueTypeClassChanged(AItemIndex: Integer); virtual;
procedure RecalculateDefaultWidths;
procedure RecordChanged(ARecordIndex: Integer); virtual;
procedure RecordCountChanged; virtual;
procedure RefreshFilterableItemsList;
procedure RefreshNavigators;
procedure SearchChanged; virtual;
procedure SelectionChanged(AInfo: TcxSelectionChangedInfo); virtual;
function CalculateDataCellSelected(ARecord: TcxCustomGridRecord;
AItem: TcxCustomGridTableItem; AUseViewInfo: Boolean;
ACellViewInfo: TcxGridTableCellViewInfo): Boolean; virtual;
function DrawDataCellSelected(ARecord: TcxCustomGridRecord; AItem: TcxCustomGridTableItem;
AUseViewInfo: Boolean = False; ACellViewInfo: TcxGridTableCellViewInfo = nil): Boolean; virtual;
function DrawRecordActive(ARecord: TcxCustomGridRecord): Boolean; virtual;
function DrawRecordFocused(ARecord: TcxCustomGridRecord): Boolean; virtual;
function DrawRecordSelected(ARecord: TcxCustomGridRecord): Boolean; virtual;
function DrawSelection: Boolean; virtual;
function DoCanFocusRecord(ARecord: TcxCustomGridRecord): Boolean; virtual;
procedure DoCustomDrawCell(ACanvas: TcxCanvas; AViewInfo: TcxGridTableDataCellViewInfo;
var ADone: Boolean); virtual;
procedure DoCustomDrawPartBackground(ACanvas: TcxCanvas; AViewInfo: TcxCustomGridCellViewInfo;
var ADone: Boolean); virtual;
procedure DoEditChanged(AItem: TcxCustomGridTableItem); virtual;
procedure DoEditKeyDown(AItem: TcxCustomGridTableItem; AEdit: TcxCustomEdit;
var Key: Word; Shift: TShiftState); virtual;
procedure DoEditKeyPress(AItem: TcxCustomGridTableItem; AEdit: TcxCustomEdit;
var Key: Char); virtual;
procedure DoEditKeyUp(AItem: TcxCustomGridTableItem; AEdit: TcxCustomEdit;
var Key: Word; Shift: TShiftState); virtual;
procedure DoEditValueChanged(AItem: TcxCustomGridTableItem); virtual;
function DoFilterCustomization: Boolean; virtual;
function DoFilterDialogShow(AItem: TcxCustomGridTableItem): Boolean; virtual;
procedure DoFocusedRecordChanged(APrevFocusedRecordIndex, AFocusedRecordIndex: Integer;
ANewItemRecordFocusingChanged: Boolean); virtual;
procedure DoGetCellHeight(ARecord: TcxCustomGridRecord; AItem: TcxCustomGridTableItem;
ACellViewInfo: TcxGridTableDataCellViewInfo; var AHeight: Integer); virtual;
function DoGetDragDropText(ARecord: TcxCustomGridRecord; AItem: TcxCustomGridTableItem): string; virtual;
procedure DoInitEdit(AItem: TcxCustomGridTableItem; AEdit: TcxCustomEdit); virtual;
procedure DoInitEditValue(AItem: TcxCustomGridTableItem; AEdit: TcxCustomEdit;
var AValue: TcxEditValue); virtual;
procedure DoInitFilteringDateRanges(AItem: TcxCustomGridTableItem); virtual;
procedure DoInitGroupingDateRanges(AItem: TcxCustomGridTableItem); virtual;
//procedure DoRecordCreated(ARecord: TcxCustomGridRecord); virtual;
//procedure DoRecordDestroying(ARecord: TcxCustomGridRecord); virtual;
procedure DoSelectionChanged; virtual;
function HasCustomProperties: Boolean;
function HasInitFilteringDateRangesHandler: Boolean;
function HasInitGroupingDateRangesHandler: Boolean;
function IsGetCellHeightAssigned: Boolean;
function GetControllerClass: TcxCustomGridControllerClass; override;
function GetPainterClass: TcxCustomGridPainterClass; override;
function GetViewDataClass: TcxCustomGridViewDataClass; override;
function GetViewInfoCacheClass: TcxCustomGridViewInfoCacheClass; override;
function GetViewInfoClass: TcxCustomGridViewInfoClass; override;
function GetBackgroundBitmapsClass: TcxCustomGridBackgroundBitmapsClass; override;
function GetDateTimeHandlingClass: TcxCustomGridTableDateTimeHandlingClass; virtual;
function GetFilterBoxClass: TcxGridFilterBoxClass; virtual;
function GetFilteringClass: TcxCustomGridTableFilteringClass; virtual;
function GetNavigatorButtonsClass: TcxNavigatorControlButtonsClass; virtual;
function GetOptionsBehaviorClass: TcxCustomGridOptionsBehaviorClass; override;
function GetOptionsCustomizeClass: TcxCustomGridTableOptionsCustomizeClass; virtual;
function GetOptionsDataClass: TcxCustomGridOptionsDataClass; override;
function GetOptionsSelectionClass: TcxCustomGridOptionsSelectionClass; override;
function GetOptionsViewClass: TcxCustomGridOptionsViewClass; override;
function GetStylesClass: TcxCustomGridViewStylesClass; override;
function GetSummaryGroupItemLinkClass: TcxDataSummaryGroupItemLinkClass; virtual;
function GetSummaryItemClass: TcxDataSummaryItemClass; virtual;
property BackgroundBitmaps: TcxCustomGridTableBackgroundBitmaps read GetBackgroundBitmaps
write SetBackgroundBitmaps;
property DontMakeMasterRecordVisible: Boolean read FDontMakeMasterRecordVisible
write FDontMakeMasterRecordVisible;
property FilterableItemCount: Integer read GetFilterableItemCount;
property FilterableItems[Index: Integer]: TcxCustomGridTableItem read GetFilterableItem;
property IgnorePropertiesChanges: Boolean read FIgnorePropertiesChanges write FIgnorePropertiesChanges;
property ItemsList: TList read FItems;
property NavigatorNotifier: TcxNavigatorControlNotifier read FNavigatorNotifier;
property NextID: Integer read FNextID;
property VisibleItemsList: TList read FVisibleItems;
property OnInitGroupingDateRanges: TcxGridInitDateRangesEvent read FOnInitGroupingDateRanges write SetOnInitGroupingDateRanges;
public
destructor Destroy; override;
procedure ApplyBestFit(AItem: TcxCustomGridTableItem = nil; ACheckSizingAbility: Boolean = False;
AFireEvents: Boolean = False); virtual;
procedure ClearItems;
procedure CopyToClipboard(ACopyAll: Boolean);
function CreateItem: TcxCustomGridTableItem;
function FindItemByID(AID: Integer): TcxCustomGridTableItem;
function FindItemByName(const AName: string): TcxCustomGridTableItem;
function FindItemByTag(ATag: TcxTag): TcxCustomGridTableItem;
function IndexOfItem(AItem: TcxCustomGridTableItem): Integer;
procedure MakeMasterGridRecordVisible;
procedure RestoreDefaults; override;
// for extended lookup edit
class function CanBeLookupList: Boolean; virtual;
property Controller: TcxCustomGridTableController read GetController;
property DateTimeHandling: TcxCustomGridTableDateTimeHandling read FDateTimeHandling write SetDateTimeHandling;
property Filtering: TcxCustomGridTableFiltering read FFiltering write SetFiltering;
property GroupedItemCount: Integer read GetGroupedItemCount;
property GroupedItems[Index: Integer]: TcxCustomGridTableItem read GetGroupedItem;
property ItemCount: Integer read GetItemCount;
property Items[Index: Integer]: TcxCustomGridTableItem read GetItem write SetItem;
property MasterGridRecord: TcxCustomGridRecord read GetMasterGridRecord;
property OptionsBehavior: TcxCustomGridTableOptionsBehavior read GetOptionsBehavior
write SetOptionsBehavior;
property OptionsCustomize: TcxCustomGridTableOptionsCustomize read FOptionsCustomize
write SetOptionsCustomize;
property OptionsData: TcxCustomGridTableOptionsData read GetOptionsData write SetOptionsData;
property OptionsSelection: TcxCustomGridTableOptionsSelection read GetOptionsSelection
write SetOptionsSelection;
property OptionsView: TcxCustomGridTableOptionsView read GetOptionsView write SetOptionsView;
property Painter: TcxCustomGridTablePainter read GetPainter;
property PatternGridView: TcxCustomGridTableView read GetPatternGridView;
property SortedItemCount: Integer read GetSortedItemCount;
property SortedItems[Index: Integer]: TcxCustomGridTableItem read GetSortedItem;
property Styles: TcxCustomGridTableViewStyles read GetStyles write SetStyles;
property ViewData: TcxCustomGridTableViewData read GetViewData;
property ViewInfo: TcxCustomGridTableViewInfo read GetViewInfo;
property VisibleItemCount: Integer read GetVisibleItemCount;
property VisibleItems[Index: Integer]: TcxCustomGridTableItem read GetVisibleItem;
published
property NavigatorButtons: TcxNavigatorControlButtons read FNavigatorButtons write SetNavigatorButtons;
property FilterBox: TcxGridFilterBox read FFilterBox write SetFilterBox;
property NavigatorButtonsEvents: TNotifyEvent read FSubClassEvents write FSubClassEvents;
property OnCanFocusRecord: TcxGridAllowRecordOperationEvent read FOnCanFocusRecord write SetOnCanFocusRecord;
property OnCanSelectRecord: TcxGridAllowRecordOperationEvent read FOnCanSelectRecord write SetOnCanSelectRecord;
property OnCellClick: TcxGridCellClickEvent read FOnCellClick write SetOnCellClick;
property OnCellDblClick: TcxGridCellClickEvent read FOnCellDblClick write SetOnCellDblClick;
property OnCustomDrawCell: TcxGridTableDataCellCustomDrawEvent read FOnCustomDrawCell write SetOnCustomDrawCell;
property OnCustomDrawPartBackground: TcxGridPartCustomDrawBackgroundEvent
read FOnCustomDrawPartBackground write SetOnCustomDrawPartBackground;
property OnEditing: TcxGridEditingEvent read FOnEditing write SetOnEditing;
property OnEditChanged: TcxGridCustomTableItemEvent read FOnEditChanged write SetOnEditChanged;
property OnEditKeyDown: TcxGridEditKeyEvent read FOnEditKeyDown write SetOnEditKeyDown;
property OnEditKeyPress: TcxGridEditKeyPressEvent read FOnEditKeyPress write SetOnEditKeyPress;
property OnEditKeyUp: TcxGridEditKeyEvent read FOnEditKeyUp write SetOnEditKeyUp;
property OnEditValueChanged: TcxGridCustomTableItemEvent read FOnEditValueChanged write SetOnEditValueChanged;
property OnFilterControlDialogShow: TNotifyEvent read FOnFilterControlDialogShow
write SetOnFilterControlDialogShow;
property OnFilterCustomization: TcxGridFilterCustomizationEvent read FOnFilterCustomization
write SetOnFilterCustomization;
property OnFilterDialogShow: TcxGridFilterDialogShowEvent read FOnFilterDialogShow
write SetOnFilterDialogShow;
property OnFocusedItemChanged: TcxGridFocusedItemChangedEvent read FOnFocusedItemChanged
write SetOnFocusedItemChanged;
property OnFocusedRecordChanged: TcxGridFocusedRecordChangedEvent read FOnFocusedRecordChanged
write SetOnFocusedRecordChanged;
property OnGetCellHeight: TcxGridGetCellHeightEvent read FOnGetCellHeight write SetOnGetCellHeight;
property OnGetDragDropText: TcxGridGetDragDropTextEvent read FOnGetDragDropText write SetOnGetDragDropText;
property OnInitEdit: TcxGridInitEditEvent read FOnInitEdit write SetOnInitEdit;
property OnInitEditValue: TcxGridInitEditValueEvent read FOnInitEditValue write SetOnInitEditValue;
property OnInitFilteringDateRanges: TcxGridInitDateRangesEvent read FOnInitFilteringDateRanges write SetOnInitFilteringDateRanges;
property OnInitStoredObject;
//property OnRecordCreated: TcxGridRecordEvent read FOnRecordCreated write FOnRecordCreated;
//property OnRecordDestroying: TcxGridRecordEvent read FOnRecordDestroying write FOnRecordDestroying;
property OnSelectionChanged: TcxGridCustomTableViewEvent read FOnSelectionChanged write SetOnSelectionChanged;
property OnTopRecordIndexChanged: TNotifyEvent read FOnTopRecordIndexChanged write SetOnTopRecordIndexChanged;
end;
{ TcxCustomGridTableControllerAccess }
TcxCustomGridTableControllerAccess = class
public
class procedure FocusNextPage(AInstance: TcxCustomGridTableController;
ASyncSelection: Boolean);
class procedure FocusPrevPage(AInstance: TcxCustomGridTableController;
ASyncSelection: Boolean);
end;
{ TcxCustomGridTableItemAccess }
TcxCustomGridTableItemAccess = class
public
class function CanGroup(AInstance: TcxCustomGridTableItem): Boolean;
class function CanHide(AInstance: TcxCustomGridTableItem): Boolean;
class function CanHorzSize(AInstance: TcxCustomGridTableItem): Boolean;
class function CanSort(AInstance: TcxCustomGridTableItem): Boolean;
class procedure CheckWidthValue(AInstance: TcxCustomGridTableItem;
var Value: Integer);
class procedure DoGetDataText(AInstance: TcxCustomGridTableItem;
ARecordIndex: Integer; var AText: string);
class procedure DoGetDisplayText(AInstance: TcxCustomGridTableItem;
ARecord: TcxCustomGridRecord; var AText: string);
class function GetGroupIndex(AInstance: TcxCustomGridTableItem): Integer;
class function GetFilterCaption(AInstance: TcxCustomGridTableItem): string;
end;
{ TcxCustomGridTableOptionsBehaviorAccess }
TcxCustomGridTableOptionsBehaviorAccess = class
public
class function GetPullFocusing(
AInstance: TcxCustomGridTableOptionsBehavior): Boolean;
class procedure SetPullFocusing(
AInstance: TcxCustomGridTableOptionsBehavior; Value: Boolean);
end;
{ TcxCustomGridTableOptionsViewAccess }
TcxCustomGridTableOptionsViewAccess = class
public
class function GetCellAutoHeight(AInstance: TcxCustomGridTableOptionsView): Boolean;
end;
{ TcxCustomGridTableViewAccess }
TcxCustomGridTableViewAccess = class
public
class function CanSelectRecord(AInstance: TcxCustomGridTableView;
ARecordIndex: Integer): Boolean;
class procedure FilterChanged(AInstance: TcxCustomGridTableView);
class function FindItemByObjectName(AInstance: TcxCustomGridTableView;
const AObjectName: string): TcxCustomGridTableItem;
class procedure FocusEdit(AInstance: TcxCustomGridTableView;
AItemIndex: Integer; var ADone: Boolean);
class function GetDefaultActiveDetailIndex(
AInstance: TcxCustomGridTableView): Integer;
class function GetItemClass(AInstance: TcxCustomGridTableView): TcxCustomGridTableItemClass;
class function GetItemSortByDisplayText(AInstance: TcxCustomGridTableView;
AItemIndex: Integer; ASortByDisplayText: Boolean): Boolean;
class function GetItemValueSource(AInstance: TcxCustomGridTableView;
AItemIndex: Integer): TcxDataEditValueSource;
class function GetSummaryGroupItemLinkClass(
AInstance: TcxCustomGridTableView): TcxDataSummaryGroupItemLinkClass;
class function GetSummaryItemClass(
AInstance: TcxCustomGridTableView): TcxDataSummaryItemClass;
class function IsEqualHeightRecords(
AInstance: TcxCustomGridTableView): Boolean;
class function IsGetCellHeightAssigned(
AInstance: TcxCustomGridTableView): Boolean;
class procedure ItemValueTypeClassChanged(AInstance: TcxCustomGridTableView;
AItemIndex: Integer);
class procedure RefreshNavigators(AInstance: TcxCustomGridTableView);
class procedure UpdateRecord(AInstance: TcxCustomGridTableView);
end;
{ TcxCustomGridTableViewInfoAccess }
TcxCustomGridTableViewInfoAccess = class
public
class function GetDefaultGridModeBufferCount(AInstance: TcxCustomGridTableViewInfo): Integer;
end;
implementation
uses
{$IFDEF DELPHI6}
DateUtils,
{$ENDIF}
Math, SysUtils, TypInfo,
Clipbrd, cxScrollBar, cxVariants, cxDateUtils,
cxTextEdit, cxEditUtils, cxFilterDialog, cxFilterControlDialog,
cxEditDataRegisteredRepositoryItems, cxFilterConsts,
cxGrid, cxGridStrs, cxGridLevel, cxLibraryConsts;
const
RecordIndexNone = -1;
EditStartChars = [#8, ^V, ^X, #32..#255];
IncSearchStartChars = [#8, #32..#255];
PullFocusingScrollingTimeInterval = 50;
// Copy to text format
EndOfLine = #13#10;
ColumnSeparator = #9;
FilterButtonsFirstOffset = 4;
FilterButtonsOffset = 4;
FilterTextOffset = 3;
DragDropTextAreaOffset = 25;
DragDropTextBorderSize = 3;
DragDropTextIndent = DragDropTextBorderSize + cxGridCellTextOffset;
ScrollTimeInterval = 35;
FilterMRUItemBaseName = 'FilterMRUItem';
DateTimeRelativeFilters = [dtfRelativeDays..dtfPastFuture];
DateTimeAbsoluteFilters = [dtfMonths, dtfYears];
CustomizationPopupCheckListBoxColumnOffset = 10;
CustomizationPopupCheckListBoxScrollZoneWidth = 15;
CustomizationPopupCheckListBoxScrollTimeInterval = 400;
type
TControlAccess = class(TControl);
TcxControlAccess = class(TcxControl);
TcxCustomGridAccess = class(TcxCustomGrid);
TcxCustomGridViewAccess = class(TcxCustomGridView);
TcxGridLevelAccess = class(TcxGridLevel);
function cxCustomGridTableControllerCanFocusItem(AOwner: TcxCustomGridTableView;
AItemIndex: Integer; AData: TObject): Boolean;
begin
Result := AOwner.VisibleItems[AItemIndex].CanFocus(TcxCustomGridRecord(AData));
end;
function cxCustomGridTableControllerCanFocusRecord(
AOwner: TcxCustomGridTableView; AItemIndex: Integer;
AData: TObject): Boolean;
begin
Result := AOwner.ViewData.Records[AItemIndex].CanFocus;
end;
function cxCustomGridTableViewGetItem(ACaller: TComponent;
Index: Integer): TComponent;
begin
Result := TcxCustomGridTableView(ACaller).Items[Index];
end;
{ TcxGridDataChange }
procedure TcxGridDataChange.Execute;
begin
with GridView as TcxCustomGridTableView do
begin
RecordCountChanged;
//Controller.MakeFocusedRecordVisible; removed because of group nodes expanding
end;
end;
function TcxGridDataChange.IsLockable: Boolean;
begin
Result := False;
end;
{ TcxGridRecordChange }
constructor TcxGridRecordChange.Create(AGridView: TcxCustomGridView;
ARecord: TcxCustomGridRecord; ARecordIndex: Integer; AItem: TcxCustomGridTableItem = nil);
begin
inherited Create(AGridView);
FRecord := ARecord;
FRecordIndex := ARecordIndex;
FItem := AItem;
end;
function TcxGridRecordChange.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
function TcxGridRecordChange.GetRecordViewInfo: TcxCustomGridRecordViewInfo;
begin
Result := GridView.ViewInfo.RecordsViewInfo.GetRealItem(FRecord);
end;
procedure TcxGridRecordChange.Execute;
begin
if (RecordViewInfo = nil) or (FItem <> nil) and not IsItemVisible or
not GridView.Changeable then Exit;
RecordViewInfo.Recalculate;
GridView.ViewChanged(RecordViewInfo.GetBoundsForInvalidate(FItem));
end;
function TcxGridRecordChange.IsCompatibleWith(AChange: TcxCustomGridChange): Boolean;
begin
Result := inherited IsCompatibleWith(AChange) or
((AChange is TcxGridLayoutChange) or (AChange is TcxGridSizeChange) or (AChange is TcxGridDataChange)) and
(TcxCustomGridViewChange(AChange).GridView <> nil) and (TcxCustomGridViewChange(AChange).GridView = GridView);
end;
function TcxGridRecordChange.IsEqual(AChange: TcxCustomGridChange): Boolean;
begin
Result := inherited IsEqual(AChange) and
(GridRecord = TcxGridRecordChange(AChange).GridRecord) and
(RecordIndex = TcxGridRecordChange(AChange).RecordIndex) and
(Item = TcxGridRecordChange(AChange).Item);
end;
function TcxGridRecordChange.IsItemVisible: Boolean;
begin
Result := (GridView.IndexOfItem(FItem) <> -1) and FItem.ActuallyVisible;
end;
{ TcxGridFocusedRecordChange }
constructor TcxGridFocusedRecordChange.Create(AGridView: TcxCustomGridView;
APrevFocusedRecordIndex, AFocusedRecordIndex: Integer; ANewItemRecordFocusingChanged: Boolean);
begin
inherited Create(AGridView);
FPrevFocusedRecordIndex := APrevFocusedRecordIndex;
FFocusedRecordIndex := AFocusedRecordIndex;
FNewItemRecordFocusingChanged := ANewItemRecordFocusingChanged;
end;
function TcxGridFocusedRecordChange.CanExecuteWhenLocked: Boolean;
begin
Result := False;
end;
procedure TcxGridFocusedRecordChange.Execute;
begin
with GridView as TcxCustomGridTableView do
//if Changeable then - should work with Visible = False (to show details)
begin
if DataController.IsGridMode then Controller.UpdateScrollBars;
if (FFocusedRecordIndex <> FPrevFocusedRecordIndex) or FNewItemRecordFocusingChanged then
Controller.MakeFocusedRecordVisible;
if IsRecordHeightDependsOnFocus then
SizeChanged
else
with ViewData do
begin
if IsRecordIndexValid(FPrevFocusedRecordIndex) then
Records[FPrevFocusedRecordIndex].Invalidate;
if IsRecordIndexValid(FFocusedRecordIndex) then
Records[FFocusedRecordIndex].Invalidate;
if FNewItemRecordFocusingChanged and HasNewItemRecord then
NewItemRecord.Invalidate;
end;
Controller.CheckEdit;
Controller.EditingController.UpdateEditValue;
DoFocusedRecordChanged(FPrevFocusedRecordIndex, FFocusedRecordIndex,
FNewItemRecordFocusingChanged); // see 23172
end;
end;
{ TcxGridFilterHitTest }
class function TcxGridFilterHitTest.GetHitTestCode: Integer;
begin
Result := htFilter;
end;
{ TcxGridFilterCloseButtonHitTest }
class function TcxGridFilterCloseButtonHitTest.GetHitTestCode: Integer;
begin
Result := htFilterCloseButton;
end;
{ TcxGridFilterActivateButtonHitTest }
class function TcxGridFilterActivateButtonHitTest.GetHitTestCode: Integer;
begin
Result := htFilterActivateButton;
end;
{ TcxGridFilterDropDownButtonHitTest }
class function TcxGridFilterDropDownButtonHitTest.GetHitTestCode: Integer;
begin
Result := htFilterDropDownButton;
end;
{ TcxGridFilterCustomizeButtonHitTest }
class function TcxGridFilterCustomizeButtonHitTest.GetHitTestCode: Integer;
begin
Result := htFilterCustomizeButton;
end;
{ TcxGridRecordHitTest }
function TcxGridRecordHitTest.GetGridRecord: TcxCustomGridRecord;
begin
if FViewData = nil then
Result := nil
else
Result := FViewData.GetRecordByKind(FGridRecordKind, FGridRecordIndex);
end;
procedure TcxGridRecordHitTest.SetGridRecord(Value: TcxCustomGridRecord);
begin
if Value <> nil then
begin
FViewData := Value.ViewData;
FGridRecordIndex := Value.Index;
FGridRecordKind := FViewData.GetRecordKind(Value);
end
else
begin
FViewData := nil;
FGridRecordIndex := -1;
FGridRecordKind := rkNone;
end;
end;
class function TcxGridRecordHitTest.GetHitTestCode: Integer;
begin
Result := htRecord;
end;
class function TcxGridRecordHitTest.CanClick: Boolean;
begin
Result := True;
end;
{ TcxGridRecordCellHitTest }
class function TcxGridRecordCellHitTest.GetHitTestCode: Integer;
begin
Result := htCell;
end;
{ TcxGridExpandButtonHitTest }
class function TcxGridExpandButtonHitTest.GetHitTestCode: Integer;
begin
Result := htExpandButton;
end;
class function TcxGridExpandButtonHitTest.CanClick: Boolean;
begin
Result := False;
end;
{ TcxGridDefaultValuesProvider }
function TcxGridDefaultValuesProvider.IsDisplayFormatDefined(AIsCurrencyValueAccepted: Boolean): Boolean;
begin
Result := TcxGridItemDataBinding(Owner).IsDisplayFormatDefined(AIsCurrencyValueAccepted);
end;
{ TcxGridDataController }
function TcxGridDataController.GetGridViewValue: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(GetGridView);
end;
procedure TcxGridDataController.ReadData(Stream: TStream);
var
ASize: Integer;
begin
Stream.Read(ASize, SizeOf(ASize));
FLoadedData := TMemoryStream.Create;
FLoadedData.CopyFrom(Stream, ASize);
FLoadedData.Position := 0;
end;
procedure TcxGridDataController.WriteData(Stream: TStream);
var
AStream: TMemoryStream;
ASize: Integer;
begin
AStream := TMemoryStream.Create;
try
SaveToStream(AStream);
ASize := AStream.Size;
Stream.Write(ASize, SizeOf(ASize));
AStream.SaveToStream(Stream);
finally
AStream.Free;
end;
end;
procedure TcxGridDataController.AssignData(ADataController: TcxCustomDataController);
var
AStream: TMemoryStream;
begin
AStream := TMemoryStream.Create;
try
ADataController.SaveToStream(AStream);
AStream.Position := 0;
LoadFromStream(AStream);
finally
AStream.Free;
end;
end;
procedure TcxGridDataController.CreateAllItems(AMissingItemsOnly: Boolean);
begin
end;
procedure TcxGridDataController.DeleteAllItems;
begin
end;
procedure TcxGridDataController.GetFakeComponentLinks(AList: TList);
begin
end;
function TcxGridDataController.GetGridView: TcxCustomGridView;
begin
Result := TcxCustomGridView(GetOwner);
end;
function TcxGridDataController.HasAllItems: Boolean;
begin
Result := True;
end;
function TcxGridDataController.IsDataChangeable: Boolean;
begin
Result := True;
end;
function TcxGridDataController.IsDataLinked: Boolean;
begin
Result := True;
end;
function TcxGridDataController.SupportsCreateAllItems: Boolean;
begin
Result := False;
end;
procedure TcxGridDataController.CheckGridModeBufferCount;
begin
end;
function TcxGridDataController.DoScroll(AForward: Boolean): Boolean;
begin
Result := False;
end;
function TcxGridDataController.DoScrollPage(AForward: Boolean): Boolean;
begin
Result := False;
end;
{function TcxGridDataController.GetFilterPropertyValue(const AName: string;
var AValue: Variant): Boolean;
begin
Result := False;
end;}
function TcxGridDataController.GetItemDataBindingClass: TcxGridItemDataBindingClass;
begin
Result := TcxGridItemDataBinding;
end;
function TcxGridDataController.GetItemDefaultValuesProviderClass: TcxCustomEditDefaultValuesProviderClass;
begin
Result := TcxGridDefaultValuesProvider;
end;
function TcxGridDataController.GetNavigatorIsBof: Boolean;
begin
Result := GridView.Controller.IsStart;
end;
function TcxGridDataController.GetNavigatorIsEof: Boolean;
begin
Result := GridView.Controller.IsFinish;
end;
function TcxGridDataController.GetScrollBarPos: Integer;
begin
Result := -1;
end;
function TcxGridDataController.GetScrollBarRecordCount: Integer;
begin
Result := -1;
end;
{function TcxGridDataController.SetFilterPropertyValue(const AName: string;
const AValue: Variant): Boolean;
begin
Result := False;
end;}
function TcxGridDataController.SetScrollBarPos(Value: Integer): Boolean;
begin
Result := False;
end;
function TcxGridDataController.CanSelectRow(ARowIndex: Integer): Boolean;
begin
Result := GridView.CanSelectRecord(ARowIndex);
end;
function TcxGridDataController.CompareByField(ARecordIndex1, ARecordIndex2: Integer;
AField: TcxCustomDataField; AMode: TcxDataControllerComparisonMode): Integer;
begin
if GridView.ViewData.NeedsCustomDataComparison(AField, AMode) then
Result := GridView.ViewData.CustomCompareDataValues(AField,
GetComparedValue(ARecordIndex1, AField), GetComparedValue(ARecordIndex2, AField), AMode)
else
Result := inherited CompareByField(ARecordIndex1, ARecordIndex2, AField, AMode);
end;
procedure TcxGridDataController.DefineProperties(Filer: TFiler);
begin
inherited;
if not IsProviderMode then
Filer.DefineBinaryProperty('Data', ReadData, WriteData, RecordCount <> 0);
end;
procedure TcxGridDataController.DoValueTypeClassChanged(AItemIndex: Integer);
begin
inherited;
GridView.ItemValueTypeClassChanged(AItemIndex);
end;
procedure TcxGridDataController.FilterChanged;
begin
inherited;
GridView.FilterChanged;
end;
function TcxGridDataController.GetDefaultActiveRelationIndex: Integer;
begin
Result := GridView.GetDefaultActiveDetailIndex;
end;
function TcxGridDataController.GetFilterDisplayText(ARecordIndex, AItemIndex: Integer): string;
begin
if GridView.ViewData.HasCustomDataHandling(Fields[AItemIndex], doFiltering) then
Result := GridView.ViewData.GetCustomDataDisplayText(ARecordIndex, AItemIndex, doFiltering)
else
Result := inherited GetFilterDisplayText(ARecordIndex, AItemIndex);
end;
{function TcxGridDataController.GetIncrementalSearchText(ARecordIndex, AItemIndex: Integer): string;
begin
if not GridView.GetDisplayText(ARecordIndex, AItemIndex, Result) then
Result := inherited GetIncrementalSearchText(ARecordIndex, AItemIndex);
end;}
function TcxGridDataController.GetItemID(AItem: TObject): Integer;
begin
if AItem is TcxCustomGridTableItem then
Result := TcxCustomGridTableItem(AItem).ID
else
Result := -1;
end;
function TcxGridDataController.GetSortingBySummaryEngineClass: TcxSortingBySummaryEngineClass;
begin
Result := GridView.ViewData.GetSortingBySummaryEngineClass;
end;
function TcxGridDataController.GetSummaryGroupItemLinkClass: TcxDataSummaryGroupItemLinkClass;
begin
Result := GridView.GetSummaryGroupItemLinkClass;
if Result = nil then
Result := inherited GetSummaryGroupItemLinkClass;
end;
function TcxGridDataController.GetSummaryItemClass: TcxDataSummaryItemClass;
begin
Result := GridView.GetSummaryItemClass;
if Result = nil then
Result := inherited GetSummaryItemClass;
end;
procedure TcxGridDataController.BeginFullUpdate;
begin
GridView.BeginUpdate;
inherited;
end;
procedure TcxGridDataController.EndFullUpdate;
begin
inherited;
GridView.EndUpdate;
end;
function TcxGridDataController.CreateDetailLinkObject(ARelation: TcxCustomDataRelation;
ARecordIndex: Integer): TObject;
begin
Result := TcxGridLevelAccess(ARelation.Item).CreateLinkObject(ARelation, ARecordIndex);
end;
procedure TcxGridDataController.FocusControl(AItemIndex: Integer; var Done: Boolean);
begin
inherited;
GridView.FocusEdit(AItemIndex, Done);
end;
function TcxGridDataController.GetDetailDataControllerByLinkObject(ALinkObject: TObject): TcxCustomDataController;
begin
Result := TcxCustomGridView(ALinkObject).DataController;
end;
function TcxGridDataController.GetDisplayText(ARecordIndex, AItemIndex: Integer): string;
begin
if not GridView.ViewData.GetDisplayText(ARecordIndex, AItemIndex, Result) then
Result := inherited GetDisplayText(ARecordIndex, AItemIndex);
GridView.Items[AItemIndex].DoGetDataText(ARecordIndex, Result);
end;
function TcxGridDataController.GetFilterDataValue(ARecordIndex: Integer; AField: TcxCustomDataField): Variant;
begin
Result := inherited GetFilterDataValue(ARecordIndex, AField);
if GridView.ViewData.HasCustomDataHandling(AField, doFiltering) then
Result := GridView.ViewData.GetCustomDataValue(AField, Result, doFiltering);
end;
function TcxGridDataController.GetFilterItemFieldCaption(AItem: TObject): string;
begin
Result := TcxCustomGridTableItem(AItem).FilterCaption;
end;
function TcxGridDataController.GetItem(Index: Integer): TObject;
begin
Result := GridView.Items[Index];
end;
function TcxGridDataController.GetItemSortByDisplayText(AItemIndex: Integer;
ASortByDisplayText: Boolean): Boolean;
begin
Result := GridView.GetItemSortByDisplayText(AItemIndex, ASortByDisplayText);
end;
function TcxGridDataController.GetItemValueSource(AItemIndex: Integer): TcxDataEditValueSource;
begin
Result := GridView.GetItemValueSource(AItemIndex);
end;
procedure TcxGridDataController.Loaded;
begin
inherited;
if FLoadedData <> nil then
try
LoadFromStream(FLoadedData);
finally
FLoadedData.Free;
end;
end;
procedure TcxGridDataController.UpdateData;
begin
inherited;
GridView.UpdateRecord;
end;
{ TcxGridFilterValueList }
procedure TcxGridFilterValueList.AddDateTimeAbsoluteFilters(ADateRange: TcxCustomGridDateRange;
AIgnoreTime: Boolean);
var
I: Integer;
ADateTime: TDateTime;
ADateRangeValue: Variant;
begin
I := GetStartValueIndex;
while I < Count do
begin
ADateTime := Items[I].Value;
if ADateRange.Contains(ADateTime) then
begin
ADateRangeValue := ADateRange.GetRangeValue(ADateTime, AIgnoreTime);
if FindItemByKind(fviSpecial, ADateRangeValue) = -1 then
begin
Add(fviSpecial, ADateRangeValue, ADateRange.GetDisplayText(ADateTime), True);
Inc(I);
end;
end;
Inc(I);
end;
end;
procedure TcxGridFilterValueList.AddDateTimeAbsoluteFilters(AItem: TcxCustomGridTableItem);
var
I: Integer;
begin
AItem.InitFilteringDateRanges;
for I := 0 to AItem.FilteringDateRanges.Count - 1 do
AddDateTimeAbsoluteFilters(AItem.FilteringDateRanges[I], AItem.CanIgnoreTimeForFiltering);
end;
procedure TcxGridFilterValueList.AddDateTimeRelativeFilters(AItem: TcxCustomGridTableItem);
var
AFilters: TcxGridDateTimeFilters;
AFilter: TcxGridDateTimeFilter;
begin
AFilters := AItem.GetDateTimeFilters;
for AFilter := Low(AFilter) to High(AFilter) do
if AFilter in AFilters then
case AFilter of
dtfRelativeDays:
begin
Add(fviSpecial, foYesterday, cxGetResourceString(@scxGridYesterday), True);
Add(fviSpecial, foToday, cxGetResourceString(@scxGridToday), True);
Add(fviSpecial, foTomorrow, cxGetResourceString(@scxGridTomorrow), True);
end;
dtfRelativeDayPeriods:
begin
Add(fviSpecial, foLast30Days, cxGetResourceString(@scxGridLast30Days), True);
Add(fviSpecial, foLast14Days, cxGetResourceString(@scxGridLast14Days), True);
Add(fviSpecial, foLast7Days, cxGetResourceString(@scxGridLast7Days), True);
Add(fviSpecial, foNext7Days, cxGetResourceString(@scxGridNext7Days), True);
Add(fviSpecial, foNext14Days, cxGetResourceString(@scxGridNext14Days), True);
Add(fviSpecial, foNext30Days, cxGetResourceString(@scxGridNext30Days), True);
end;
dtfRelativeWeeks:
begin
Add(fviSpecial, foLastTwoWeeks, cxGetResourceString(@scxGridLastTwoWeeks), True);
Add(fviSpecial, foLastWeek, cxGetResourceString(@scxGridLastWeek), True);
Add(fviSpecial, foThisWeek, cxGetResourceString(@scxGridThisWeek), True);
Add(fviSpecial, foNextWeek, cxGetResourceString(@scxGridNextWeek), True);
Add(fviSpecial, foNextTwoWeeks, cxGetResourceString(@scxGridNextTwoWeeks), True);
end;
dtfRelativeMonths:
begin
Add(fviSpecial, foLastMonth, cxGetResourceString(@scxGridLastMonth), True);
Add(fviSpecial, foThisMonth, cxGetResourceString(@scxGridThisMonth), True);
Add(fviSpecial, foNextMonth, cxGetResourceString(@scxGridNextMonth), True);
end;
dtfRelativeYears:
begin
Add(fviSpecial, foLastYear, cxGetResourceString(@scxGridLastYear), True);
Add(fviSpecial, foThisYear, cxGetResourceString(@scxGridThisYear), True);
Add(fviSpecial, foNextYear, cxGetResourceString(@scxGridNextYear), True);
end;
dtfPastFuture:
begin
Add(fviSpecial, foInPast, cxGetResourceString(@scxGridPast), True);
Add(fviSpecial, foInFuture, cxGetResourceString(@scxGridFuture), True);
end;
end;
(* !!!
if dtfRelativeDay in AFilterItems then
begin
Add(fviSpecial, foYesterday, cxGetResourceString(@scxGridYesterday), True);
Add(fviSpecial, foToday, cxGetResourceString(@scxGridToday), True);
Add(fviSpecial, foTomorrow, cxGetResourceString(@scxGridTomorrow), True);
end;
if dtfRelativeWeek in AFilterItems then
Add(fviSpecial, foLastWeek, cxGetResourceString(@scxGridLastWeek), True);
if dtfRelativeMonth in AFilterItems then
Add(fviSpecial, foLastMonth, cxGetResourceString(@scxGridLastMonth), True);
if dtfRelativeYear in AFilterItems then
Add(fviSpecial, foLastYear, cxGetResourceString(@scxGridLastYear), True);
if dtfRelativeWeek in AFilterItems then
Add(fviSpecial, foThisWeek, cxGetResourceString(@scxGridThisWeek), True);
if dtfRelativeMonth in AFilterItems then
Add(fviSpecial, foThisMonth, cxGetResourceString(@scxGridThisMonth), True);
if dtfRelativeYear in AFilterItems then
Add(fviSpecial, foThisYear, cxGetResourceString(@scxGridThisYear), True);
if dtfRelativeWeek in AFilterItems then
Add(fviSpecial, foNextWeek, cxGetResourceString(@scxGridNextWeek), True);
if dtfRelativeMonth in AFilterItems then
Add(fviSpecial, foNextMonth, cxGetResourceString(@scxGridNextMonth), True);
if dtfRelativeYear in AFilterItems then
Add(fviSpecial, foNextYear, cxGetResourceString(@scxGridNextYear), True);
*)
Add(fviMRUSeparator, Null, '', True);
end;
function TcxGridFilterValueList.SupportedSpecialOperatorKinds: TcxFilterOperatorKinds;
begin
Result := [foYesterday..foInFuture];
end;
procedure TcxGridFilterValueList.ApplyFilter(AItem: TcxCustomGridTableItem; AIndex: Integer;
AFilterList: TcxFilterCriteriaItemList; AReplaceExistent, AAddToMRUItemsList: Boolean);
function GetVarArrayDisplayText(const AValue: Variant): string;
begin
Result :=
AItem.GetProperties.GetDisplayText(AValue[0], True, False) + ';' +
AItem.GetProperties.GetDisplayText(AValue[1], True, False);
end;
var
AListItem: PcxFilterValueItem;
begin
AItem.DataBinding.Filter.BeginUpdate;
try
AListItem := Items[AIndex];
case AListItem.Kind of
fviAll:
AItem.Filtered := False;
fviCustom:
AItem.GridView.Filtering.RunCustomizeDialog(AItem);
fviBlanks:
AItem.DataBinding.AddToFilter(AFilterList, foEqual, AListItem.Value,
cxGetResourceString(@cxSFilterBlankCaption), AReplaceExistent);
fviNonBlanks:
AItem.DataBinding.AddToFilter(AFilterList, foNotEqual, AListItem.Value,
cxGetResourceString(@cxSFilterBlankCaption), AReplaceExistent);
fviUser:
AItem.DoUserFiltering(AListItem.Value, AListItem.DisplayText);
fviValue, fviMRU:
begin
AItem.DataBinding.AddToFilter(AFilterList, foEqual, AListItem.Value,
AListItem.DisplayText, AReplaceExistent);
if AAddToMRUItemsList then
AItem.DataBinding.FilterMRUValueItems.Add(AListItem.Value, AListItem.DisplayText);
end;
fviSpecial:
if VarIsArray(AListItem.Value) then
AItem.DataBinding.AddToFilter(AFilterList, foBetween, AListItem.Value,
GetVarArrayDisplayText(AListItem.Value), AReplaceExistent)
else
if TcxFilterOperatorKind(AListItem.Value) in SupportedSpecialOperatorKinds then
AItem.DataBinding.AddToFilter(AFilterList, TcxFilterOperatorKind(AListItem.Value),
Null, '', AReplaceExistent);
end;
if not (AListItem.Kind in [fviAll, fviCustom]) then
AItem.DataBinding.Filter.Active := True;
finally
AItem.DataBinding.Filter.EndUpdate;
end;
end;
function TcxGridFilterValueList.GetIndexByCriteriaItem(ACriteriaItem: TcxFilterCriteriaItem): Integer;
begin
Result := -1;
if ACriteriaItem <> nil then
if ACriteriaItem.OperatorKind in SupportedSpecialOperatorKinds then
Result := FindItemByKind(fviSpecial, ACriteriaItem.OperatorKind)
else
if ACriteriaItem.OperatorKind = foBetween then
Result := FindItemByKind(fviSpecial, ACriteriaItem.Value);
if Result = -1 then
Result := inherited GetIndexByCriteriaItem(ACriteriaItem);
end;
procedure TcxGridFilterValueList.Load(AItem: TcxCustomGridTableItem;
AInitSortByDisplayText, AUseFilteredValues: Boolean);
begin
inherited Load(AItem.Index, AInitSortByDisplayText, AUseFilteredValues);
if AItem.SupportsDateTimeFilters(True) then
AddDateTimeRelativeFilters(AItem);
if AItem.SupportsDateTimeFilters(False) then
AddDateTimeAbsoluteFilters(AItem);
end;
{ TcxGridFilterMRUValueItem }
constructor TcxGridFilterMRUValueItem.Create(const AValue: Variant; const ADisplayText: string);
begin
inherited Create;
Value := AValue;
DisplayText := ADisplayText;
end;
function TcxGridFilterMRUValueItem.Equals(AItem: TcxMRUItem): Boolean;
begin
Result := VarCompare(Value, TcxGridFilterMRUValueItem(AItem).Value) = 0;
end;
{ TcxGridFilterMRUValueItems }
function TcxGridFilterMRUValueItems.GetItem(Index: Integer): TcxGridFilterMRUValueItem;
begin
Result := TcxGridFilterMRUValueItem(inherited Items[Index]);
end;
procedure TcxGridFilterMRUValueItems.Add(const AValue: Variant; const ADisplayText: string);
begin
inherited Add(TcxGridFilterMRUValueItem.Create(AValue, ADisplayText));
end;
procedure TcxGridFilterMRUValueItems.AddItemsTo(AValueList: TcxGridFilterValueList);
var
I: Integer;
begin
for I := 0 to Count - 1 do
with Items[I] do
AValueList.Add(fviMRU, Value, DisplayText, True);
end;
{ TcxGridItemDataBinding }
constructor TcxGridItemDataBinding.Create(AItem: TcxCustomGridTableItem);
begin
inherited Create;
FItem := AItem;
FDefaultValuesProvider := GetDefaultValuesProviderClass.Create(Self);
FFilterMRUValueItems := GetFilterMRUValueItemsClass.Create;
FFilterMRUValueItems.MaxCount := GridView.Filtering.ItemMRUItemsListCount;
end;
destructor TcxGridItemDataBinding.Destroy;
begin
FFilterMRUValueItems.Free;
FDefaultValuesProvider.Free;
inherited;
end;
function TcxGridItemDataBinding.GetDataController: TcxCustomDataController;
begin
Result := GridView.DataController;
end;
function TcxGridItemDataBinding.GetFilter: TcxDataFilterCriteria;
begin
Result := DataController.Filter;
end;
function TcxGridItemDataBinding.GetFilterCriteriaItem: TcxFilterCriteriaItem;
begin
Result := Filter.FindItemByItemLink(FItem);
end;
function TcxGridItemDataBinding.GetFiltered: Boolean;
begin
Result := FilterCriteriaItem <> nil;
end;
function TcxGridItemDataBinding.GetGridView: TcxCustomGridTableView;
begin
Result := FItem.GridView;
end;
function TcxGridItemDataBinding.GetValueType: string;
begin
if ValueTypeClass = nil then
Result := ''
else
Result := ValueTypeClass.Caption;
end;
function TcxGridItemDataBinding.GetValueTypeClass: TcxValueTypeClass;
begin
Result := DataController.GetItemValueTypeClass(FItem.Index);
end;
procedure TcxGridItemDataBinding.SetData(Value: TObject);
begin
if FData <> Value then
begin
FData := Value;
FItem.Changed(ticProperty);
end;
end;
procedure TcxGridItemDataBinding.SetFiltered(Value: Boolean);
begin
if Filtered <> Value then
if not Value then
Filter.RemoveItemByItemLink(FItem);
end;
procedure TcxGridItemDataBinding.SetValueType(const Value: string);
begin
if ValueType <> Value then
ValueTypeClass := cxValueTypeClassList.ItemByCaption(Value);
end;
procedure TcxGridItemDataBinding.SetValueTypeClass(Value: TcxValueTypeClass);
begin
DataController.ChangeValueTypeClass(FItem.Index, Value);
end;
function TcxGridItemDataBinding.GetDefaultValuesProviderClass: TcxCustomEditDefaultValuesProviderClass;
var
AIcxGridDataController: IcxGridDataController;
begin
if Supports(TObject(DataController), IcxGridDataController, AIcxGridDataController) then
Result := AIcxGridDataController.GetItemDefaultValuesProviderClass
else
Result := nil;
end;
function TcxGridItemDataBinding.GetDefaultValueTypeClass: TcxValueTypeClass;
begin
Result := TcxStringValueType;
end;
function TcxGridItemDataBinding.GetFilterFieldName: string;
begin
Result := '';
end;
function TcxGridItemDataBinding.GetFilterMRUValueItemsClass: TcxGridFilterMRUValueItemsClass;
begin
Result := TcxGridFilterMRUValueItems;
end;
procedure TcxGridItemDataBinding.Init;
begin
end;
function TcxGridItemDataBinding.IsValueTypeStored: Boolean;
begin
Result := ValueTypeClass <> GetDefaultValueTypeClass;
end;
procedure TcxGridItemDataBinding.Assign(Source: TPersistent);
begin
if Source is TcxGridItemDataBinding then
with TcxGridItemDataBinding(Source) do
begin
Self.Data := Data;
Self.ValueTypeClass := ValueTypeClass;
end
else
inherited;
end;
function TcxGridItemDataBinding.DefaultCaption: string;
begin
Result := ''{Item.Name};
end;
function TcxGridItemDataBinding.DefaultRepositoryItem: TcxEditRepositoryItem;
begin
Result := GetDefaultEditDataRepositoryItems.GetItem(ValueTypeClass);
end;
function TcxGridItemDataBinding.DefaultWidth(ATakeHeaderIntoAccount: Boolean = True): Integer;
begin
Result := 64;
end;
function TcxGridItemDataBinding.GetDefaultValuesProvider(AProperties: TcxCustomEditProperties = nil): IcxEditDefaultValuesProvider;
begin
Result := FDefaultValuesProvider;
end;
function TcxGridItemDataBinding.IsDisplayFormatDefined(AIsCurrencyValueAccepted: Boolean): Boolean;
begin
Result :=
DataController.IsDisplayFormatDefined(FItem.Index, not AIsCurrencyValueAccepted) or
FItem.HasDataTextHandler;
end;
function TcxGridItemDataBinding.AddToFilter(AParent: TcxFilterCriteriaItemList;
AOperatorKind: TcxFilterOperatorKind; const AValue: Variant; const ADisplayText: string;
AReplaceExistent: Boolean): TcxFilterCriteriaItem;
begin
Result := GridView.ViewData.AddItemToFilter(AParent, FItem, AOperatorKind,
AValue, ADisplayText, AReplaceExistent);
end;
procedure TcxGridItemDataBinding.GetFilterDisplayText(const AValue: Variant;
var ADisplayText: string);
begin
FItem.GetFilterDisplayText(AValue, ADisplayText);
end;
procedure TcxGridItemDataBinding.GetFilterStrings(AStrings: TStrings;
AValueList: TcxGridFilterValueList);
var
I: Integer;
S: string;
begin
GetFilterValues(AValueList, False, True, True);
AStrings.BeginUpdate;
try
AStrings.Clear;
for I := 0 to AValueList.Count - 1 do
begin
S := AValueList[I].DisplayText;
GetFilterDisplayText(AValueList[I].Value, S);
AStrings.AddObject(S, TObject(AValueList[I]));
end;
finally
AStrings.EndUpdate;
end;
end;
procedure TcxGridItemDataBinding.GetFilterValues(AValueList: TcxGridFilterValueList;
AValuesOnly: Boolean = True; AInitSortByDisplayText: Boolean = False;
ACanUseFilteredValues: Boolean = False);
var
I: Integer;
begin
AValueList.Load(FItem, AInitSortByDisplayText,
ACanUseFilteredValues and FItem.UseFilteredValuesForFilterValueList);
FItem.DoGetFilterValues(AValueList);
if AValuesOnly then
for I := AValueList.Count - 1 downto 0 do
if AValueList[I].Kind <> fviValue then
AValueList.Delete(I)
else
else
if FItem.CanFilterMRUValueItems then
FFilterMRUValueItems.AddItemsTo(AValueList);
end;
procedure TcxGridItemDataBinding.GetFilterActiveValueIndexes(AValueList: TcxGridFilterValueList;
var AIndexes: TcxGridIndexes);
procedure CheckFilterItem(AFilterItem: TcxFilterCriteriaItem);
var
AValueIndex: Integer;
begin
if AFilterItem.ItemLink <> FItem then Exit;
AValueIndex := AValueList.GetIndexByCriteriaItem(AFilterItem);
if (AValueIndex <> -1) and (AValueList[AValueIndex].Kind <> fviCustom) then
begin
SetLength(AIndexes, Length(AIndexes) + 1);
AIndexes[Length(AIndexes) - 1] := AValueIndex;
end;
end;
var
AFilterItem: TcxFilterCriteriaItem;
AFilterList: TcxFilterCriteriaItemList;
I: Integer;
begin
AIndexes := nil;
AFilterItem := FilterCriteriaItem;
if AFilterItem = nil then Exit;
AFilterList := AFilterItem.Parent;
case AFilterList.BoolOperatorKind of
fboOr:
for I := 0 to AFilterList.Count - 1 do
if AFilterList[I] is TcxFilterCriteriaItem then
CheckFilterItem(TcxFilterCriteriaItem(AFilterList[I]));
fboAnd:
CheckFilterItem(AFilterItem);
end;
end;
procedure TcxGridItemDataBinding.SetFilterActiveValueIndexes(AValueList: TcxGridFilterValueList;
const AIndexes: TcxGridIndexes);
function GetFilterList: TcxFilterCriteriaItemList;
begin
if (Filter.Root.BoolOperatorKind = fboOr) or
(Filter.Root.BoolOperatorKind = fboAnd) and (Length(AIndexes) = 1) then
Result := Filter.Root
else
Result := Filter.Root.AddItemList(fboOr);
end;
var
AFilterList: TcxFilterCriteriaItemList;
I: Integer;
begin
Filter.BeginUpdate;
try
Filter.RemoveItemByItemLink(FItem);
if Length(AIndexes) <> 0 then
begin
AFilterList := GetFilterList;
for I := 0 to Length(AIndexes) - 1 do
AValueList.ApplyFilter(Item, AIndexes[I], AFilterList, False, False);
end;
finally
Filter.EndUpdate;
end;
end;
{ TcxCustomGridDateRange }
destructor TcxCustomGridDateRange.Destroy;
begin
if FContainer <> nil then
FContainer.RemoveItem(Self);
inherited;
end;
function TcxCustomGridDateRange.GetIndex: Integer;
begin
if FContainer = nil then
Result := -1
else
Result := FContainer.GetItemIndex(Self);
end;
procedure TcxCustomGridDateRange.SetIndex(Value: Integer);
begin
if FContainer <> nil then
FContainer.SetItemIndex(Self, Value);
end;
function TcxCustomGridDateRange.GetRangeValue(const ADate: TDateTime; AIgnoreTime: Boolean): Variant;
begin
Result := GetValue(ADate);
end;
function TcxCustomGridDateRange.GetSortingValue(const ADate: TDateTime): Variant;
begin
if NeedsSortingByTime then
Result := TimeOf(ADate)
else
Result := GetValue(ADate);
end;
function TcxCustomGridDateRange.NeedsSortingByTime: Boolean;
begin
Result := False;
end;
function TcxCustomGridDateRange.NeedsTime: Boolean;
begin
Result := NeedsSortingByTime;
end;
{ TcxGridHourRange }
function TcxGridHourRange.Contains(const ADate: TDateTime): Boolean;
begin
Result := True;
end;
function TcxGridHourRange.GetDisplayText(const ADate: TDateTime): string;
begin
if Container.DateTimeHandling.GetHourFormat = '' then
Result := ''
else
Result := FormatDateTime(Container.DateTimeHandling.GetHourFormat, GetValue(ADate));
end;
function TcxGridHourRange.GetValue(const ADate: TDateTime): Variant;
begin
Result := EncodeTime(HourOf(ADate), 0, 0, 0);
end;
function TcxGridHourRange.NeedsSortingByTime: Boolean;
begin
Result := True;
end;
{ TcxGridDayRange }
function TcxGridDayRange.Contains(const ADate: TDateTime): Boolean;
begin
Result := True;
end;
function TcxGridDayRange.GetDisplayText(const ADate: TDateTime): string;
begin
if Container.DateTimeHandling.GetDateFormat = '' then
Result := ''
else
Result := FormatDateTime(Container.DateTimeHandling.GetDateFormat, ADate);
end;
function TcxGridDayRange.GetValue(const ADate: TDateTime): Variant;
begin
Result := ADate;
end;
{ TcxGridMonthRange }
function TcxGridMonthRange.Contains(const ADate: TDateTime): Boolean;
begin
Result := True;
end;
function TcxGridMonthRange.GetDisplayText(const ADate: TDateTime): string;
begin
Result := FormatDateTime(Container.DateTimeHandling.GetMonthFormat, ADate);
end;
function TcxGridMonthRange.GetRangeValue(const ADate: TDateTime; AIgnoreTime: Boolean): Variant;
begin
Result := VarBetweenArrayCreate(GetStartDateOfMonth(ADate), GetEndDateOfMonth(ADate, AIgnoreTime));
end;
function TcxGridMonthRange.GetValue(const ADate: TDateTime): Variant;
begin
Result := GetStartDateOfMonth(ADate);
end;
{ TcxGridYearRange }
function TcxGridYearRange.Contains(const ADate: TDateTime): Boolean;
begin
Result := True;
end;
function TcxGridYearRange.GetDisplayText(const ADate: TDateTime): string;
begin
Result := FormatDateTime(Container.DateTimeHandling.GetYearFormat, ADate);
end;
function TcxGridYearRange.GetRangeValue(const ADate: TDateTime; AIgnoreTime: Boolean): Variant;
begin
Result := VarBetweenArrayCreate(GetStartDateOfYear(ADate), GetEndDateOfYear(ADate, AIgnoreTime));
end;
function TcxGridYearRange.GetValue(const ADate: TDateTime): Variant;
begin
Result := GetStartDateOfYear(ADate);
end;
{ TcxGridYesterdayRange }
function TcxGridYesterdayRange.Contains(const ADate: TDateTime): Boolean;
begin
Result := ADate = Container.Today - 1;
end;
function TcxGridYesterdayRange.GetDisplayText(const ADate: TDateTime): string;
begin
Result := cxGetResourceString(@scxGridYesterday);
end;
function TcxGridYesterdayRange.GetValue(const ADate: TDateTime): Variant;
begin
Result := ADate;
end;
{ TcxGridTodayRange }
function TcxGridTodayRange.Contains(const ADate: TDateTime): Boolean;
begin
Result := ADate = Container.Today;
end;
function TcxGridTodayRange.GetDisplayText(const ADate: TDateTime): string;
begin
Result := cxGetResourceString(@scxGridToday);
end;
function TcxGridTodayRange.GetValue(const ADate: TDateTime): Variant;
begin
Result := ADate;
end;
{ TcxGridTomorrowRange }
function TcxGridTomorrowRange.Contains(const ADate: TDateTime): Boolean;
begin
Result := ADate = Container.Today + 1;
end;
function TcxGridTomorrowRange.GetDisplayText(const ADate: TDateTime): string;
begin
Result := cxGetResourceString(@scxGridTomorrow);
end;
function TcxGridTomorrowRange.GetValue(const ADate: TDateTime): Variant;
begin
Result := ADate;
end;
{ TcxGridLastWeekRange }
function TcxGridLastWeekRange.Contains(const ADate: TDateTime): Boolean;
begin
Result := GetStartDateOfWeek(ADate) = Container.StartOfThisWeek - 7;
end;
function TcxGridLastWeekRange.GetDisplayText(const ADate: TDateTime): string;
begin
Result := cxGetResourceString(@scxGridLastWeek);
end;
function TcxGridLastWeekRange.GetValue(const ADate: TDateTime): Variant;
begin
Result := GetStartDateOfWeek(ADate) + 0.1;
end;
{ TcxGridThisWeekRange }
function TcxGridThisWeekRange.Contains(const ADate: TDateTime): Boolean;
begin
Result := GetStartDateOfWeek(ADate) = Container.StartOfThisWeek;
end;
function TcxGridThisWeekRange.GetDisplayText(const ADate: TDateTime): string;
begin
Result := cxGetResourceString(@scxGridThisWeek);
end;
function TcxGridThisWeekRange.GetValue(const ADate: TDateTime): Variant;
begin
Result := GetStartDateOfWeek(ADate) + 0.1;
end;
{ TcxGridNextWeekRange }
function TcxGridNextWeekRange.Contains(const ADate: TDateTime): Boolean;
begin
Result := GetStartDateOfWeek(ADate) = Container.StartOfThisWeek + 7;
end;
function TcxGridNextWeekRange.GetDisplayText(const ADate: TDateTime): string;
begin
Result := cxGetResourceString(@scxGridNextWeek);
end;
function TcxGridNextWeekRange.GetValue(const ADate: TDateTime): Variant;
begin
Result := GetStartDateOfWeek(ADate) + 0.1;
end;
{ TcxGridLastMonthRange }
function TcxGridLastMonthRange.Contains(const ADate: TDateTime): Boolean;
begin
Result := GetMonthNumber(ADate) = Container.ThisMonthNumber - 1;
end;
function TcxGridLastMonthRange.GetDisplayText(const ADate: TDateTime): string;
begin
Result := cxGetResourceString(@scxGridLastMonth);
end;
function TcxGridLastMonthRange.GetValue(const ADate: TDateTime): Variant;
begin
Result := GetStartDateOfMonth(ADate) + 0.2;
end;
{ TcxGridThisMonthRange }
function TcxGridThisMonthRange.Contains(const ADate: TDateTime): Boolean;
begin
Result := GetMonthNumber(ADate) = Container.ThisMonthNumber;
end;
function TcxGridThisMonthRange.GetDisplayText(const ADate: TDateTime): string;
begin
Result := cxGetResourceString(@scxGridThisMonth);
end;
function TcxGridThisMonthRange.GetValue(const ADate: TDateTime): Variant;
begin
Result := GetStartDateOfMonth(ADate) + 0.2;
end;
{ TcxGridNextMonthRange }
function TcxGridNextMonthRange.Contains(const ADate: TDateTime): Boolean;
begin
Result := GetMonthNumber(ADate) = Container.ThisMonthNumber + 1;
end;
function TcxGridNextMonthRange.GetDisplayText(const ADate: TDateTime): string;
begin
Result := cxGetResourceString(@scxGridNextMonth);
end;
function TcxGridNextMonthRange.GetValue(const ADate: TDateTime): Variant;
begin
Result := GetStartDateOfMonth(ADate) + 0.2;
end;
{ TcxGridLastYearRange }
function TcxGridLastYearRange.Contains(const ADate: TDateTime): Boolean;
begin
Result := GetDateElement(ADate, deYear) = Container.ThisYear - 1;
end;
function TcxGridLastYearRange.GetDisplayText(const ADate: TDateTime): string;
begin
Result := cxGetResourceString(@scxGridLastYear);
end;
function TcxGridLastYearRange.GetValue(const ADate: TDateTime): Variant;
begin
Result := GetStartDateOfYear(ADate) + 0.3;
end;
{ TcxGridThisYearRange }
function TcxGridThisYearRange.Contains(const ADate: TDateTime): Boolean;
begin
Result := GetDateElement(ADate, deYear) = Container.ThisYear;
end;
function TcxGridThisYearRange.GetDisplayText(const ADate: TDateTime): string;
begin
Result := cxGetResourceString(@scxGridThisYear);
end;
function TcxGridThisYearRange.GetValue(const ADate: TDateTime): Variant;
begin
Result := GetStartDateOfYear(ADate) + 0.3;
end;
{ TcxGridNextYearRange }
function TcxGridNextYearRange.Contains(const ADate: TDateTime): Boolean;
begin
Result := GetDateElement(ADate, deYear) = Container.ThisYear + 1;
end;
function TcxGridNextYearRange.GetDisplayText(const ADate: TDateTime): string;
begin
Result := cxGetResourceString(@scxGridNextYear);
end;
function TcxGridNextYearRange.GetValue(const ADate: TDateTime): Variant;
begin
Result := GetStartDateOfYear(ADate) + 0.3;
end;
{ TcxGridDateRanges }
constructor TcxGridDateRanges.Create;
begin
inherited Create;
FItems := TList.Create;
end;
destructor TcxGridDateRanges.Destroy;
begin
Clear;
FItems.Free;
inherited;
end;
function TcxGridDateRanges.GetCount: Integer;
begin
Result := FItems.Count;
end;
function TcxGridDateRanges.GetItem(Index: Integer): TcxCustomGridDateRange;
begin
Result := TcxCustomGridDateRange(FItems[Index]);
end;
procedure TcxGridDateRanges.AddItem(AItem: TcxCustomGridDateRange);
begin
AItem.FContainer := Self;
FItems.Add(AItem);
end;
procedure TcxGridDateRanges.RemoveItem(AItem: TcxCustomGridDateRange);
begin
FItems.Remove(AItem);
AItem.FContainer := nil;
end;
function TcxGridDateRanges.GetItemIndex(AItem: TcxCustomGridDateRange): Integer;
begin
Result := FItems.IndexOf(AItem);
end;
procedure TcxGridDateRanges.SetItemIndex(AItem: TcxCustomGridDateRange; AValue: Integer);
begin
FItems.Move(GetItemIndex(AItem), AValue);
end;
procedure TcxGridDateRanges.InitConsts;
begin
FToday := Date;
FStartOfThisWeek := GetStartDateOfWeek(Today);
DecodeDate(Today, FThisYear, FThisMonth, FThisDay);
FThisMonthNumber := GetMonthNumber(Today);
end;
procedure TcxGridDateRanges.Add(ARange: TcxCustomGridDateRange);
begin
AddItem(ARange);
end;
procedure TcxGridDateRanges.Add(ARangeClass: TcxCustomGridDateRangeClass);
begin
Add(ARangeClass.Create);
end;
procedure TcxGridDateRanges.Clear;
var
I: Integer;
begin
for I := Count - 1 downto 0 do
Items[I].Free;
end;
function TcxGridDateRanges.GetRange(const ADate: TDateTime): TcxCustomGridDateRange;
var
I: Integer;
begin
for I := 0 to Count - 1 do
begin
Result := Items[I];
if Result.Contains(ADate) then Exit;
end;
Result := nil;
end;
function TcxGridDateRanges.GetRange(ARangeClass: TcxCustomGridDateRangeClass): TcxCustomGridDateRange;
var
I: Integer;
begin
for I := 0 to Count - 1 do
begin
Result := Items[I];
if Result is ARangeClass then Exit;
end;
Result := nil;
end;
procedure TcxGridDateRanges.Init(ADateTimeHandling: TcxCustomGridTableDateTimeHandling);
begin
FDateTimeHandling := ADateTimeHandling;
InitConsts;
Clear;
end;
function TcxGridDateRanges.IsEmpty: Boolean;
begin
Result := Count = 0;
end;
function TcxGridDateRanges.NeedSortingByTime: Boolean;
var
I: Integer;
begin
for I := 0 to Count - 1 do
begin
Result := Items[I].NeedsSortingByTime;
if Result then Exit;
end;
Result := False;
end;
function TcxGridDateRanges.NeedTime: Boolean;
var
I: Integer;
begin
for I := 0 to Count - 1 do
begin
Result := Items[I].NeedsTime;
if Result then Exit;
end;
Result := False;
end;
{ TcxGridFilteringDateRanges }
procedure TcxGridFilteringDateRanges.Init(ADateTimeHandling: TcxCustomGridTableDateTimeHandling;
ADateTimeFilters: TcxGridDateTimeFilters);
begin
inherited Init(ADateTimeHandling);
if dtfYears in ADateTimeFilters then
Add(TcxGridYearRange);
if dtfMonths in ADateTimeFilters then
Add(TcxGridMonthRange);
end;
{ TcxGridGroupingDateRanges }
procedure TcxGridGroupingDateRanges.Init(ADateTimeHandling: TcxCustomGridTableDateTimeHandling;
ADateTimeGrouping: TcxGridDateTimeGrouping);
begin
inherited Init(ADateTimeHandling);
case ADateTimeGrouping of
dtgRelativeToToday:
begin
Add(TcxGridYesterdayRange);
Add(TcxGridTodayRange);
Add(TcxGridTomorrowRange);
Add(TcxGridLastWeekRange);
Add(TcxGridThisWeekRange);
Add(TcxGridNextWeekRange);
Add(TcxGridLastMonthRange);
Add(TcxGridThisMonthRange);
Add(TcxGridNextMonthRange);
Add(TcxGridLastYearRange);
Add(TcxGridThisYearRange);
Add(TcxGridNextYearRange);
end;
dtgByHour:
Add(TcxGridHourRange);
dtgByDate:
Add(TcxGridDayRange);
dtgByMonth:
Add(TcxGridMonthRange);
dtgByYear:
Add(TcxGridYearRange);
end;
end;
{ TcxCustomGridRecord }
constructor TcxCustomGridRecord.Create(AViewData: TcxCustomGridTableViewData;
AIndex: Integer; const ARecordInfo: TcxRowInfo);
begin
inherited Create;
FViewData := AViewData;
FIndex := AIndex;
RecordInfo := ARecordInfo;
end;
destructor TcxCustomGridRecord.Destroy;
begin
//GridView.DoRecordDestroying(Self);
if FViewInfo <> nil then
FViewInfo.FRecord := nil;
inherited;
end;
function TcxCustomGridRecord.GetController: TcxCustomGridTableController;
begin
Result := GridView.Controller;
end;
function TcxCustomGridRecord.GetDataController: TcxCustomDataController;
begin
Result := FViewData.DataController;
end;
function TcxCustomGridRecord.GetDragHighlighted: Boolean;
begin
Result := FViewData.Controller.DragHighlightedRecord = Self;
end;
function TcxCustomGridRecord.GetFocused: Boolean;
begin
Result := FViewData.Controller.FocusedRecord = Self;
end;
function TcxCustomGridRecord.GetGridView: TcxCustomGridTableView;
begin
Result := FViewData.GridView;
end;
function TcxCustomGridRecord.GetIsEditing: Boolean;
begin
Result := FViewData.EditingRecord = Self;
end;
function TcxCustomGridRecord.GetIsNewItemRecord: Boolean;
begin
Result := FViewData.NewItemRecord = Self;
end;
function TcxCustomGridRecord.GetIsValid: Boolean;
begin
Result := (0 <= RecordIndex) and (RecordIndex < ViewData.DataController.RecordCount);
end;
function TcxCustomGridRecord.GetLastParentRecordCount: Integer;
begin
if Level = 0 then
Result := 0
else
for Result := 0 to Level - 1 do
if not IsParentRecordLast[Result] then Break;
end;
function TcxCustomGridRecord.GetLevel: Integer;
begin
Result := RecordInfo.Level;
end;
function TcxCustomGridRecord.GetPartVisible: Boolean;
begin
Result := FViewInfo <> nil;
end;
function TcxCustomGridRecord.GetRecordIndex: Integer;
begin
Result := RecordInfo.RecordIndex;
end;
procedure TcxCustomGridRecord.SetExpanded(Value: Boolean);
begin
if Expanded <> Value then
if Value then
Expand(False)
else
Collapse(False);
end;
procedure TcxCustomGridRecord.SetFocused(Value: Boolean);
begin
if Value then
FViewData.Controller.FocusedRecord := Self
else
if Focused then
FViewData.Controller.FocusedRecord := nil;
end;
procedure TcxCustomGridRecord.RefreshRecordInfo;
begin
if IsNewItemRecord then
with RecordInfo do
begin
Expanded := False;
Level := 0;
RecordIndex := DataController.NewItemRecordIndex;
end
else
RecordInfo := DataController.GetRowInfo(FIndex);
end;
procedure TcxCustomGridRecord.DoCollapse(ARecurse: Boolean);
begin
end;
procedure TcxCustomGridRecord.DoExpand(ARecurse: Boolean);
begin
end;
{function TcxCustomGridRecord.GetDestroyingOnExpanding: Boolean;
begin
Result := False;
end;}
function TcxCustomGridRecord.GetExpandable: Boolean;
begin
Result := False;
end;
function TcxCustomGridRecord.GetExpanded: Boolean;
begin
Result := False;
end;
procedure TcxCustomGridRecord.ToggleExpanded;
begin
Expanded := not Expanded;
end;
function TcxCustomGridRecord.GetHasCells: Boolean;
begin
Result := False;
end;
function TcxCustomGridRecord.GetIsData: Boolean;
begin
Result := True;
end;
function TcxCustomGridRecord.GetIsFirst: Boolean;
begin
Result := Index = 0;
end;
function TcxCustomGridRecord.GetIsLast: Boolean;
begin
Result := Index = FViewData.RecordCount - 1;
end;
function TcxCustomGridRecord.GetIsParent: Boolean;
begin
Result := False;
end;
function TcxCustomGridRecord.GetIsParentRecordLast(AIndex: Integer): Boolean;
begin
Result := IsLast or (ViewData.Records[Index + 1].Level < Level - AIndex);
end;
function TcxCustomGridRecord.GetParentRecord: TcxCustomGridRecord;
begin
if Level <> 0 then
begin
Result := Self;
repeat
Result := ViewData.Records[Result.Index - 1];
until Result.Level < Level;
end
else
if GridView.IsDetail then
Result := GridView.MasterGridRecord
else
Result := nil;
end;
function TcxCustomGridRecord.GetSelected: Boolean;
begin
if IsNewItemRecord then
Result := Controller.NewItemRecordFocused
else
Result := Controller.IsRecordSelected(Self);
end;
function TcxCustomGridRecord.GetVisible: Boolean;
begin
Result := IsNewItemRecord or PartVisible and
FViewData.ViewInfo.RecordsViewInfo.GetRealItem(Self).Visible;
end;
procedure TcxCustomGridRecord.SetSelected(Value: Boolean);
begin
if IsNewItemRecord then
Controller.NewItemRecordFocused := Value
else
Controller.ChangeRecordSelection(Self, Value);
end;
function TcxCustomGridRecord.GetDisplayText(Index: Integer): string;
begin
Result := DataController.GetRowDisplayText(RecordInfo, Index);
end;
function TcxCustomGridRecord.GetValueCount: Integer;
begin
Result := DataController.GetItemCount;
end;
function TcxCustomGridRecord.GetValue(Index: Integer): Variant;
begin
Result := DataController.GetRowValue(RecordInfo, Index);
end;
procedure TcxCustomGridRecord.SetDisplayText(Index: Integer; const Value: string);
begin
DataController.SetDisplayText(RecordIndex, Index, Value);
end;
procedure TcxCustomGridRecord.SetValue(Index: Integer; const Value: Variant);
begin
DataController.SetValue(RecordIndex, Index, Value);
end;
procedure TcxCustomGridRecord.KeyDown(var Key: Word; Shift: TShiftState);
begin
case Key of
VK_ADD:
if Expandable then
begin
Controller.EatKeyPress := True;
Expanded := True;
Key := 0;
end;
VK_SUBTRACT:
if Expandable then
begin
Controller.EatKeyPress := True;
Expanded := False;
Key := 0;
end;
VK_RETURN, VK_F2, VK_PROCESSKEY:
if HasCells and (Controller.FocusedItem <> nil) and
((Shift = []) or (Key = VK_RETURN) and (Shift = [ssShift])) then
begin
Controller.FocusedItem.Editing := True;
if Controller.FocusedItem.Editing and (Key <> VK_PROCESSKEY) then
Key := 0;
end;
end;
end;
function TcxCustomGridRecord.CanFocus: Boolean;
begin
Result := GridView.DoCanFocusRecord(Self); //!!!
end;
function TcxCustomGridRecord.CanFocusCells: Boolean;
begin
Result := GridView.OptionsSelection.CellSelect;
end;
procedure TcxCustomGridRecord.Collapse(ARecurse: Boolean);
begin
if Expandable then DoCollapse(ARecurse);
end;
procedure TcxCustomGridRecord.Expand(ARecurse: Boolean);
begin
if Expandable then DoExpand(ARecurse);
end;
function TcxCustomGridRecord.GetFirstFocusableChild: TcxCustomGridRecord;
begin
Result := nil;
end;
function TcxCustomGridRecord.GetLastFocusableChild(ARecursive: Boolean): TcxCustomGridRecord;
begin
Result := nil;
end;
procedure TcxCustomGridRecord.Invalidate(AItem: TcxCustomGridTableItem = nil);
begin
if PartVisible then
GridView.Changed(TcxGridRecordChange.Create(GridView, Self, Index, AItem));
end;
procedure TcxCustomGridRecord.MakeVisible;
begin
Controller.MakeRecordVisible(Self);
end;
{ TcxCustomGridTableViewData }
constructor TcxCustomGridTableViewData.Create(AGridView: TcxCustomGridView);
begin
inherited;
FRecords := TList.Create;
end;
destructor TcxCustomGridTableViewData.Destroy;
begin
DestroyNewItemRecord;
DestroyRecords;
FRecords.Free;
inherited;
end;
function TcxCustomGridTableViewData.GetController: TcxCustomGridTableController;
begin
Result := TcxCustomGridTableController(inherited Controller);
end;
function TcxCustomGridTableViewData.GetEditingRecord: TcxCustomGridRecord;
begin
if DataController.IsEditing then
Result := GetRecordByRecordIndex(DataController.EditingRecordIndex)
else
Result := nil;
end;
function TcxCustomGridTableViewData.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
function TcxCustomGridTableViewData.GetInternalRecord(Index: Integer): TcxCustomGridRecord;
begin
Result := TcxCustomGridRecord(FRecords[Index]);
end;
function TcxCustomGridTableViewData.GetRecord(Index: Integer): TcxCustomGridRecord;
begin
Result := InternalRecords[Index];
if Result = nil then
begin
Result := CreateRecord(Index);
FRecords[Index] := Result;
//GridView.DoRecordCreated(Result);
end;
end;
function TcxCustomGridTableViewData.GetRecordCount: Integer;
begin
Result := FRecords.Count;
end;
function TcxCustomGridTableViewData.GetViewInfo: TcxCustomGridTableViewInfo;
begin
Result := TcxCustomGridTableViewInfo(inherited ViewInfo);
end;
function TcxCustomGridTableViewData.CreateRecord(AIndex: Integer): TcxCustomGridRecord;
var
ARecordInfo: TcxRowInfo;
begin
ARecordInfo := DataController.GetRowInfo(AIndex);
Result := GetRecordClass(ARecordInfo).Create(Self, AIndex, ARecordInfo);
end;
function TcxCustomGridTableViewData.GetFilterValueListClass: TcxGridFilterValueListClass;
begin
Result := TcxGridFilterValueList;
end;
function TcxCustomGridTableViewData.GetRecordByKind(AKind, AIndex: Integer): TcxCustomGridRecord;
begin
case AKind of
rkNormal:
if (0 <= AIndex) and (AIndex < RecordCount) then
Result := Records[AIndex]
else
Result := nil;
rkNewItem:
Result := NewItemRecord;
else
Result := nil;
end;
end;
function TcxCustomGridTableViewData.GetRecordKind(ARecord: TcxCustomGridRecord): Integer;
begin
if ARecord.IsNewItemRecord then
Result := rkNewItem
else
Result := rkNormal;
end;
procedure TcxCustomGridTableViewData.AssignEditingRecord;
begin
FEditingRecord := GetEditingRecord;
end;
procedure TcxCustomGridTableViewData.CreateNewItemRecord;
var
ARowInfo: TcxRowInfo;
begin
FNewItemRecord := GetNewItemRecordClass.Create(Self, -1, ARowInfo);
FNewItemRecord.RefreshRecordInfo;
//GridView.DoRecordCreated(FNewItemRecord);
end;
procedure TcxCustomGridTableViewData.DestroyNewItemRecord;
begin
FreeAndNil(FNewItemRecord);
end;
function TcxCustomGridTableViewData.GetNewItemRecordClass: TcxCustomGridRecordClass;
begin
Result := nil;
end;
procedure TcxCustomGridTableViewData.RecreateNewItemRecord;
begin
if HasNewItemRecord then
begin
DestroyNewItemRecord;
CreateNewItemRecord;
end;
end;
procedure TcxCustomGridTableViewData.Collapse(ARecurse: Boolean);
var
I: Integer;
begin
BeginUpdate;
try
for I := RecordCount - 1 downto 0 do
Records[I].Collapse(ARecurse);
finally
EndUpdate;
end;
end;
procedure TcxCustomGridTableViewData.DestroyRecords;
var
I: Integer;
ARecord: TcxCustomGridRecord;
begin
for I := 0 to RecordCount - 1 do
begin
ARecord := InternalRecords[I];
if ARecord <> nil then
begin
ARecord.Free;
FRecords[I] := nil;
end;
end;
end;
procedure TcxCustomGridTableViewData.Expand(ARecurse: Boolean);
var
I: Integer;
begin
BeginUpdate;
try
for I := 0 to RecordCount - 1 do
Records[I].Expand(ARecurse);
finally
EndUpdate;
end;
end;
function TcxCustomGridTableViewData.GetRecordByIndex(AIndex: Integer): TcxCustomGridRecord;
begin
if (0 <= AIndex) and (AIndex < RecordCount) then
Result := Records[AIndex]
else
Result := nil;
end;
function TcxCustomGridTableViewData.GetRecordByRecordIndex(ARecordIndex: Integer): TcxCustomGridRecord;
var
I: Integer;
begin
if HasNewItemRecord and (ARecordIndex = DataController.NewItemRecordIndex) then
Result := FNewItemRecord
else
if (0 <= ARecordIndex) and (ARecordIndex < DataController.RecordCount) then
begin
// following loop was created because during sorting
// row order in data controller is new already, but it is old in view data
// (used in TcxCustomGridTableItem.GetProperties(ARecordIndex))
if GridView.IsUpdateLocked or not DataController.IsRowInfoValid then
for I := 0 to RecordCount - 1 do
begin
Result := InternalRecords[I];
if (Result <> nil) and Result.IsData and (Result.RecordIndex = ARecordIndex) then
Exit;
end;
Result := GetRecordByIndex(DataController.GetRowIndexByRecordIndex(ARecordIndex, False));
end
else
Result := nil;
end;
function TcxCustomGridTableViewData.GetRecordIndexByRecord(ARecord: TcxCustomGridRecord): Integer;
begin
if ARecord = nil then
Result := -1 //!!! can be internal record index
else
Result := ARecord.RecordIndex;
end;
function TcxCustomGridTableViewData.IsRecordIndexValid(AIndex: Integer): Boolean;
begin
Result := (0 <= AIndex) and (AIndex < RecordCount);
end;
procedure TcxCustomGridTableViewData.Refresh(ARecordCount: Integer);
begin
RecreateNewItemRecord;
DestroyRecords;
FRecords.Clear;
FRecords.Count := ARecordCount;
AssignEditingRecord;
GridView.SizeChanged(GridView.IsPattern);
end;
procedure TcxCustomGridTableViewData.RefreshRecords;
var
I: Integer;
ARecord: TcxCustomGridRecord;
begin
if HasNewItemRecord then FNewItemRecord.RefreshRecordInfo;
for I := 0 to RecordCount - 1 do
begin
ARecord := InternalRecords[I];
if ARecord <> nil then ARecord.RefreshRecordInfo;
end;
AssignEditingRecord;
end;
procedure TcxCustomGridTableViewData.CheckNewItemRecord;
begin
if HasNewItemRecord then
CreateNewItemRecord
else
DestroyNewItemRecord;
end;
function TcxCustomGridTableViewData.HasNewItemRecord: Boolean;
begin
Result := False;
end;
function TcxCustomGridTableViewData.AddItemToFilter(AParent: TcxFilterCriteriaItemList;
AItem: TcxCustomGridTableItem; AOperatorKind: TcxFilterOperatorKind;
const AValue: Variant; ADisplayText: string; AReplaceExistent: Boolean): TcxFilterCriteriaItem;
begin
if (ADisplayText = '') and not (VarIsNull(AValue) or VarIsArray(AValue)) then
ADisplayText := AValue;
AItem.DataBinding.GetFilterDisplayText(AValue, ADisplayText);
if AReplaceExistent then
DataController.Filter.RemoveItemByItemLink(AItem);
Result := DataController.Filter.AddItem(AParent, AItem, AOperatorKind, AValue, ADisplayText);
end;
function TcxCustomGridTableViewData.CreateFilterValueList: TcxGridFilterValueList;
begin
Result := GetFilterValueListClass.Create(DataController.Filter);
end;
function TcxCustomGridTableViewData.GetDisplayText(ARecordIndex, AItemIndex: Integer;
out AText: string; AUseCustomValue: Boolean = False; ACustomValueOperation: TcxGridDataOperation = doGrouping): Boolean;
var
AItem: TcxCustomGridTableItem;
AProperties: TcxCustomEditProperties;
AValue: Variant;
begin
AItem := GridView.Items[AItemIndex];
AProperties := AItem.GetProperties(ARecordIndex);
Result := AUseCustomValue or (AProperties.GetEditValueSource(False) = evsValue);
if Result then
begin
AValue := DataController.Values[ARecordIndex, AItemIndex];
if AUseCustomValue then
AValue := GetCustomDataValue(AItem, AValue, ACustomValueOperation);
AText := AProperties.GetDisplayText(AValue, True);
end;
end;
function TcxCustomGridTableViewData.CustomCompareDataValues(AField: TcxCustomDataField;
const AValue1, AValue2: Variant; AMode: TcxDataControllerComparisonMode): Integer;
var
AOperation: TcxGridDataOperation;
ACustomValue1, ACustomValue2: Variant;
begin
if AMode = dccmSorting then
AOperation := doSorting
else
AOperation := doGrouping;
ACustomValue1 := GetCustomDataValue(AField, AValue1, AOperation);
ACustomValue2 := GetCustomDataValue(AField, AValue2, AOperation);
Result := VarCompare(ACustomValue1, ACustomValue2);
end;
function TcxCustomGridTableViewData.GetCustomDataDisplayText(ARecordIndex, AItemIndex: Integer;
AOperation: TcxGridDataOperation): string;
var
AValue: Variant;
ADate: TDateTime;
ADateRange: TcxCustomGridDateRange;
begin
Result := '';
if AOperation = doGrouping then
begin
AValue := DataController.Values[ARecordIndex, AItemIndex];
if not VarIsNull(AValue) then
begin
if GridView.Items[AItemIndex].GroupingDateRanges.NeedTime then
ADate := AValue
else
ADate := DateOf(AValue);
ADateRange := GridView.Items[AItemIndex].GroupingDateRanges.GetRange(ADate);
if ADateRange <> nil then
Result := ADateRange.GetDisplayText(ADate);
end;
end;
if Result = '' then
GetDisplayText(ARecordIndex, AItemIndex, Result, True, AOperation);
end;
function TcxCustomGridTableViewData.GetCustomDataValue(AField: TcxCustomDataField;
const AValue: Variant; AOperation: TcxGridDataOperation): Variant;
begin
Result := GetCustomDataValue(TcxCustomGridTableItem(AField.Item), AValue, AOperation);
end;
function TcxCustomGridTableViewData.GetCustomDataValue(AItem: TcxCustomGridTableItem;
const AValue: Variant; AOperation: TcxGridDataOperation): Variant;
var
ADate: TDateTime;
ADateRange: TcxCustomGridDateRange;
begin
if VarIsNull(AValue) then
Result := AValue
else
if AOperation in [doSorting, doGrouping] then
begin
if AItem.GroupingDateRanges.NeedTime then
ADate := AValue
else
ADate := DateOf(AValue);
ADateRange := AItem.GroupingDateRanges.GetRange(ADate);
if ADateRange = nil then
Result := ADate
else
if AOperation = doGrouping then
Result := ADateRange.GetValue(ADate)
else
Result := ADateRange.GetSortingValue(ADate);
end
else
Result := DateOf(AValue);
end;
function TcxCustomGridTableViewData.HasCustomDataHandling(AField: TcxCustomDataField;
AOperation: TcxGridDataOperation): Boolean;
begin
Result := (AField.Item <> nil) and
HasCustomDataHandling(TcxCustomGridTableItem(AField.Item), AOperation);
end;
function TcxCustomGridTableViewData.HasCustomDataHandling(AItem: TcxCustomGridTableItem;
AOperation: TcxGridDataOperation): Boolean;
begin
Result :=
(AOperation = doGrouping) and AItem.SupportsGroupingDateRanges(False) or
(AOperation = doFiltering) and AItem.CanIgnoreTimeForFiltering;
end;
function TcxCustomGridTableViewData.NeedsCustomDataComparison(AField: TcxCustomDataField;
AMode: TcxDataControllerComparisonMode): Boolean;
var
AItem: TcxCustomGridTableItem;
AItemGroupIndex: Integer;
begin
AItem := TcxCustomGridTableItem(AField.Item);
Result := (AItem <> nil) and ((AMode = dccmGrouping) or (AMode = dccmSorting)) and
HasCustomDataHandling(AField, doGrouping);
if Result and (AMode = dccmSorting) then
begin
AItemGroupIndex := AItem.GroupIndex;
Result := (AItemGroupIndex <> -1) and
((AItemGroupIndex < GridView.GroupedItemCount - 1) or AItem.GroupingDateRanges.NeedSortingByTime);
end;
end;
{ TcxCustomGridTableMovingObject }
function TcxCustomGridTableMovingObject.GetController: TcxCustomGridTableController;
begin
Result := TcxCustomGridTableController(inherited Controller);
end;
function TcxCustomGridTableMovingObject.GetCustomizationForm: TcxCustomGridTableCustomizationForm;
begin
Result := TcxCustomGridTableCustomizationForm(inherited CustomizationForm);
end;
procedure TcxCustomGridTableMovingObject.DragAndDrop(const P: TPoint; var Accepted: Boolean);
begin
inherited;
Controller.CheckScrolling(P);
end;
{ TcxGridItemContainerZone }
constructor TcxGridItemContainerZone.Create(AItemIndex: Integer);
begin
inherited Create;
ItemIndex := AItemIndex;
end;
function TcxGridItemContainerZone.IsEqual(Value: TcxGridItemContainerZone): Boolean;
begin
Result := (Value <> nil) and (ItemIndex = Value.ItemIndex);
end;
{ TcxCustomGridTableItemMovingObject }
constructor TcxCustomGridTableItemMovingObject.Create(AControl: TcxControl);
begin
inherited;
FDestItemContainerKind := ckNone;
end;
destructor TcxCustomGridTableItemMovingObject.Destroy;
begin
DestZone := nil;
inherited;
end;
procedure TcxCustomGridTableItemMovingObject.SetDestItemContainerKind(Value: TcxGridItemContainerKind);
begin
CheckDestItemContainerKind(Value);
if FDestItemContainerKind <> Value then
begin
Dirty := True;
FDestItemContainerKind := Value;
end;
end;
procedure TcxCustomGridTableItemMovingObject.SetDestZone(Value: TcxGridItemContainerZone);
begin
if (FDestZone <> Value) and
((FDestZone = nil) or not FDestZone.IsEqual(Value) or
(Value = nil) or not Value.IsEqual(FDestZone)) then
begin
Dirty := True;
FDestZone.Free;
FDestZone := Value;
end
else
Value.Free;
end;
procedure TcxCustomGridTableItemMovingObject.CalculateDestParams(AHitTest: TcxCustomGridHitTest;
out AContainerKind: TcxGridItemContainerKind; out AZone: TcxGridItemContainerZone);
begin
if AHitTest.HitTestCode = htCustomizationForm then
AContainerKind := ckCustomizationForm
else
AContainerKind := ckNone;
AZone := nil;
end;
procedure TcxCustomGridTableItemMovingObject.CheckDestItemContainerKind(var AValue: TcxGridItemContainerKind);
begin
if (SourceItemContainerKind <> ckCustomizationForm) and
(AValue = ckCustomizationForm) and not CanRemove then
AValue := ckNone;
end;
function TcxCustomGridTableItemMovingObject.GetCustomizationFormListBox: TcxCustomGridItemsListBox;
begin
Result := CustomizationForm.ItemsListBox;
end;
function TcxCustomGridTableItemMovingObject.IsSourceCustomizationForm: Boolean;
begin
Result := FSourceItemContainerKind = ckCustomizationForm;
end;
procedure TcxCustomGridTableItemMovingObject.BeginDragAndDrop;
begin
if CustomizationForm <> nil then
with CustomizationForm do
ActivatePage(ItemsPage);
Controller.FMovingItem := SourceItem as TcxCustomGridTableItem;
inherited;
end;
procedure TcxCustomGridTableItemMovingObject.DragAndDrop(const P: TPoint; var Accepted: Boolean);
var
AHitTest: TcxCustomGridHitTest;
ADestContainerKind: TcxGridItemContainerKind;
ADestZone: TcxGridItemContainerZone;
begin
AHitTest := ViewInfo.GetHitTest(P);
CalculateDestParams(AHitTest, ADestContainerKind, ADestZone);
DestZone := ADestZone;
DestItemContainerKind := ADestContainerKind;
Accepted := FDestItemContainerKind <> ckNone;
inherited;
end;
procedure TcxCustomGridTableItemMovingObject.EndDragAndDrop(Accepted: Boolean);
begin
inherited;
Controller.FMovingItem := nil;
end;
{ TcxCustomGridTableItemsListBox }
function TcxCustomGridTableItemsListBox.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
procedure TcxCustomGridTableItemsListBox.RefreshItemsAsTableItems;
var
I: Integer;
AItem: TcxCustomGridTableItem;
begin
inherited;
with Items do
begin
BeginUpdate;
try
Clear;
for I := 0 to GridView.ItemCount - 1 do
begin
AItem := GridView.Items[I];
if AItem.CanMove and AItem.VisibleForCustomization and not AItem.Visible then
AddObject(AItem.GetAlternateCaption, AItem);
end;
finally
EndUpdate;
end;
end;
end;
{ TcxCustomGridTableCustomizationForm }
procedure TcxCustomGridTableCustomizationForm.CreateControls;
begin
inherited;
FItemsListBox := GetItemsListBoxClass.Create(Self);
with FItemsListBox do
begin
Align := alClient;
Parent := FItemsPage;
RefreshItems;
end;
end;
function TcxCustomGridTableCustomizationForm.GetItemsListBoxClass: TcxCustomGridTableItemsListBoxClass;
begin
Result := TcxCustomGridTableItemsListBox;
end;
function TcxCustomGridTableCustomizationForm.GetItemsPageVisible: Boolean;
begin
Result := TcxCustomGridTableView(GridView).OptionsCustomize.ItemMoving;
end;
procedure TcxCustomGridTableCustomizationForm.InitPageControl;
begin
inherited;
FItemsPage := CreatePage(GetItemsPageCaption, GetItemsPageVisible);
end;
procedure TcxCustomGridTableCustomizationForm.RefreshData;
begin
inherited;
FItemsListBox.RefreshItems;
end;
{ TcxGridFilterPopupListBox }
function TcxGridFilterPopupListBox.GetPopup: TcxGridFilterPopup;
begin
Result := TcxGridFilterPopup(inherited Popup);
end;
function TcxGridFilterPopupListBox.CanHaveCheck(AItemIndex: Integer): Boolean;
begin
Result := inherited CanHaveCheck(AItemIndex) and
not Popup.IsMRUItemsListSeparator(AItemIndex);
end;
procedure TcxGridFilterPopupListBox.DrawItemContent(ACanvas: TcxCanvas;
AIndex: Integer; ARect: TRect; AState: TOwnerDrawState);
procedure DrawMRUItemsListSeparator;
var
Y: Integer;
begin
with ACanvas do
begin
Pen.Color := clBtnShadow;
with ARect do
begin
Y := (Top + Bottom - 3) div 2;
MoveTo(Left, Y);
LineTo(Right, Y);
MoveTo(Left, Y + 2);
LineTo(Right, Y + 2);
end;
end;
end;
begin
if Popup.IsMRUItemsListSeparator(AIndex) then
DrawMRUItemsListSeparator
else
inherited;
end;
function TcxGridFilterPopupListBox.HasCheck(AItemIndex: Integer): Boolean;
begin
Result := Popup.IsCheck(AItemIndex);
end;
{ TcxGridFilterPopup }
constructor TcxGridFilterPopup.Create(AGridView: TcxCustomGridView);
begin
inherited;
AlignHorz := pahRight;
FListBoxItems := TStringList.Create;
FValueList := GridView.ViewData.CreateFilterValueList;
FListBox := TcxGridFilterPopupListBox.Create(Self);
FListBox.OnAction := ListBoxAction;
FButton := TcxButton.Create(Self);
FButton.Caption := cxGetResourceString(@scxGridFilterApplyButtonCaption);
FButton.LookAndFeel.MasterLookAndFeel := GridView.LookAndFeel;
FButton.ParentFont := True;
UpdateButtonEnabled;
FButton.OnClick := ButtonClicked;
end;
destructor TcxGridFilterPopup.Destroy;
begin
FValueList.Free;
FListBoxItems.Free;
inherited;
end;
function TcxGridFilterPopup.GetFilter: TcxDataFilterCriteria;
begin
Result := GridView.DataController.Filter;
end;
function TcxGridFilterPopup.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
{function TcxGridFilterPopup.GetOwnerValue: IcxGridFilterPopupOwner;
begin
Result := IcxGridFilterPopupOwner(inherited Owner);
end;
procedure TcxGridFilterPopup.SetOwnerValue(Value: IcxGridFilterPopupOwner);
begin
inherited Owner := Value;
end;}
procedure TcxGridFilterPopup.SetFilterChangedByCheck(Value: Boolean);
begin
if FFilterChangedByCheck <> Value then
begin
FFilterChangedByCheck := Value;
UpdateButtonEnabled;
end;
end;
procedure TcxGridFilterPopup.ButtonClicked(Sender: TObject);
begin
CloseUp;
ApplyFilterUsingCheckedItems(FListBox.CheckedIndexes);
GridView.Filtering.AddFilterToMRUItems;
end;
procedure TcxGridFilterPopup.ListBoxAction(Sender: TcxGridPopupListBox; AItemIndex: Integer);
begin
if FListBox.IsCheck(AItemIndex) then
begin
if ImmediateFilterUsingChecks then
ApplyFilterUsingCheckedItems(FListBox.CheckedIndexes);
FilterChangedByCheck := True;
end
else
ApplyFilterUsingClickedItem(AItemIndex);
end;
procedure TcxGridFilterPopup.AddListBoxItems;
begin
Item.DataBinding.GetFilterStrings(FListBoxItems, FValueList);
end;
procedure TcxGridFilterPopup.AdjustListBoxSize;
begin
FListBox.VisibleItemCount := GridView.Filtering.ItemPopup.MaxDropDownItemCount;
FListBox.VisibleWidth := GridView.Filtering.ItemPopup.DropDownWidth;
FListBox.ShowChecks := SupportsChecks;
FListBox.AdjustBounds(FListBoxItems);
end;
procedure TcxGridFilterPopup.ApplyFilterUsingCheckedItems(const AItemIndexes: TcxGridIndexes);
begin
Item.DataBinding.SetFilterActiveValueIndexes(FValueList, AItemIndexes);
end;
procedure TcxGridFilterPopup.ApplyFilterUsingClickedItem(AItemIndex: Integer);
begin
FValueList.ApplyFilter(Item, AItemIndex, nil, True, True);
if not (FValueList[AItemIndex].Kind in [fviCustom, fviUser]) then
GridView.Filtering.AddFilterToMRUItems;
end;
function TcxGridFilterPopup.GetImmediateFilterUsingChecks: Boolean;
begin
Result := GridView.Filtering.ItemPopup.ApplyMultiSelectChanges = fpacImmediately;
end;
function TcxGridFilterPopup.GetListBoxCheckedItemIndexes: TcxGridIndexes;
var
AActiveValueIndexes: TcxGridIndexes;
I: Integer;
begin
Item.DataBinding.GetFilterActiveValueIndexes(FValueList, AActiveValueIndexes);
Result := nil;
for I := 0 to Length(AActiveValueIndexes) - 1 do
if IsCheck(AActiveValueIndexes[I]) then
begin
SetLength(Result, Length(Result) + 1);
Result[Length(Result) - 1] := AActiveValueIndexes[I];
end;
end;
function TcxGridFilterPopup.GetSelectedItemIndex: Integer;
begin
Result := FValueList.GetIndexByCriteriaItem(Item.DataBinding.FilterCriteriaItem);
end;
procedure TcxGridFilterPopup.InitButton;
begin
if IsButtonVisible then
begin
FButton.Width := FListBox.Width;
FButton.Top := FListBox.BoundsRect.Bottom;
FButton.Parent := Self;
FButton.Height := FButton.GetOptimalSize.cy;
{with GetButtonPainterClass(FButton.LookAndFeel) do
FButton.Height := 2 * (ButtonBorderSize + ButtonTextOffset) + Canvas.FontHeight(FButton.Font);}
end
else
FButton.Parent := nil;
end;
procedure TcxGridFilterPopup.InitListBox;
var
ACheckedIndexes: TcxGridIndexes;
begin
AddListBoxItems;
AdjustListBoxSize;
FListBox.Items := FListBoxItems;
if FListBox.ShowChecks then
ACheckedIndexes := GetListBoxCheckedItemIndexes
else
ACheckedIndexes := nil;
if ACheckedIndexes = nil then
FListBox.ItemIndex := SelectedItemIndex
else
FListBox.ItemIndex := -1;
FListBox.CheckedIndexes := ACheckedIndexes;
end;
procedure TcxGridFilterPopup.InitPopup;
begin
FItem := (Owner as IcxGridFilterPopupOwner).GetItem;
ShowHourglassCursor;
try
inherited;
InitListBox;
InitButton;
FilterChangedByCheck := False;
finally
HideHourglassCursor;
end;
end;
function TcxGridFilterPopup.IsButtonVisible: Boolean;
begin
Result := SupportsChecks and not ImmediateFilterUsingChecks;
end;
function TcxGridFilterPopup.IsCheck(AItemIndex: Integer): Boolean;
begin
Result := FValueList[AItemIndex].Kind in [fviBlanks, fviValue, fviSpecial];
end;
function TcxGridFilterPopup.IsMRUItemsListSeparator(AItemIndex: Integer): Boolean;
begin
Result := FValueList[AItemIndex].Kind = fviMRUSeparator;
end;
function TcxGridFilterPopup.SupportsChecks: Boolean;
begin
Result := Item.CanFilterUsingChecks;
end;
procedure TcxGridFilterPopup.UpdateButtonEnabled;
begin
FButton.Enabled := FFilterChangedByCheck;
end;
procedure TcxGridFilterPopup.CloseUp;
begin
inherited;
FListBox.Clear;
if FFilterChangedByCheck and ImmediateFilterUsingChecks then
GridView.Filtering.AddFilterToMRUItems;
end;
{ TcxGridFilterMRUItemsPopup }
constructor TcxGridFilterMRUItemsPopup.Create(AGridView: TcxCustomGridView);
begin
inherited;
FListBox := TcxGridPopupListBox.Create(Self);
FListBox.OnAction := ListBoxAction;
end;
function TcxGridFilterMRUItemsPopup.GetFiltering: TcxCustomGridTableFiltering;
begin
Result := GridView.Filtering;
end;
function TcxGridFilterMRUItemsPopup.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
procedure TcxGridFilterMRUItemsPopup.ListBoxAction(Sender: TcxGridPopupListBox;
AItemIndex: Integer);
begin
ApplyFilterMRUItem(AItemIndex);
end;
procedure TcxGridFilterMRUItemsPopup.AddFilterMRUItems(AStrings: TStrings);
var
I: Integer;
AItem: TcxGridFilterMRUItem;
begin
AStrings.BeginUpdate;
try
AStrings.Clear;
for I := 0 to Filtering.MRUItems.VisibleCount - 1 do
begin
AItem := Filtering.MRUItems.VisibleItems[I];
AStrings.AddObject(AItem.Caption, AItem);
end;
finally
AStrings.EndUpdate;
end;
end;
procedure TcxGridFilterMRUItemsPopup.ApplyFilterMRUItem(AItemIndex: Integer);
begin
TcxGridFilterMRUItem(FListBox.Items.Objects[AItemIndex]).AssignTo(GridView.DataController.Filter);
Filtering.AddFilterToMRUItems;
end;
function TcxGridFilterMRUItemsPopup.GetTextOffsetHorz: Integer;
begin
Result := FListBox.ItemTextOffsetLeft;
end;
procedure TcxGridFilterMRUItemsPopup.InitPopup;
begin
inherited;
FListBox.ItemTextOffsetVert := 2;
FListBox.VisibleItemCount := GridView.FilterBox.MRUItemsListDropDownCount;
AddFilterMRUItems(FListBox.Items);
FListBox.AdjustBounds;
end;
{ TcxCustomGridCustomizationPopup }
constructor TcxCustomGridCustomizationPopup.Create(AGridView: TcxCustomGridView);
begin
inherited;
CreateCheckListBox;
end;
function TcxCustomGridCustomizationPopup.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
procedure TcxCustomGridCustomizationPopup.SetScrollDirection(Value: TcxDirection);
begin
if FScrollDirection <> Value then
begin
FreeAndNil(FScrollTimer);
FScrollDirection := Value;
if FScrollDirection <> dirNone then
begin
FScrollTimer := TcxTimer.Create(nil);
FScrollTimer.Interval := CustomizationPopupCheckListBoxScrollTimeInterval;
FScrollTimer.OnTimer := ScrollTimerHandler;
end;
end;
end;
procedure TcxCustomGridCustomizationPopup.CheckListBoxClick(Sender: TObject);
var
AItems: TList;
begin
if not GridView.IsDesigning then Exit;
AItems := TList.Create;
try
GetCheckListBoxSelectedItems(AItems);
GridView.Controller.DesignController.SelectObjects(AItems);
finally
AItems.Free;
end;
end;
procedure TcxCustomGridCustomizationPopup.CheckListBoxCheckClick(Sender: TObject;
AIndex: Integer; APrevState, ANewState: TcxCheckBoxState);
begin
CheckClicked(AIndex, ANewState = cbsChecked);
end;
procedure TcxCustomGridCustomizationPopup.CheckListBoxEndDrag(Sender, Target: TObject;
X, Y: Integer);
begin
ScrollDirection := dirNone;
end;
procedure TcxCustomGridCustomizationPopup.CheckListBoxKeyDown(Sender: TObject;
var Key: Word; Shift: TShiftState);
begin
case Key of
VK_ESCAPE:
CloseUp;
end;
end;
procedure TcxCustomGridCustomizationPopup.CheckListBoxMouseDown(Sender: TObject;
Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
if Button = mbLeft then
CheckListBoxClick(Sender);
end;
procedure TcxCustomGridCustomizationPopup.CheckListBoxStartDrag(Sender: TObject;
var DragObject: TDragObject);
begin
if CheckListBox.ItemAtPos(CheckListBox.ScreenToClient(GetMouseCursorPos), True) = -1 then
begin
DragObject := TDragObject(1); // to avoid DragObject creation in TcxControl.DoStartDrag
CancelDrag;
end
else
DragItemIndex := -1;
end;
procedure TcxCustomGridCustomizationPopup.CheckListBoxDragOver(Sender, Source: TObject;
X, Y: Integer; State: TDragState; var Accept: Boolean);
function GetArrowBounds(APlace: TcxGridArrowPlace): TRect;
const
ArrowOffset = 1;
begin
Result := CheckListBox.InnerCheckListBox.ItemRect(DragItemIndex);
Result.Bottom := Result.Top;
Result := GetDragAndDropArrowBounds(Result, cxEmptyRect, APlace);
if APlace = apLeft then
OffsetRect(Result, Result.Right - Result.Left + ArrowOffset, 0)
else
OffsetRect(Result, -(Result.Right - Result.Left + ArrowOffset), 0);
end;
procedure HideInsertionMark;
var
R: TRect;
begin
if DragItemIndex = -1 then Exit;
R := GetArrowBounds(apLeft);
InvalidateRect(CheckListBox.InnerCheckListBox.Handle, @R, True);
R := GetArrowBounds(apRight);
InvalidateRect(CheckListBox.InnerCheckListBox.Handle, @R, True);
CheckListBox.InnerCheckListBox.Update;
end;
procedure ShowInsertionMark;
begin
if DragItemIndex = -1 then Exit;
DrawDragAndDropArrow(CheckListBox.InnerCheckListBox.Canvas,
GetArrowBounds(apLeft), apLeft);
DrawDragAndDropArrow(CheckListBox.InnerCheckListBox.Canvas,
GetArrowBounds(apRight), apRight);
end;
procedure CheckScrolling;
begin
if (DragItemIndex <> -1) and (CheckListBox.Columns > 1) then
if X < CustomizationPopupCheckListBoxScrollZoneWidth then
ScrollDirection := dirLeft
else
if X >= CheckListBox.ClientWidth - CustomizationPopupCheckListBoxScrollZoneWidth then
ScrollDirection := dirRight
else
ScrollDirection := dirNone
else
ScrollDirection := dirNone;
end;
var
AItemIndex: Integer;
begin
AItemIndex := GetItemInsertionIndex(X, Y);
Accept := AItemIndex <> -1;
if State = dsDragLeave then
AItemIndex := -1;
if DragItemIndex <> AItemIndex then
begin
HideInsertionMark;
DragItemIndex := AItemIndex;
ShowInsertionMark;
end;
CheckScrolling;
end;
procedure TcxCustomGridCustomizationPopup.CheckListBoxDragDrop(Sender, Source: TObject;
X, Y: Integer);
procedure MoveItems(AItems: TList; AIndex: Integer);
var
I: Integer;
begin
GridView.BeginUpdate;
try
for I := 0 to AItems.Count - 1 do
begin
SetItemIndex(AItems[I], AIndex);
AIndex := GetItemIndex(AItems[I]) + 1;
end;
finally
GridView.EndUpdate;
end;
end;
var
AIndex: Integer;
AItems: TList;
begin
AIndex := GetItemInsertionIndex(X, Y);
if AIndex = -1 then Exit;
if AIndex = CheckListBox.Count then
AIndex := GetItemIndex(CheckListBox.Items[AIndex - 1].ItemObject) + 1
else
AIndex := GetItemIndex(CheckListBox.Items[AIndex].ItemObject);
AItems := TList.Create;
try
GetCheckListBoxSelectedItems(AItems);
MoveItems(AItems, AIndex);
CheckListBox.ItemIndex := AIndex;
RefreshCheckListBoxItems;
SetCheckListBoxSelectedItems(AItems);
finally
AItems.Free;
end;
end;
procedure TcxCustomGridCustomizationPopup.ScrollTimerHandler(Sender: TObject);
var
ATopIndex: Integer;
AAccept: Boolean;
begin
// cannot use WM_HSCROLL here - it does not scroll by one column
if ScrollDirection = dirLeft then
CheckListBox.TopIndex := CheckListBox.TopIndex - 1
else
begin
ATopIndex := CheckListBox.TopIndex;
repeat
Inc(ATopIndex);
CheckListBox.TopIndex := ATopIndex;
until (CheckListBox.TopIndex = ATopIndex) or (ATopIndex >= CheckListBox.Items.Count);
end;
AAccept := True;
with CheckListBox.ScreenToClient(GetMouseCursorPos) do
CheckListBoxDragOver(nil, nil, X, Y, dsDragMove, AAccept);
end;
procedure TcxCustomGridCustomizationPopup.AdjustCheckListBoxSize(AFixedHeight: Boolean = False);
var
ADropDownCount: Integer;
function CalculateClientWidth: Integer;
begin
if FCheckListBox.Columns > 1 then
Result := CheckListBoxColumnWidth * FCheckListBox.Columns
else
begin
Result := FCheckListBox.GetBestFitWidth;
if (ADropDownCount <> -1) and (FCheckListBox.Items.Count > ADropDownCount) then
Inc(Result, GetScrollBarSize.cx);
end;
end;
function CalculateClientHeight: Integer;
begin
if ADropDownCount = -1 then
Result := FCheckListBox.ClientHeight + GetScrollBarSize.cy
else
Result := FCheckListBox.GetHeight(ADropDownCount);
end;
begin
if AFixedHeight then
ADropDownCount := -1
else
if FCheckListBox.Columns > 1 then
ADropDownCount := RoundDiv(FCheckListBox.Items.Count, FCheckListBox.Columns)
else
begin
ADropDownCount := GetDropDownCount;
if (ADropDownCount = 0) or (FCheckListBox.Items.Count < ADropDownCount) then
ADropDownCount := FCheckListBox.Items.Count;
end;
FCheckListBox.ClientWidth := CalculateClientWidth;
FCheckListBox.ClientHeight := CalculateClientHeight;
end;
procedure TcxCustomGridCustomizationPopup.CheckClicked(AIndex: Integer; AChecked: Boolean);
begin
ItemClicked(CheckListBox.Items[AIndex].ItemObject, AChecked);
end;
procedure TcxCustomGridCustomizationPopup.CreateCheckListBox;
begin
FCheckListBox := TcxCheckListBox.Create(Self);
with FCheckListBox do
begin
with Style do
begin
LookAndFeel.MasterLookAndFeel := GridView.LookAndFeel;
BorderStyle := cbsNone;
HotTrack := False;
TransparentBorder := False;
end;
StyleFocused.BorderStyle := cbsNone;
StyleHot.BorderStyle := cbsNone;
ParentFont := True;
Parent := Self;
OnClick := CheckListBoxClick;
OnClickCheck := CheckListBoxCheckClick;
OnDragDrop := CheckListBoxDragDrop;
OnDragOver := CheckListBoxDragOver;
OnEndDrag := CheckListBoxEndDrag;
OnKeyDown := CheckListBoxKeyDown;
OnMouseDown := CheckListBoxMouseDown;
OnStartDrag := CheckListBoxStartDrag;
end;
end;
function TcxCustomGridCustomizationPopup.GetCheckListBoxColumnWidth: Integer;
begin
Result := CheckListBox.GetBestFitWidth + CustomizationPopupCheckListBoxColumnOffset;
end;
function TcxCustomGridCustomizationPopup.GetItemInsertionIndex(X, Y: Integer): Integer;
var
R: TRect;
begin
Result := CheckListBox.ItemAtPos(Point(X, Y), True);
if Result = -1 then
begin
R := CheckListBox.ItemRect(CheckListBox.Count - 1);
R.Bottom := CheckListBox.ClientBounds.Bottom;
if PtInRect(R, Point(X, Y)) then
Result := CheckListBox.Count;
end
else
begin
R := CheckListBox.ItemRect(Result);
if Y > GetRangeCenter(R.Top, R.Bottom) then
Inc(Result);
end;
end;
procedure TcxCustomGridCustomizationPopup.InitPopup;
begin
inherited;
with FCheckListBox do
begin
Canvas.Font := Font;
if SupportsItemMoving then
DragMode := dmAutomatic
else
DragMode := dmManual;
InnerCheckListBox.MultiSelect := DragMode = dmAutomatic;
end;
AddCheckListBoxItems;
AdjustCheckListBoxSize;
end;
procedure TcxCustomGridCustomizationPopup.RefreshCheckListBoxItems;
begin
CheckListBox.Items.BeginUpdate;
try
CheckListBox.Clear;
AddCheckListBoxItems;
finally
CheckListBox.Items.EndUpdate;
end;
end;
procedure TcxCustomGridCustomizationPopup.GetCheckListBoxSelectedItems(AItems: TList);
var
I: Integer;
begin
for I := 0 to CheckListBox.Count - 1 do
if CheckListBox.Selected[I] then
AItems.Add(CheckListBox.Items[I].ItemObject);
end;
procedure TcxCustomGridCustomizationPopup.SetCheckListBoxSelectedItems(AItems: TList);
var
I, AIndex: Integer;
begin
for I := 0 to AItems.Count - 1 do
begin
AIndex := CheckListBox.Items.IndexOfObject(AItems[I]);
if AIndex <> -1 then
CheckListBox.Selected[AIndex] := True;
end;
end;
procedure TcxCustomGridCustomizationPopup.CloseUp;
begin
inherited;
FCheckListBox.Clear;
FCheckListBox.Columns := 0;
end;
procedure TcxCustomGridCustomizationPopup.CorrectBoundsWithDesktopWorkArea(var APosition: TPoint);
var
ADesktopWorkArea: TRect;
ADesktopSpace, AColumnCount: Integer;
begin
ADesktopWorkArea := GetDesktopWorkArea(OwnerScreenBounds.TopLeft);
if APosition.Y < ADesktopWorkArea.Top then
ADesktopSpace := APosition.Y + Height - ADesktopWorkArea.Top
else
if APosition.Y + Height > ADesktopWorkArea.Bottom then
ADesktopSpace := ADesktopWorkArea.Bottom - APosition.Y
else
ADesktopSpace := 0;
if ADesktopSpace <> 0 then
begin
AColumnCount := RoundDiv(CheckListBox.Height, ADesktopSpace - NCHeight);
repeat
RestoreControlsBounds;
CheckListBox.Columns := AColumnCount;
AdjustCheckListBoxSize;
CalculateSize;
APosition := CalculatePosition;
Inc(AColumnCount);
until (ADesktopWorkArea.Top <= APosition.Y - GetScrollBarSize.cy) and
(APosition.Y + Height + GetScrollBarSize.cy <= ADesktopWorkArea.Bottom);
if APosition.X + Width > ADesktopWorkArea.Right then
begin
RestoreControlsBounds;
CheckListBox.Columns :=
(ADesktopWorkArea.Right - APosition.X - NCWidth) div CheckListBoxColumnWidth;
AdjustCheckListBoxSize(True);
CalculateSize;
APosition := CalculatePosition;
end;
end;
end;
procedure TcxCustomGridCustomizationPopup.Popup;
begin
GridView.Focused := True; // to prevent popup from closing because of viewinfo recalculation
inherited;
end;
{ TcxCustomGridItemsCustomizationPopup }
procedure TcxCustomGridItemsCustomizationPopup.AddCheckListBoxItems;
var
I: Integer;
AItem: TcxCustomGridTableItem;
begin
with CheckListBox.Items do
begin
BeginUpdate;
try
for I := 0 to GridView.ItemCount - 1 do
begin
AItem := GridView.Items[I];
if AItem.VisibleInQuickCustomizationPopup then
with Add do
begin
Checked := AItem.Visible;
ItemObject := AItem;
Text := AItem.GetAlternateCaption;
end;
end;
finally
EndUpdate;
end;
end;
end;
function TcxCustomGridItemsCustomizationPopup.GetDropDownCount: Integer;
begin
Result := GridView.OptionsCustomize.ItemsQuickCustomizationMaxDropDownCount;
end;
function TcxCustomGridItemsCustomizationPopup.SupportsItemMoving: Boolean;
begin
Result := GridView.OptionsCustomize.SupportsItemsQuickCustomizationReordering;
end;
procedure TcxCustomGridItemsCustomizationPopup.ItemClicked(AItem: TObject; AChecked: Boolean);
begin
TcxCustomGridTableItem(AItem).Visible := AChecked;
GridView.Controller.DesignerModified;
end;
function TcxCustomGridItemsCustomizationPopup.GetItemIndex(AItem: TObject): Integer;
begin
Result := TcxCustomGridTableItem(AItem).Index;
end;
procedure TcxCustomGridItemsCustomizationPopup.SetItemIndex(AItem: TObject;
AIndex: Integer);
begin
if TcxCustomGridTableItem(AItem).Index < AIndex then
Dec(AIndex);
TcxCustomGridTableItem(AItem).Index := AIndex;
GridView.Controller.DesignerModified;
end;
{ TcxGridEditingController }
constructor TcxGridEditingController.Create(AController: TcxCustomGridTableController);
begin
inherited Create;
FController := AController;
FEditList := TcxInplaceEditList.Create;
end;
destructor TcxGridEditingController.Destroy;
begin
StopEditShowingTimer;
FEditList.Free;
inherited;
end;
function TcxGridEditingController.GetEditingProperties: TcxCustomEditProperties;
begin
if FEditingItem = nil then
Result := nil
else
Result := FEditingItem.GetPropertiesForEdit;
end;
function TcxGridEditingController.GetGridView: TcxCustomGridTableView;
begin
Result := FController.GridView;
end;
function TcxGridEditingController.GetIsEditing: Boolean;
begin
Result := FEditingItem <> nil;
end;
procedure TcxGridEditingController.SetEditingItem(Value: TcxCustomGridTableItem);
begin
if FEditingItem <> Value then
begin
if FEditingItemSetting then Exit;
FEditingItemSetting := True;
try
if Value <> nil then
begin
if not Value.CanEdit or not GridView.DoEditing(Value) then Exit;
Value.FocusWithSelection;
end;
HideEdit(False);
FEditingItem := Value;
if IsEditing then
try
ShowEdit(Value);
if not FEditPreparing and (FEdit = nil) then
FEditingItem := nil;
except
FEditingItem := nil;
raise;
end;
finally
FEditingItemSetting := False;
end;
end;
end;
procedure TcxGridEditingController.EditShowingTimerHandler(Sender: TObject);
begin
StopEditShowingTimer;
FEditShowingTimerItem.Editing := True;
end;
procedure TcxGridEditingController.AfterViewInfoCalculate;
begin
if IsEditing and (not FIsEditPlaced or FEditingItem.EditPartVisible) then
begin
CancelEditUpdatePost;
if not FEditPreparing then
FEdit.Left := cxGridInvisibleCoordinate;
end;
end;
procedure TcxGridEditingController.BeforeViewInfoCalculate;
begin
FIsEditPlaced := False;
end;
procedure TcxGridEditingController.CancelEditUpdatePost;
begin
FEditUpdateNeeded := False;
end;
function TcxGridEditingController.CanInitEditing: Boolean;
begin
Result := EditingItem.CanInitEditing;
end;
function TcxGridEditingController.CanRemoveEditFocus: Boolean;
begin
Result := not (IsEditing and FEdit.IsFocused and not FEditHiding);
end;
function TcxGridEditingController.CanUpdateEditValue: Boolean;
begin
Result := not GridView.IsPattern and
IsEditing and not FEditHiding and not FInitiatingEditing and not FEdit.IsPosting;
end;
procedure TcxGridEditingController.CheckEdit;
begin
if IsEditing and (FEditingItem.FocusedCellViewInfo = nil) then
HideEdit(False)
else
ShowEdit;
end;
procedure TcxGridEditingController.CheckEditUpdatePost;
begin
if FEditUpdateNeeded then DoUpdateEdit;
end;
procedure TcxGridEditingController.DoEditChanged;
begin
end;
procedure TcxGridEditingController.DoEditKeyDown(var Key: Word; Shift: TShiftState);
var
AModified: Boolean;
begin
GridView.DoEditKeyDown(FEditingItem, FEdit, Key, Shift);
case Key of
VK_RETURN:
begin
HideEdit(True);
if GridView.OptionsBehavior.GoToNextCellOnEnter then
begin
FController.BlockRecordKeyboardHandling := True;
try
FController.DoKeyDown(Key, Shift);
finally
FController.BlockRecordKeyboardHandling := False;
end;
ShowEdit;
end
else
Controller.CheckEdit;
Key := 0;
end;
VK_ESCAPE:
begin
AModified := FEdit.EditModified;
HideEdit(False);
Controller.CheckEdit;
if AModified then Key := 0;
end;
VK_DELETE:
if Shift = [ssCtrl] then
Controller.DoKeyDown(Key, Shift);
end;
end;
procedure TcxGridEditingController.DoUpdateEdit;
begin
CancelEditUpdatePost;
if (FEditingItem <> nil) and (FEditingItem.FocusedCellViewInfo <> nil) and
not FEditingItem.EditPartVisible then
begin
with FEditingItem.FocusedCellViewInfo do
begin
if IsRectEmpty(Bounds) then Exit;
FEdit.BoundsRect := EditBounds;
InitStyle;
FEdit.Style := Style;
end;
GridView.DoInitEdit(FEditingItem, FEdit);
end;
end;
function TcxGridEditingController.GetHideEditOnExit: Boolean;
begin
Result := True{
not GridView.OptionsBehavior.AlwaysShowEditor or
GridView.Control.IsFocused};
end;
function TcxGridEditingController.GetHideEditOnFocusedRecordChange: Boolean;
begin
Result := not GridView.OptionsBehavior.AlwaysShowEditor or
(FEditingItem <> nil) and
(FEditingItem.HasCustomPropertiesHandler or FEditingItem.HasCustomPropertiesForEditHandler or
FEditingItem.ShowButtons(False) or
(esoAlwaysHotTrack in FEditingItem.GetProperties.GetSupportedOperations)) or
Assigned(GridView.OnEditing) or Assigned(GridView.OnInitEdit);
end;
procedure TcxGridEditingController.InitEdit;
begin
with FEdit.InternalProperties do
begin
FPrevEditOnChange := OnChange;
FPrevEditOnEditValueChanged := OnEditValueChanged;
OnChange := nil;
OnEditValueChanged := nil;
end;
FEdit.InplaceParams.Position := FEditingItem.FocusedCellViewInfo.GetInplaceEditPosition;
FEdit.Parent := FController.Site;
UpdateEdit;
UpdateEditValue;
AssignEditEvents;
//GridView.DoInitEdit(FEditingItem, FEdit);
end;
procedure TcxGridEditingController.UninitEdit;
begin
UnassignEditEvents;
end;
procedure TcxGridEditingController.PostEditingData;
begin
GridView.DataController.PostEditingData;
end;
procedure TcxGridEditingController.PostEditUpdate;
begin
FEditUpdateNeeded := True;
end;
function TcxGridEditingController.PrepareEdit(AItem: TcxCustomGridTableItem;
AOnMouseEvent: Boolean): Boolean;
var
AProperties: TcxCustomEditProperties;
AAssignRepositoryItem: Boolean;
begin
Result := False;
try
FController.CancelCheckEditPost;
if FEditPreparing or FEditHiding or
(AItem = nil) or (Controller.FocusedRecord = nil) then Exit;
FEditPreparing := True;
try
if AItem.Editing and not FEditingItemSetting then
begin
Result := (FEdit <> nil) and
(FController.Site.Focused and not FEdit.IsFocused or AOnMouseEvent);
if Result then
FEditingItem.FocusedCellViewInfo.Invalidate(True);
Exit;
end;
Result := FController.Site.Focused;
if not Result then Exit;
AItem.Editing := True;
Result := AItem.Editing;
if not Result then Exit;
Result := not AItem.EditPartVisible;
if not Result then
begin
AItem.Editing := False;
Exit;
end;
try
AProperties := EditingProperties;
if (AItem.Properties <> nil) and (AItem.RepositoryItem <> nil) and
(AProperties = AItem.RepositoryItem.Properties) then
begin
AProperties := AItem.Properties;
AAssignRepositoryItem := True;
end
else
AAssignRepositoryItem := False;
GridView.PatternGridView.IgnorePropertiesChanges := True;
try
FEdit := FEditList.GetEdit(AProperties);
if AAssignRepositoryItem then
FEdit.RepositoryItem := AItem.RepositoryItem;
finally
GridView.PatternGridView.IgnorePropertiesChanges := False;
end;
except
AItem.Editing := False;
Result := False;
raise;
end;
FEditingItem.FocusedCellViewInfo.Invalidate(True);
InitEdit;
finally
FEditPreparing := False;
end;
finally
if Result then GridView.TabStop := False;
end;
end;
procedure TcxGridEditingController.UpdateEditValue;
var
AValue: TcxEditValue;
begin
if CanUpdateEditValue then
begin
FEdit.LockChangeEvents(True);
try
AValue := EditingItem.EditValue;
GridView.DoInitEditValue(EditingItem, Edit, AValue);
FEdit.EditValue := AValue;
finally
FEdit.LockChangeEvents(False, False);
end;
FEdit.SelectAll;
end;
end;
procedure TcxGridEditingController.UpdateValue;
begin
if IsEditing and FEdit.EditModified then
begin
FEdit.ValidateEdit(True);
FEditingItem.EditValue := FEdit.EditValue;
if FEdit <> nil then
FEdit.ModifiedAfterEnter := False;
end;
end;
procedure TcxGridEditingController.AssignEditEvents;
begin
with FEdit do
begin
OnAfterKeyDown := EditAfterKeyDown;
OnEditing := EditEditing;
OnPostEditValue := EditPostEditValue;
OnExit := EditExit;
OnFocusChanged := EditFocusChanged;
OnKeyDown := EditKeyDown;
OnKeyPress := EditKeyPress;
OnKeyUp := EditKeyUp;
InternalProperties.OnChange := EditChanged;
InternalProperties.OnEditValueChanged := EditValueChanged;
end;
end;
procedure TcxGridEditingController.UnassignEditEvents;
begin
with FEdit do
begin
OnAfterKeyDown := nil;
OnEditing := nil;
OnPostEditValue := nil;
OnExit := nil;
OnFocusChanged := nil;
OnKeyDown := nil;
OnKeyPress := nil;
OnKeyUp := nil;
InternalProperties.OnChange := FPrevEditOnChange;
InternalProperties.OnEditValueChanged := FPrevEditOnEditValueChanged;
end;
end;
procedure TcxGridEditingController.EditAfterKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
begin
if FController.IsKeyForController(Key, Shift) then
FController.DoKeyDown(Key, Shift);
end;
procedure TcxGridEditingController.EditChanged(Sender: TObject);
begin
DoEditChanged;
if Assigned(FPrevEditOnChange) then FPrevEditOnChange(Sender);
GridView.DoEditChanged(FEditingItem);
end;
procedure TcxGridEditingController.EditEditing(Sender: TObject; var CanEdit: Boolean);
begin
FInitiatingEditing := True;
try
CanEdit := CanInitEditing;
finally
FInitiatingEditing := False;
end;
end;
procedure TcxGridEditingController.EditExit(Sender: TObject);
begin
if HideEditOnExit then
try
HideEdit(not FController.CancelEditingOnExit);
except
if IsEditing then
begin
FEdit.SetFocus;
FIsErrorOnEditExit := True;
end;
raise;
end;
end;
procedure TcxGridEditingController.EditFocusChanged(Sender: TObject);
begin
TcxControlAccess(FController.Site).FocusChanged;
end;
procedure TcxGridEditingController.EditKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
begin
if not (Key in [VK_CONTROL, VK_SHIFT, VK_MENU]) then
FController.MakeFocusedItemVisible;
DoEditKeyDown(Key, Shift);
end;
procedure TcxGridEditingController.EditKeyPress(Sender: TObject; var Key: Char);
begin
GridView.DoEditKeyPress(FEditingItem, FEdit, Key);
end;
procedure TcxGridEditingController.EditKeyUp(Sender: TObject; var Key: Word;
Shift: TShiftState);
begin
GridView.DoEditKeyUp(FEditingItem, FEdit, Key, Shift);
end;
procedure TcxGridEditingController.EditPostEditValue(Sender: TObject);
begin
UpdateValue;
end;
procedure TcxGridEditingController.EditValueChanged(Sender: TObject);
begin
if Assigned(FPrevEditOnEditValueChanged) then FPrevEditOnEditValueChanged(Sender);
GridView.DoEditValueChanged(FEditingItem);
end;
procedure TcxGridEditingController.HideEdit(Accept: Boolean);
var
APrevAllowCheckEdit: Boolean;
begin
FController.CancelCheckEditPost;
CancelEditUpdatePost;
StopEditShowingTimer;
if FEditHiding or not IsEditing then Exit;
FEditHiding := True;
try
if Accept then
begin
if not FEdit.Deactivate then raise EAbort.Create('');
PostEditingData;
FEdit.ActiveProperties.Update(FEditingItem.GetProperties(Controller.FocusedRecord));
end;
EditingItem := nil;
if GridView.Focused then GridView.TabStop := True;
if FEdit <> nil then
begin
UninitEdit;
if FEdit.Focused and GridView.Focused then
begin
FEdit.EditModified := False;
if not GridView.IsDestroying then
begin
APrevAllowCheckEdit := FController.AllowCheckEdit;
FController.AllowCheckEdit := False;
try
FController.DoSetFocus(False);
finally
FController.AllowCheckEdit := APrevAllowCheckEdit;
end;
end;
end
else
Controller.InvalidateFocusedRecord;
FEdit.Parent := nil;
FEdit.RepositoryItem := nil;
FEdit := nil;
end;
FIsErrorOnEditExit := False;
finally
FEditHiding := False;
end;
end;
procedure TcxGridEditingController.RemoveEdit(AProperties: TcxCustomEditProperties);
begin
//if EditingProperties = AProperties then
if IsEditing and (Edit = FEditList.FindEdit(AProperties)) then
EditingItem := nil;
FEditList.RemoveItem(AProperties);
end;
procedure TcxGridEditingController.ShowEdit(AItem: TcxCustomGridTableItem = nil);
begin
if AItem = nil then AItem := FController.FocusedItem;
if PrepareEdit(AItem, False) then FEdit.Activate(AItem.FEditData);
end;
procedure TcxGridEditingController.ShowEdit(AItem: TcxCustomGridTableItem; Key: Char);
begin
if PrepareEdit(AItem, False) then FEdit.ActivateByKey(Key, AItem.FEditData);
end;
procedure TcxGridEditingController.ShowEdit(AItem: TcxCustomGridTableItem;
Shift: TShiftState; X, Y: Integer);
begin
if PrepareEdit(AItem, True) then FEdit.ActivateByMouse(Shift, X, Y, AItem.FEditData);
end;
procedure TcxGridEditingController.UpdateEdit;
var
ACellViewInfo: TcxGridTableDataCellViewInfo;
begin
if FEdit = nil then Exit;
ACellViewInfo := FEditingItem.FocusedCellViewInfo;
if ACellViewInfo = nil then Exit;
with ACellViewInfo do
begin
if IsRectEmpty(Bounds) then Exit;
if not FInitiatingEditing and FEditPreparing then
DoUpdateEdit
else
PostEditUpdate;
end;
FIsEditPlaced := True;
end;
procedure TcxGridEditingController.StartEditShowingTimer(AItem: TcxCustomGridTableItem);
begin
StopEditShowingTimer;
FEditShowingTimerItem := AItem;
FEditShowingTimer := TcxTimer.Create(nil);
with FEditShowingTimer do
begin
Interval := GetDblClickInterval;
OnTimer := EditShowingTimerHandler;
end;
end;
procedure TcxGridEditingController.StopEditShowingTimer;
begin
FreeAndNil(FEditShowingTimer);
end;
(*{ TcxCustomGridDragOpenInfo }
function TcxCustomGridDragOpenInfo.Equals(AInfo: TcxCustomGridDragOpenInfo): Boolean;
begin
Result := ClassType = AInfo.ClassType;
end;
*)
{ TcxGridDragOpenInfoExpand }
constructor TcxGridDragOpenInfoExpand.Create(AGridRecord: TcxCustomGridRecord);
begin
inherited Create;
GridRecord := AGridRecord;
end;
function TcxGridDragOpenInfoExpand.Equals(AInfo: TcxCustomGridDragOpenInfo): Boolean;
begin
Result := inherited Equals(AInfo) and
(GridRecord = TcxGridDragOpenInfoExpand(AInfo).GridRecord);
end;
procedure TcxGridDragOpenInfoExpand.Run;
begin
GridRecord.Expand(False);
end;
{ TcxCustomGridTableController }
constructor TcxCustomGridTableController.Create(AGridView: TcxCustomGridView);
begin
inherited;
FAllowAppendRecord := True;
FAllowCheckEdit := True;
FEditingController := GetEditingControllerClass.Create(Self);
FFocusOnRecordFocusing := True;
end;
destructor TcxCustomGridTableController.Destroy;
begin
FFilterPopup.Free;
FFilterMRUItemsPopup.Free;
FItemsCustomizationPopup.Free;
CancelGridModeBufferCountUpdate;
FreeAndNil(FEditingController);
inherited;
end;
function TcxCustomGridTableController.GetEditingItem: TcxCustomGridTableItem;
begin
Result := FEditingController.EditingItem;
end;
function TcxCustomGridTableController.GetFilterMRUItemsPopup: TcxGridFilterMRUItemsPopup;
begin
if FFilterMRUItemsPopup = nil then
FFilterMRUItemsPopup := GetFilterMRUItemsPopupClass.Create(GridView);
Result := FFilterMRUItemsPopup;
end;
function TcxCustomGridTableController.GetFilterPopup: TcxGridFilterPopup;
begin
if FFilterPopup = nil then
FFilterPopup := GetFilterPopupClass.Create(GridView);
Result := FFilterPopup;
end;
function TcxCustomGridTableController.GetFocusedItemIndex: Integer;
begin
if FFocusedItem = nil then
Result := -1
else
Result := FFocusedItem.VisibleIndex;
end;
function TcxCustomGridTableController.GetFocusedRecordIndex: Integer;
begin
Result := DataController.GetFocusedRowIndex;
end;
function TcxCustomGridTableController.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
function TcxCustomGridTableController.GetIncSearchingItem: TcxCustomGridTableItem;
begin
if IsIncSearching then
Result := GridView.Items[DataController.Search.ItemIndex]
else
Result := nil;
end;
function TcxCustomGridTableController.GetIncSearchingText: string;
begin
Result := DataController.Search.SearchText;
end;
function TcxCustomGridTableController.GetIsEditing: Boolean;
begin
Result := FEditingController.IsEditing;
end;
function TcxCustomGridTableController.GetIsIncSearching: Boolean;
begin
Result := DataController.Search.Searching;
end;
function TcxCustomGridTableController.GetIsItemMoving: Boolean;
begin
Result := FMovingItem <> nil;
end;
function TcxCustomGridTableController.GetItemsCustomizationPopup: TcxCustomGridItemsCustomizationPopup;
begin
if FItemsCustomizationPopup = nil then
FItemsCustomizationPopup := GetItemsCustomizationPopupClass.Create(GridView);
Result := FItemsCustomizationPopup;
end;
function TcxCustomGridTableController.GetMasterController: TcxCustomGridTableController;
begin
if GridView.IsDetail then
Result := GridView.MasterGridView.Controller as TcxCustomGridTableController
else
Result := nil;
end;
function TcxCustomGridTableController.GetMultiSelect: Boolean;
begin
Result := GridView.OptionsSelection.MultiSelect;
end;
function TcxCustomGridTableController.GetNewItemRecordFocused: Boolean;
begin
Result := DataController.NewItemRowFocused;
end;
function TcxCustomGridTableController.GetSelectedRecord(Index: Integer): TcxCustomGridRecord;
begin
Index := DataController.GetSelectedRowIndex(Index);
if Index = -1 then
Result := nil
else
Result := ViewData.Records[Index];
end;
function TcxCustomGridTableController.GetSelectedRecordCount: Integer;
begin
Result := DataController.GetSelectedCount;
end;
function TcxCustomGridTableController.GetViewData: TcxCustomGridTableViewData;
begin
Result := TcxCustomGridTableViewData(inherited ViewData);
end;
function TcxCustomGridTableController.GetViewInfo: TcxCustomGridTableViewInfo;
begin
Result := TcxCustomGridTableViewInfo(inherited ViewInfo);
end;
procedure TcxCustomGridTableController.SetDragHighlightedRecord(Value: TcxCustomGridRecord);
var
APrevDragHighlightedRecord: TcxCustomGridRecord;
begin
if FDragHighlightedRecord <> Value then
begin
APrevDragHighlightedRecord := FDragHighlightedRecord;
FDragHighlightedRecord := Value;
if APrevDragHighlightedRecord <> nil then
APrevDragHighlightedRecord.Invalidate;
if FDragHighlightedRecord <> nil then
FDragHighlightedRecord.Invalidate;
end;
end;
procedure TcxCustomGridTableController.SetEditingItem(Value: TcxCustomGridTableItem);
begin
FEditingController.EditingItem := Value;
end;
procedure TcxCustomGridTableController.SetFocusedItem(Value: TcxCustomGridTableItem);
var
APrevFocusedItem: TcxCustomGridTableItem;
begin
if (Value <> nil) and not Value.CanFocus(FocusedRecord) then Exit;
if FFocusedItem <> Value then
begin
APrevFocusedItem := FFocusedItem;
if (FFocusedItem <> nil) and not FEditingController.FEditingItemSetting then
FEditingController.HideEdit(True);
FFocusedItem := Value;
FocusedItemChanged(APrevFocusedItem);
CheckEdit;
end
else
MakeFocusedItemVisible;
end;
procedure TcxCustomGridTableController.SetFocusedItemIndex(Value: Integer);
begin
if (Value < -1) or (Value >= GridView.VisibleItemCount) then Exit;
if Value = -1 then
FocusedItem := nil
else
FocusedItem := GridView.VisibleItems[Value];
end;
procedure TcxCustomGridTableController.SetFocusedRecordIndex(Value: Integer);
var
AIndexesAreEqual: Boolean;
begin
if (0 <= Value) and (Value < ViewData.RecordCount) and
not ViewData.Records[Value].CanFocus then Exit;
AIndexesAreEqual := FocusedRecordIndex = Value;
if not DataController.ChangeFocusedRowIndex(Value) then Exit;
if FFocusOnRecordFocusing then
begin
if AIndexesAreEqual then MakeFocusedRecordVisible;
if FocusedRecord <> nil then GridView.Focused := True;
end;
end;
procedure TcxCustomGridTableController.SetIncSearchingText(const Value: string);
function GetItemIndex: Integer;
begin
if IsIncSearching then
Result := IncSearchingItem.Index
else
if ItemForIncSearching = nil then
Result := -1
else
Result := ItemForIncSearching.Index;
end;
begin
if (IncSearchingText <> Value) and (GetItemIndex <> -1) then
if Value = '' then
CancelIncSearching
else
DataController.Search.Locate(GetItemIndex, Value)
end;
procedure TcxCustomGridTableController.SetInternalTopRecordIndex(Value: Integer);
var
ARecordCountDelta: Integer;
//ft,lt: integer;
begin
if FTopRecordIndex <> Value then
begin
//ft:=gettickcount;
ARecordCountDelta := Value - FTopRecordIndex;
FTopRecordIndex := Value;
ViewInfo.AllowCheckCoordinates := False;
try
if Value <> -1 then
if GridView.CanOffset(ARecordCountDelta) then
GridView.Offset(ARecordCountDelta, 0, 0)
else
if GridView.IsMaster then
GridView.SizeChanged(not GridView.IsDetail)
{begin
GridView.SizeChanged(True);
if GridView.IsDetail and (GridView.MasterGridRecord <> nil) and
(GridView.MasterGridRecord.ViewInfo <> nil) then
GridView.MasterGridRecord.ViewInfo.Recalculate;
end}
else
GridView.LayoutChanged;
finally
ViewInfo.AllowCheckCoordinates := True;
end;
GridView.DoTopRecordIndexChanged;
{site.Update;
lt:=gettickcount;
application.MainForm.Caption := inttostr(lt-ft);}
end;
end;
procedure TcxCustomGridTableController.SetNewItemRecordFocused(Value: Boolean);
begin
DataController.NewItemRowFocused := Value;
end;
procedure TcxCustomGridTableController.SetScrollDirection(Value: TcxDirection);
begin
if FScrollDirection <> Value then
begin
DestroyScrollTimer;
FScrollDirection := Value;
if FScrollDirection <> dirNone then
CreateScrollTimer;
end;
end;
procedure TcxCustomGridTableController.SetTopRecordIndex(Value: Integer);
begin
CheckTopRecordIndex(Value);
InternalTopRecordIndex := Value;
end;
procedure TcxCustomGridTableController.DragScrollTimerHandler(Sender: TObject);
begin
Site.ScrollContent(FDragScrollDirection);
Site.Update;
end;
procedure TcxCustomGridTableController.GridModeBufferCountUpdateTimerHandler(Sender: TObject);
begin
CheckGridModeBufferCountUpdatePost;
end;
procedure TcxCustomGridTableController.PullFocusingScrollingTimerHandler(Sender: TObject);
begin
DoPullFocusingScrolling(FPullFocusingScrollingDirection);
Site.Update;
SavePullFocusingPos;
end;
procedure TcxCustomGridTableController.CreateScrollTimer;
begin
FScrollTimer := TcxTimer.Create(nil);
with FScrollTimer do
begin
Interval := GetScrollDataTimeInterval(FScrollDirection);
OnTimer := ScrollTimerHandler;
end;
end;
procedure TcxCustomGridTableController.DestroyScrollTimer;
begin
FreeAndNil(FScrollTimer);
end;
procedure TcxCustomGridTableController.ScrollTimerHandler(Sender: TObject);
var
AAccepted: Boolean;
begin
if CanScrollData(FScrollDirection) then
begin
if DragAndDropObject <> nil then
DragAndDropObject.BeforeScrolling;
ScrollData(FScrollDirection);
if DragAndDropObject <> nil then
begin
Site.Update;
DragAndDropObject.AfterScrolling;
TcxControlAccess(Site).DragAndDrop(
Site.ScreenToClient(Mouse.CursorPos), AAccepted);
end;
end;
end;
procedure TcxCustomGridTableController.DoEnter;
begin
inherited;
PostCheckEdit;
end;
procedure TcxCustomGridTableController.DoExit;
begin
if CancelEditingOnExit then
DataController.Cancel
else
DataController.PostEditingData;
inherited;
end;
procedure TcxCustomGridTableController.AfterPaint;
begin
inherited;
ProcessCheckEditPost;
end;
procedure TcxCustomGridTableController.BeforePaint;
begin
inherited;
FEditingController.CheckEditUpdatePost;
end;
function TcxCustomGridTableController.CanFocusOnClick(X, Y: Integer): Boolean;
begin
Result := inherited CanFocusOnClick(X, Y);
if Result and Site.IsFocused and IsEditing and
(ViewInfo.GetHitTest(X, Y).HitTestCode = htNavigator) then
Result := False;
end;
procedure TcxCustomGridTableController.DetailFocused(ADetail: TcxCustomGridView);
var
APrevFocusOnRecordFocusing: Boolean;
begin
APrevFocusOnRecordFocusing := FFocusOnRecordFocusing;
FFocusOnRecordFocusing := False;
try
inherited;
FocusedRecordIndex := ADetail.MasterGridRecordIndex;
finally
FFocusOnRecordFocusing := APrevFocusOnRecordFocusing;
end;
end;
function TcxCustomGridTableController.MayFocus: Boolean;
begin
Result := inherited MayFocus and
((Site <> nil) and not Site.IsFocused or not IsEditing or
not GridView.OptionsBehavior.AlwaysShowEditor and FEditingController.Edit.ValidateEdit(True));
end;
procedure TcxCustomGridTableController.RemoveFocus;
begin
inherited;
CheckFocusedRecordSelectionWhenExit(FocusedRecord);
InvalidateFocusedRecord;
end;
procedure TcxCustomGridTableController.SetFocus(ANotifyMaster: Boolean);
begin
if not FEditingController.CanRemoveEditFocus then Exit;
inherited;
InvalidateFocusedRecord;
PostCheckEdit;
end;
procedure TcxCustomGridTableController.AfterOffset;
begin
Site.PostMouseMove;
FEditingController.UpdateEdit;
FEditingController.AfterViewInfoCalculate;
UpdateScrollBars;
end;
procedure TcxCustomGridTableController.BeforeKillFocus;
begin
FEditingController.HideEdit(not GridView.IsDestroying);
if not GridView.IsDestroying and DataController.IsEditing then
begin
GridView.DontMakeMasterRecordVisible := True;
try
DataController.CheckBrowseMode;
//DataController.Post;
finally
GridView.DontMakeMasterRecordVisible := False;
end;
end;
inherited;
end;
procedure TcxCustomGridTableController.BeforeOffset;
begin
FEditingController.BeforeViewInfoCalculate;
end;
function TcxCustomGridTableController.CanAppend(ACheckOptions: Boolean): Boolean;
begin
Result := AllowAppendRecord and (dceoAppend in DataController.EditOperations) and
(not ACheckOptions or GridView.OptionsData.Appending);
end;
procedure TcxCustomGridTableController.CancelCheckEditPost;
begin
FCheckEditNeeded := False;
end;
function TcxCustomGridTableController.CanDelete(ACheckOptions: Boolean): Boolean;
begin
Result := (dceoDelete in DataController.EditOperations) and
(not ACheckOptions or GridView.OptionsData.Deleting);
end;
function TcxCustomGridTableController.CanEdit: Boolean;
begin
Result := (FocusedItem <> nil) and GridView.OptionsData.Editing and
([dceoEdit, dceoShowEdit] * DataController.EditOperations = [dceoEdit, dceoShowEdit]);
end;
function TcxCustomGridTableController.CanHScrollBarHide: Boolean;
begin
Result := not ViewInfo.NavigatorSiteViewInfo.Visible;
end;
function TcxCustomGridTableController.CanInsert(ACheckOptions: Boolean): Boolean;
begin
Result := (dceoInsert in DataController.EditOperations) and
(not ACheckOptions or GridView.OptionsData.Inserting);
end;
procedure TcxCustomGridTableController.CheckEdit;
begin
CancelCheckEditPost;
if FAllowCheckEdit and GridView.OptionsBehavior.AlwaysShowEditor then
if (GridView.Control <> nil) and TcxCustomGrid(GridView.Control).UpdateLocked then
PostCheckEdit
else
FEditingController.CheckEdit;
end;
procedure TcxCustomGridTableController.CheckCoordinates;
begin
inherited;
TopRecordIndex := TopRecordIndex;
end;
procedure TcxCustomGridTableController.CheckTopRecordIndex(var Value: Integer);
function IsGridModeAndScrollable: Boolean;
begin
Result := DataController.IsGridMode and not (dceInsert in DataController.EditState) and
not IsCheckingCoordinates;
end;
var
APrevAllowHideSite: Boolean;
AMaxValue: Integer;
begin
if FCheckingCoordinate then Exit;
FCheckingCoordinate := True;
APrevAllowHideSite := ViewInfo.AllowHideSite;
ViewInfo.AllowHideSite := False;
try
if Value < 0 then
begin
if IsGridModeAndScrollable and not DataController.IsBOF then
DataController.Scroll(Value);
Value := 0;
end;
if Value > ViewData.RecordCount - 1 then
begin
if DataController.IsGridMode and not DataController.IsEOF then
DataController.Scroll(Value - (ViewData.RecordCount - 1));
Value := ViewData.RecordCount - 1;
end;
if (Value <= 0) or not DataController.IsGridMode and (Value = TopRecordIndex) and
(ViewInfo.VisibleRecordCount < ViewData.RecordCount - Value) then Exit;
AMaxValue := GetMaxTopRecordIndexValue;
if Value > AMaxValue then
begin
if IsGridModeAndScrollable and not DataController.IsEOF then
begin
DataController.Scroll(Value - AMaxValue);
AMaxValue := GetMaxTopRecordIndexValue;
end;
Value := AMaxValue;
end;
finally
ViewInfo.AllowHideSite := APrevAllowHideSite;
FCheckingCoordinate := False;
end;
end;
function TcxCustomGridTableController.FindNextCustomItem(AFocusedItemIndex, AItemCount: Integer;
AGoForward, AGoOnCycle: Boolean; ACanFocus: TcxCustomGridTableCanItemFocus;
AData: TObject; var AItemIndex: Integer; out ACycleChanged: Boolean): Boolean;
var
AFromIndex: Integer;
function GetFromIndex: Integer;
begin
if AFocusedItemIndex = -1 then
if AGoForward then
Result := 0
else
if AGoOnCycle then
Result := AItemCount - 1
else
Result := -1
else
if AGoForward then
Result := AFocusedItemIndex + 1
else
Result := AFocusedItemIndex - 1;
end;
function CheckIndex(var AIndex: Integer): Boolean;
begin
Result := True;
if AGoForward then
if AIndex > AItemCount - 1 then
if AGoOnCycle then
begin
AIndex := 0;
ACycleChanged := True;
end
else
Result := False
else
else
if AIndex < 0 then
if AGoOnCycle then
begin
AIndex := AItemCount - 1;
ACycleChanged := True;
end
else
Result := False;
end;
procedure GetNextIndex(var AIndex: Integer);
begin
if AGoForward then
Inc(AIndex)
else
Dec(AIndex);
end;
begin
Result := False;
ACycleChanged := False;
if AItemCount = 0 then Exit;
AFromIndex := GetFromIndex;
AItemIndex := AFromIndex;
repeat
if not CheckIndex(AItemIndex) then Exit;
if (AItemIndex = AFocusedItemIndex) and not ACycleChanged then Exit;
Result := ACanFocus(GridView, AItemIndex, AData);
if Result or
ACycleChanged and ((AItemIndex = AFocusedItemIndex) or (AFocusedItemIndex = -1)) then Exit;
GetNextIndex(AItemIndex);
until (AItemIndex = AFromIndex) or (AItemIndex = -1) and (AFocusedItemIndex = -1);
end;
procedure TcxCustomGridTableController.FocusedItemChanged(APrevFocusedItem: TcxCustomGridTableItem);
begin
if GridView.IsLoading or GridView.IsDestroying then Exit;
IsReadyForImmediateEditing := False;
CancelIncSearching;
MakeFocusedItemVisible;
if FocusedRecord <> nil then
begin
FocusedRecord.Invalidate(APrevFocusedItem);
FocusedRecord.Invalidate(FocusedItem);
end;
if (APrevFocusedItem = nil) or (FocusedItem = nil) then
GridView.RefreshNavigators;
GridView.FocusedItemChanged(APrevFocusedItem, FFocusedItem);
end;
procedure TcxCustomGridTableController.FocusedRecordChanged(APrevFocusedRecordIndex,
AFocusedRecordIndex: Integer; ANewItemRecordFocusingChanged: Boolean);
begin
IsReadyForImmediateEditing := False;
with EditingController do
if HideEditOnFocusedRecordChange then HideEdit(True);
if not DataController.IsSelectionAnchorExist then
SetSelectionAnchor(AFocusedRecordIndex);
GridView.FocusedRecordChanged(APrevFocusedRecordIndex, AFocusedRecordIndex, ANewItemRecordFocusingChanged);
end;
function TcxCustomGridTableController.GetCancelEditingOnExit: Boolean;
begin
Result :=
GridView.OptionsData.CancelOnExit and
(DataController.EditState * [dceInsert, dceChanging, dceModified] = [dceInsert]);
end;
function TcxCustomGridTableController.GetFilterMRUItemsPopupClass: TcxGridFilterMRUItemsPopupClass;
begin
Result := TcxGridFilterMRUItemsPopup;
end;
function TcxCustomGridTableController.GetFilterPopupClass: TcxGridFilterPopupClass;
begin
Result := TcxGridFilterPopup;
end;
function TcxCustomGridTableController.GetFocusedRecord: TcxCustomGridRecord;
begin
if (0 <= FocusedRecordIndex) and (FocusedRecordIndex < ViewData.RecordCount) then
Result := ViewData.Records[FocusedRecordIndex]
else
Result := nil;
end;
function TcxCustomGridTableController.GetItemsCustomizationPopupClass: TcxCustomGridItemsCustomizationPopupClass;
begin
Result := TcxCustomGridItemsCustomizationPopup;
end;
function TcxCustomGridTableController.GetMaxTopRecordIndexValue: Integer;
begin
Result := ViewData.RecordCount -
GetVisibleRecordCount(ViewData.RecordCount - 1, False);
end;
function TcxCustomGridTableController.GetPatternObject(AObject: TPersistent): TPersistent;
begin
if AObject is TcxCustomGridTableItem then
Result := TcxCustomGridTableView(GridView.PatternGridView).FindItemByID(TcxCustomGridTableItem(AObject).ID)
else
Result := inherited GetPatternObject(AObject);
end;
function TcxCustomGridTableController.GetScrollBarOffsetBegin: Integer;
begin
if DataController.IsGridMode then
Result := Ord(not DataController.IsBOF)
else
Result := 0;
end;
function TcxCustomGridTableController.GetScrollBarOffsetEnd: Integer;
begin
if DataController.IsGridMode then
Result := Ord(not DataController.IsEOF)
else
Result := 0;
end;
function TcxCustomGridTableController.GetScrollBarPos: Integer;
var
AIcxGridDataController: IcxGridDataController;
begin
if Supports(TObject(DataController), IcxGridDataController, AIcxGridDataController) then
Result := AIcxGridDataController.GetScrollBarPos
else
Result := -1;
if Result = -1 then
Result := ScrollBarOffsetBegin + TopRecordIndex;
end;
function TcxCustomGridTableController.GetScrollBarRecordCount: Integer;
var
AIcxGridDataController: IcxGridDataController;
begin
if Supports(TObject(DataController), IcxGridDataController, AIcxGridDataController) then
Result := AIcxGridDataController.GetScrollBarRecordCount
else
Result := -1;
if Result = -1 then
Result := ViewData.RecordCount + ScrollBarOffsetBegin + ScrollBarOffsetEnd;
end;
function TcxCustomGridTableController.GetVisibleRecordCount(AFirstRecordIndex: Integer;
ACalculateDown: Boolean = True): Integer;
var
AVisibleEqualHeightRecordCount: Integer;
AViewInfo: TcxCustomGridTableViewInfo;
function CanCalculateVisibleEqualHeightRecordCount: Boolean;
begin
AVisibleEqualHeightRecordCount := ViewInfo.CalculateVisibleEqualHeightRecordCount;
Result := AVisibleEqualHeightRecordCount <> -1;
end;
begin
if IsRectEmpty(ViewInfo.Bounds) then
Result := 0
else
if GridView.IsEqualHeightRecords and CanCalculateVisibleEqualHeightRecordCount then
begin // -2-4 ms
Result := AVisibleEqualHeightRecordCount;
if ACalculateDown then
if AFirstRecordIndex + Result > ViewData.RecordCount then
Result := ViewData.RecordCount - AFirstRecordIndex
else
else
if AFirstRecordIndex - Result + 1 < 0 then
Result := AFirstRecordIndex + 1;
end
else
begin
ViewInfo.CalculateDown := ACalculateDown;
AViewInfo := TcxCustomGridTableViewInfo(GridView.CreateViewInfo);
try
AViewInfo.CalculateDown := ACalculateDown;
AViewInfo.FirstRecordIndex := AFirstRecordIndex;
AViewInfo.MainCalculate(ViewInfo.Bounds);
Result := AViewInfo.VisibleRecordCount;
finally
AViewInfo.Free;
ViewInfo.CalculateDown := True;
end;
end;
end;
procedure TcxCustomGridTableController.PostCheckEdit;
begin
if FAllowCheckEdit then FCheckEditNeeded := True;
end;
procedure TcxCustomGridTableController.ProcessCheckEditPost;
begin
if FCheckEditNeeded then CheckEdit;
end;
procedure TcxCustomGridTableController.ScrollData(ADirection: TcxDirection);
begin
end;
procedure TcxCustomGridTableController.SetFocusedRecord(Value: TcxCustomGridRecord);
begin
if Value = nil then
FocusedRecordIndex := -1
else
FocusedRecordIndex := Value.Index;
end;
procedure TcxCustomGridTableController.SetScrollBarPos(Value: Integer);
var
AIcxGridDataController: IcxGridDataController;
begin
if not Supports(TObject(DataController), IcxGridDataController, AIcxGridDataController) or
not AIcxGridDataController.SetScrollBarPos(Value) then
if DataController.IsGridMode then
TopRecordIndex := Value - ScrollBarOffsetBegin
else
InternalTopRecordIndex := Value;
end;
procedure TcxCustomGridTableController.CancelGridModeBufferCountUpdate;
begin
FGridModeBufferCountUpdateNeeded := False;
FreeAndNil(FGridModeBufferCountUpdateTimer);
end;
procedure TcxCustomGridTableController.CheckGridModeBufferCountUpdatePost;
begin
if FGridModeBufferCountUpdateNeeded and ViewInfo.Calculated then
begin
CancelGridModeBufferCountUpdate;
(DataController as IcxGridDataController).CheckGridModeBufferCount;
end;
end;
procedure TcxCustomGridTableController.PostGridModeBufferCountUpdate;
begin
if DataController.IsGridMode and not FGridModeBufferCountUpdateNeeded then
begin
FGridModeBufferCountUpdateNeeded := True;
FGridModeBufferCountUpdateTimer := TcxTimer.Create(nil);
with FGridModeBufferCountUpdateTimer do
begin
Interval := 1;
OnTimer := GridModeBufferCountUpdateTimerHandler;
end;
end;
end;
function TcxCustomGridTableController.CanScrollData(ADirection: TcxDirection): Boolean;
begin
Result := False;
end;
function TcxCustomGridTableController.GetScrollDataTimeInterval(ADirection: TcxDirection): Integer;
begin
Result := ScrollTimeInterval;
end;
function TcxCustomGridTableController.CanPostponeRecordSelection: Boolean;
begin
Result := not IsEditing;
end;
function TcxCustomGridTableController.CanProcessMultiSelect(AIsKeyboard: Boolean): Boolean;
begin
Result := MultiSelect and (not AIsKeyboard or GridView.Focused);
end;
function TcxCustomGridTableController.CanProcessMultiSelect(AHitTest: TcxCustomGridHitTest;
AShift: TShiftState): Boolean;
begin
Result := //not (ssDouble in AShift) and
CanProcessMultiSelect(False) and IsClickableRecordHitTest(AHitTest) and
(TcxGridRecordHitTest(AHitTest).GridRecord <> nil) and
TcxGridRecordHitTest(AHitTest).GridRecord.Focused;
end;
function TcxCustomGridTableController.CanProcessMultiSelect(AKey: Word;
AShift: TShiftState; AFocusedRecordChanged: Boolean): Boolean;
begin
Result := CanProcessMultiSelect(True) and
IsKeyForMultiSelect(AKey, AShift, AFocusedRecordChanged);
end;
procedure TcxCustomGridTableController.ChangeRecordSelection(ARecord: TcxCustomGridRecord;
Value: Boolean);
begin
if MultiSelect then
DataController.ChangeRowSelection(ARecord.Index, Value);
end;
procedure TcxCustomGridTableController.CheckFocusedRecordSelectionWhenExit(ARecord: TcxCustomGridRecord);
begin
if GridView.OptionsSelection.UnselectFocusedRecordOnExit and
MultiSelect and (ARecord <> nil) and (SelectedRecordCount = 1) and ARecord.Selected then
ARecord.Selected := False;
end;
procedure TcxCustomGridTableController.DoMouseNormalSelection(AHitTest: TcxCustomGridHitTest);
begin
DoNormalSelection;
end;
procedure TcxCustomGridTableController.DoMouseRangeSelection(AClearSelection: Boolean = True;
AData: TObject = nil);
begin
DoRangeSelection(AClearSelection);
end;
procedure TcxCustomGridTableController.DoNormalSelection;
begin
if (SelectedRecordCount = 1) and (SelectedRecords[0] = FocusedRecord) then
Exit;
BeginUpdate;
try
ClearSelection;
if FocusedRecord <> nil then
FocusedRecord.Selected := True;
finally
EndUpdate;
end;
end;
procedure TcxCustomGridTableController.DoNormalSelectionWithAnchor(ASelect: Boolean = True);
begin
SetSelectionAnchor(FocusedRecordIndex);
if ASelect then DoNormalSelection;
end;
procedure TcxCustomGridTableController.DoRangeSelection(AClearSelection: Boolean = True);
begin //!!!
if (FocusedRecordIndex <> -1) {and not (dceInsert in DataController.EditState) }then
DataController.SelectFromAnchor(FocusedRecordIndex, not AClearSelection);
end;
procedure TcxCustomGridTableController.DoToggleRecordSelection;
begin
if FocusedRecord <> nil then
with FocusedRecord do
Selected := not Selected;
end;
procedure TcxCustomGridTableController.FinishSelection;
begin
FIsRecordUnselecting := False;
end;
procedure TcxCustomGridTableController.InvalidateFocusedRecord;
begin
if FocusedRecord <> nil then FocusedRecord.Invalidate;
end;
procedure TcxCustomGridTableController.InvalidateSelection;
var
I: Integer;
ARecord: TcxCustomGridRecord;
begin
for I := 0 to SelectedRecordCount - 1 do
begin
ARecord := SelectedRecords[I];
if ARecord <> nil then ARecord.Invalidate;
end;
InvalidateFocusedRecord;
end;
function TcxCustomGridTableController.IsKeyForMultiSelect(AKey: Word;
AShift: TShiftState; AFocusedRecordChanged: Boolean): Boolean;
begin
Result := (AKey = VK_SPACE) or (AKey = VK_PRIOR) or (AKey = VK_NEXT) or
AFocusedRecordChanged and not (((AKey = VK_INSERT) or (AKey = Ord('C'))) and (AShift = [ssCtrl])); // for grid mode
end;
function TcxCustomGridTableController.IsRecordSelected(ARecord: TcxCustomGridRecord): Boolean;
begin
Result := DataController.IsRowSelected(ARecord.Index);
end;
procedure TcxCustomGridTableController.MultiSelectKeyDown(var Key: Word; Shift: TShiftState);
begin
if (Shift = [ssCtrl]) and (Key = VK_SPACE) then
begin
DoToggleRecordSelection;
FEatKeyPress := True;
end
else
if (ssShift in Shift) and (Key <> 0) then
DoRangeSelection
else
DoNormalSelectionWithAnchor(Shift <> [ssCtrl]);
end;
procedure TcxCustomGridTableController.MultiSelectMouseDown(AHitTest: TcxCustomGridHitTest;
AShift: TShiftState);
var
APressedRecord: TcxCustomGridRecord;
ASelectionShift: TShiftState;
procedure AssignSelectionAnchor;
begin
if (ASelectionShift = []) or (ASelectionShift = [ssCtrl]) then
SetSelectionAnchor(APressedRecord.Index);
end;
function MustPostponeDoing: Boolean;
begin
Result := CanPostponeRecordSelection and
APressedRecord.Selected and not (ssDouble in AShift);
end;
procedure PostponeDoing;
begin
FIsRecordUnselecting := True;
FUnselectingRecordIndex := APressedRecord.Index;
end;
procedure ProcessRecordSelectionToggling;
begin
if MustPostponeDoing then
PostponeDoing
else
DoToggleRecordSelection;
end;
procedure ProcessNormalSelection;
begin
if MustPostponeDoing then
PostponeDoing
else
DoMouseNormalSelection(AHitTest);
end;
begin
APressedRecord := TcxGridRecordHitTest(AHitTest).GridRecord;
ASelectionShift := AShift - [ssLeft, ssRight, ssMiddle, ssDouble];
AssignSelectionAnchor;
if (ASelectionShift = [ssCtrl]) and SupportsRecordSelectionToggling then
ProcessRecordSelectionToggling
else
if (ASelectionShift = [ssShift]) or (ASelectionShift = [ssCtrl, ssShift]) then
DoMouseRangeSelection(not (ssCtrl in AShift) or not SupportsAdditiveSelection, AHitTest)
else
ProcessNormalSelection;
end;
procedure TcxCustomGridTableController.MultiSelectMouseUp(AHitTest: TcxCustomGridHitTest;
AShift: TShiftState);
var
ASelectionShift: TShiftState;
begin
if FIsRecordUnselecting and (FUnselectingRecordIndex <> -1) and
(FUnselectingRecordIndex = TcxGridRecordHitTest(AHitTest).GridRecord.Index) then
begin
ASelectionShift := AShift - [ssLeft, ssRight, ssMiddle, ssDouble];
if (ASelectionShift = [ssCtrl]) and SupportsRecordSelectionToggling then
DoToggleRecordSelection
else
DoNormalSelection;
end;
end;
procedure TcxCustomGridTableController.SelectFocusedRecord;
begin
if CanProcessMultiSelect(True) then
DoNormalSelectionWithAnchor;
end;
procedure TcxCustomGridTableController.SetSelectionAnchor(AGridRecordIndex: Integer);
begin
if AGridRecordIndex <> -1 then
DataController.SetSelectionAnchor(AGridRecordIndex);
end;
function TcxCustomGridTableController.SupportsAdditiveSelection: Boolean;
begin
Result := True;
end;
function TcxCustomGridTableController.SupportsRecordSelectionToggling: Boolean;
begin
Result := True;
end;
function TcxCustomGridTableController.CanFocusNextItem(AFocusedItemIndex, ANextItemIndex: Integer;
AGoForward, AGoOnCycle, AGoToNextRecordOnCycle: Boolean): Boolean;
begin
Result := ANextItemIndex <> -1;
end;
function TcxCustomGridTableController.FocusedRecordHasCells(ACheckCellSelectionAbility: Boolean): Boolean;
begin
Result := (FocusedRecord <> nil) and FocusedRecord.HasCells and
(not ACheckCellSelectionAbility or FocusedRecord.CanFocusCells);
end;
procedure TcxCustomGridTableController.FocusNextPage(ASyncSelection: Boolean);
begin
MakeFocusedRecordVisible;
if FocusedRecordIndex = TopRecordIndex + ViewInfo.VisibleRecordCount - 1 then
ShowNextPage;
FocusRecord(TopRecordIndex + ViewInfo.VisibleRecordCount - 1, ASyncSelection);
Site.Update;
end;
procedure TcxCustomGridTableController.FocusPrevPage(ASyncSelection: Boolean);
begin
MakeFocusedRecordVisible;
if FocusedRecordIndex = TopRecordIndex then
ShowPrevPage;
FocusRecord(TopRecordIndex, ASyncSelection);
Site.Update;
end;
function TcxCustomGridTableController.IsKeyForController(AKey: Word; AShift: TShiftState): Boolean;
begin
Result :=
(AKey = VK_TAB) or (AKey = VK_UP) or (AKey = VK_DOWN) or (AKey = VK_PRIOR) or
(AKey = VK_NEXT) or (AKey = VK_INSERT) or (AKey = VK_ESCAPE);
if not Result and GridView.OptionsBehavior.AlwaysShowEditor then
Result := (AKey = VK_LEFT) or (AKey = VK_RIGHT);
end;
procedure TcxCustomGridTableController.ScrollPage(AForward: Boolean);
var
AIcxGridDataController: IcxGridDataController;
begin
if not Supports(TObject(DataController), IcxGridDataController, AIcxGridDataController) or
not AIcxGridDataController.DoScrollPage(AForward) then
if AForward then
ShowNextPage
else
ShowPrevPage;
end;
procedure TcxCustomGridTableController.ScrollRecords(AForward: Boolean; ACount: Integer);
var
APrevAllowAppendRecord: Boolean;
AIcxGridDataController: IcxGridDataController;
begin
APrevAllowAppendRecord := AllowAppendRecord;
AllowAppendRecord := False;
try
if not Supports(TObject(DataController), IcxGridDataController, AIcxGridDataController) or
not AIcxGridDataController.DoScroll(AForward) then
if AForward then
TopRecordIndex := TopRecordIndex + ACount
else
TopRecordIndex := TopRecordIndex - ACount;
finally
AllowAppendRecord := APrevAllowAppendRecord;
end;
end;
procedure TcxCustomGridTableController.ShowNextPage;
begin
TopRecordIndex := TopRecordIndex + ViewInfo.VisibleRecordCount;
end;
procedure TcxCustomGridTableController.ShowPrevPage;
begin
TopRecordIndex := TopRecordIndex - ViewInfo.VisibleRecordCount;
end;
procedure TcxCustomGridTableController.DoPullFocusing(AHitTest: TcxGridRecordHitTest);
begin
AHitTest.GridRecord.Focused := True;
if AHitTest is TcxGridRecordCellHitTest then
TcxGridRecordCellHitTest(AHitTest).Item.Focused := True;
if MultiSelect and IsPullFocusingPosChanged then
DoMouseRangeSelection(True, FPullFocusingOriginHitTest);
end;
procedure TcxCustomGridTableController.DoPullFocusingScrolling(ADirection: TcxDirection);
var
APrevAllowAppendRecord: Boolean;
begin
if ADirection in [dirUp, dirDown] then
begin
case ADirection of
dirUp:
FocusedRecordIndex := TopRecordIndex;
dirDown:
FocusedRecordIndex := TopRecordIndex + ViewInfo.VisibleRecordCount - 1;
end;
APrevAllowAppendRecord := AllowAppendRecord;
AllowAppendRecord := False;
try
FocusNextRecord(FocusedRecordIndex, ADirection = dirDown, False, False, False);
finally
AllowAppendRecord := APrevAllowAppendRecord;
end;
end;
if MultiSelect and IsPullFocusingPosChanged then
DoMouseRangeSelection(True, FPullFocusingOriginHitTest);
end;
function TcxCustomGridTableController.GetPullFocusingScrollingDirection(X, Y: Integer;
out ADirection: TcxDirection): Boolean;
var
R: TRect;
begin
Result := False;
R := ViewInfo.RecordsViewInfo.Bounds;
if IsRecordsScrollHorizontal and (X < R.Left) or
not IsRecordsScrollHorizontal and (Y < R.Top) then
begin
ADirection := dirUp;
Result := True;
end;
if IsRecordsScrollHorizontal and (X >= R.Right) or
not IsRecordsScrollHorizontal and (Y >= R.Bottom) then
begin
ADirection := dirDown;
Result := True;
end;
end;
function TcxCustomGridTableController.IsPullFocusingPosChanged: Boolean;
begin
Result := (FPullFocusingRecordId <> DataController.GetRowId(FocusedRecordIndex)) or
(FPullFocusingItem <> FocusedItem);
end;
procedure TcxCustomGridTableController.SavePullFocusingPos;
begin
FPullFocusingRecordId := DataController.GetRowId(FocusedRecordIndex);
FPullFocusingItem := FocusedItem;
end;
procedure TcxCustomGridTableController.StartPullFocusing(AHitTest: TcxCustomGridHitTest);
begin
FIsPullFocusing := True;
FPullFocusingMousePos := ViewInfo.MousePos;// Point(-1, -1);
FPullFocusingOriginHitTest := AHitTest;
FPullFocusingRecordId := Null;
end;
procedure TcxCustomGridTableController.StopPullFocusing;
begin
StopPullFocusingScrolling;
FPullFocusingRecordId := Null;
FPullFocusingItem := nil;
FIsPullFocusing := False;
end;
procedure TcxCustomGridTableController.StartPullFocusingScrolling(ADirection: TcxDirection);
begin
FPullFocusingScrollingDirection := ADirection;
if FPullFocusingScrollingTimer <> nil then Exit;
FPullFocusingScrollingTimer := TcxTimer.Create(nil);
with FPullFocusingScrollingTimer do
begin
Interval := PullFocusingScrollingTimeInterval;
OnTimer := PullFocusingScrollingTimerHandler;
end;
end;
procedure TcxCustomGridTableController.StopPullFocusingScrolling;
begin
FreeAndNil(FPullFocusingScrollingTimer);
end;
function TcxCustomGridTableController.SupportsPullFocusing: Boolean;
begin
Result := GridView.OptionsBehavior.PullFocusing;
end;
function TcxCustomGridTableController.GetDragScrollDirection(X, Y: Integer): TcxDirection;
const
ADirections: array[Boolean, Boolean] of TcxDirection = ((dirUp, dirDown), (dirLeft, dirRight));
var
AHitTest: TcxCustomGridHitTest;
ARecord: TcxCustomGridRecord;
begin
Result := dirNone;
AHitTest := ViewInfo.GetHitTest(X, Y);
if AHitTest is TcxGridRecordHitTest then
begin
ARecord := TcxGridRecordHitTest(AHitTest).GridRecord;
if IsFirstRecordForDragScroll(ARecord) then
Result := ADirections[IsRecordsScrollHorizontal, False]
else
if IsLastRecordForDragScroll(ARecord) then
Result := ADirections[IsRecordsScrollHorizontal, True];
end;
end;
function TcxCustomGridTableController.GetDragScrollInterval: Integer;
begin
Result := 20;
end;
function TcxCustomGridTableController.IsFirstRecordForDragScroll(ARecord: TcxCustomGridRecord): Boolean;
begin
Result := ARecord.Index = TopRecordIndex;
end;
function TcxCustomGridTableController.IsLastRecordForDragScroll(ARecord: TcxCustomGridRecord): Boolean;
begin
Result := ARecord.ViewInfo.Index >= ViewInfo.RecordsViewInfo.VisibleCount - 1;
end;
procedure TcxCustomGridTableController.ProcessDragFocusing(X, Y: Integer);
var
AHitTest: TcxCustomGridHitTest;
begin
AHitTest := ViewInfo.GetHitTest(X, Y);
if AHitTest is TcxGridRecordHitTest then
TcxGridRecordHitTest(AHitTest).GridRecord.Focused := True
else
if AHitTest is TcxCustomGridViewHitTest then
TcxCustomGridViewHitTest(AHitTest).GridView.Focused := True;
end;
procedure TcxCustomGridTableController.StartDragScroll(ADirection: TcxDirection);
begin
FDragScrollDirection := ADirection;
if FDragScrollTimer <> nil then Exit;
FDragScrollTimer := TcxTimer.Create(nil);
with FDragScrollTimer do
begin
Interval := GetDragScrollInterval;
OnTimer := DragScrollTimerHandler;
end;
end;
procedure TcxCustomGridTableController.StopDragScroll;
begin
FreeAndNil(FDragScrollTimer);
end;
function TcxCustomGridTableController.IsDragScroll: Boolean;
begin
Result := FDragScrollTimer <> nil;
end;
function TcxCustomGridTableController.GetDragOpenInfo(AHitTest: TcxCustomGridHitTest): TcxCustomGridDragOpenInfo;
begin
if AHitTest.HitTestCode = htExpandButton then
Result := TcxGridDragOpenInfoExpand.Create(TcxGridExpandButtonHitTest(AHitTest).GridRecord)
else
Result := nil;
end;
function TcxCustomGridTableController.IsDragOpenHitTest(AHitTest: TcxCustomGridHitTest;
out ADragOpenInfo: TcxCustomGridDragOpenInfo): Boolean;
begin
ADragOpenInfo := GetDragOpenInfo(AHitTest);
Result := ADragOpenInfo <> nil;
end;
function TcxCustomGridTableController.GetItemForIncSearching: TcxCustomGridTableItem;
begin
if GridView.OptionsSelection.CellSelect then
Result := FocusedItem
else
begin
Result := GridView.OptionsBehavior.IncSearchItem;
if (Result = nil) and (GridView.VisibleItemCount <> 0) then
Result := GridView.VisibleItems[0];
end;
end;
procedure TcxCustomGridTableController.IncSearchKeyDown(var Key: Word; Shift: TShiftState);
begin
case Key of
VK_ESCAPE:
begin
CancelIncSearching;
Key := 0;
end;
VK_BACK:
begin
IncSearchingText := Copy(IncSearchingText, 1, Length(IncSearchingText) - 1);
Key := 0;
end;
VK_UP, VK_DOWN:
if Shift = [ssCtrl] then
begin
DataController.Search.LocateNext(Key = VK_DOWN);
Key := 0;
end;
end;
end;
function TcxCustomGridTableController.GetEditingControllerClass: TcxGridEditingControllerClass;
begin
Result := TcxGridEditingController;
end;
procedure TcxCustomGridTableController.BeginDragAndDrop;
begin
FEditingController.HideEdit(True);
inherited;
end;
procedure TcxCustomGridTableController.ControlFocusChanged;
begin
inherited;
InvalidateSelection;
end;
procedure TcxCustomGridTableController.DoCancelMode;
begin
inherited;
ClickedCellViewInfo := nil;
StopPullFocusing;
FinishSelection;
end;
procedure TcxCustomGridTableController.DoKeyDown(var Key: Word; Shift: TShiftState);
var
APrevTopRecordIndex, APrevFocusedRecordIndex: Integer;
AGridViewLink: TcxGridListenerLink;
begin
APrevTopRecordIndex := TopRecordIndex;
AGridViewLink := GridView.AddListenerLink;
try
try
if IsIncSearching then
begin
IncSearchKeyDown(Key, Shift);
if AGridViewLink.GridView = nil then Exit;
end;
APrevFocusedRecordIndex := FocusedRecordIndex;
inherited;
if AGridViewLink.GridView <> nil then
if CanProcessMultiSelect(Key, Shift, FocusedRecordIndex <> APrevFocusedRecordIndex) then
MultiSelectKeyDown(Key, Shift);
finally
if AGridViewLink.GridView <> nil then
begin
if TopRecordIndex <> APrevTopRecordIndex then
Site.Update;
end
else
Key := 0;
end;
finally
AGridViewLink.Free;
end;
end;
procedure TcxCustomGridTableController.EndDragAndDrop(Accepted: Boolean);
begin
ScrollDirection := dirNone;
inherited;
CheckEdit;
end;
function TcxCustomGridTableController.FindNextItem(AFocusedItemIndex: Integer;
AGoForward, AGoOnCycle: Boolean; out ACycleChanged: Boolean;
ARecord: TcxCustomGridRecord): Integer;
begin
if not FindNextCustomItem(AFocusedItemIndex, GridView.VisibleItemCount,
AGoForward, AGoOnCycle, @cxCustomGridTableControllerCanFocusItem, ARecord, Result, ACycleChanged) then
Result := -1;
end;
function TcxCustomGridTableController.FindNextRecord(AFocusedRecordIndex: Integer;
AGoForward, AGoOnCycle: Boolean; out ACycleChanged: Boolean): Integer;
begin
if DataController.IsGridMode then
if AGoForward then
if not DataController.IsEOF and (AFocusedRecordIndex = ViewData.RecordCount - 1) then
begin
DataController.Scroll(1);
if not DataController.IsEOF then
Dec(AFocusedRecordIndex);
end
else
else
if (AFocusedRecordIndex = 0) and not DataController.IsBOF then
begin
DataController.Scroll(-1);
if not DataController.IsBOF then
Inc(AFocusedRecordIndex);
end;
if not FindNextCustomItem(AFocusedRecordIndex, ViewData.RecordCount, AGoForward,
AGoOnCycle, @cxCustomGridTableControllerCanFocusRecord, nil, Result, ACycleChanged) then
Result := -1;
end;
function TcxCustomGridTableController.HasFilterMRUItemsPopup: Boolean;
begin
Result := FFilterMRUItemsPopup <> nil;
end;
function TcxCustomGridTableController.HasFilterPopup: Boolean;
begin
Result := FFilterPopup <> nil;
end;
function TcxCustomGridTableController.HasFocusedControls: Boolean;
begin
Result := inherited HasFocusedControls or
{IsEditing}(FEditingController.Edit <> nil) and FEditingController.Edit.IsFocused;
end;
function TcxCustomGridTableController.HasItemsCustomizationPopup: Boolean;
begin
Result := FItemsCustomizationPopup <> nil;
end;
function TcxCustomGridTableController.IsClickableRecordHitTest(AHitTest: TcxCustomGridHitTest): Boolean;
begin
Result := (AHitTest is TcxGridRecordHitTest) and TcxGridRecordHitTest(AHitTest).CanClick;
end;
function TcxCustomGridTableController.IsDataFullyVisible(AIsCallFromMaster: Boolean = False): Boolean;
begin
Result := ViewInfo.VisibleRecordCount = ViewData.RecordCount;
end;
procedure TcxCustomGridTableController.KeyDown(var Key: Word; Shift: TShiftState);
var
ARemoveFocus: Boolean;
begin
inherited;
if not FBlockRecordKeyboardHandling and (FocusedRecord <> nil) then
FocusedRecord.KeyDown(Key, Shift);
case Key of
VK_INSERT:
if (Shift = []) and CanInsert(True) then
CreateNewRecord(False)
else
if (Shift = [ssCtrl]) and not IsEditing then
GridView.CopyToClipboard(False);
VK_DELETE:
if ((Shift = []) or (Shift = [ssCtrl])) and CanDelete(True) then
begin
DeleteSelection;
Key := 0;
end;
VK_ESCAPE:
if DataController.IsEditing then
begin
DataController.Cancel;
if not DataController.IsEditing and MultiSelect and (FocusedRecord <> nil) then
FocusedRecord.Selected := True;
Key := 0;
end;
VK_RETURN, VK_TAB:
if (Key = VK_RETURN) and GridView.OptionsBehavior.GoToNextCellOnEnter or
(Key = VK_TAB) and GridView.OptionsBehavior.FocusCellOnTab then
begin
ARemoveFocus := False;
if Shift + [ssShift] = [ssShift] then
if FocusNextCell(Shift = [], False) or (Key = VK_RETURN) then
Key := 0
else
ARemoveFocus := not EditingController.IsEditing
else
ARemoveFocus := (Key = VK_TAB) and (Shift + [ssShift, ssCtrl] = [ssShift, ssCtrl]);
if ARemoveFocus then
TcxCustomGrid(GridView.Control).RemoveFocus(not (ssShift in Shift));
end;
VK_PRIOR:
FocusPrevPage(False);
VK_NEXT:
FocusNextPage(False);
Ord('A'):
if Shift = [ssCtrl] then SelectAll;
Ord('C'):
if (Shift = [ssCtrl]) and not IsEditing then
GridView.CopyToClipboard(False);
end;
end;
procedure TcxCustomGridTableController.KeyPress(var Key: Char);
begin
inherited;
if FEatKeyPress then
begin
FEatKeyPress := False;
Exit;
end;
// inc search
if ((Key) in IncSearchStartChars) and
(ItemForIncSearching <> nil) and ItemForIncSearching.CanIncSearch and
not DataController.IsEditing then
begin
if Key <> #8 then
IncSearchingText := IncSearchingText + Key;
Key := #0;
end;
// editing
if ((Key) in EditStartChars) and
(FocusedRecord <> nil) and FocusedRecord.HasCells and (FocusedItem <> nil) then
begin
EditingController.ShowEdit(FocusedItem, Key);
Key := #0;
end;
end;
procedure TcxCustomGridTableController.MouseDown(Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
var
AHitTest: TcxCustomGridHitTest;
AGridViewLink: TcxGridListenerLink;
begin
FEditingController.StopEditShowingTimer;
AHitTest := ViewInfo.GetHitTest(X, Y);
AGridViewLink := GridView.AddListenerLink;
try
try
inherited;
finally
//AHitTest := ViewInfo.GetHitTest(X, Y);
if AGridViewLink.GridView <> nil then
begin
if not (AHitTest is TcxCustomGridViewHitTest) or
(TcxCustomGridViewHitTest(AHitTest).GridView = AGridViewLink.GridView) then
begin
if CanProcessMultiSelect(AHitTest, Shift) then
MultiSelectMouseDown(AHitTest, Shift);
if (Shift = [ssLeft]) and IsClickableRecordHitTest(AHitTest) and
SupportsPullFocusing and Site.MouseCapture and (GridView.DragMode = dmManual) then
StartPullFocusing(AHitTest);
end;
end;
end;
finally
AGridViewLink.Free;
end;
end;
procedure TcxCustomGridTableController.MouseMove(Shift: TShiftState; X, Y: Integer);
var
AHitTest: TcxCustomGridHitTest;
ADirection: TcxDirection;
begin
inherited;
if FIsPullFocusing then
begin
AHitTest := ViewInfo.GetHitTest(X, Y);
if (AHitTest is TcxGridRecordHitTest) and CanHandleHitTest(AHitTest) then
if (FPullFocusingMousePos.X <> X) or (FPullFocusingMousePos.Y <> Y) then
begin
StopPullFocusingScrolling;
DoPullFocusing(TcxGridRecordHitTest(AHitTest));
SavePullFocusingPos;
Site.Update;
end
else
else
if GetPullFocusingScrollingDirection(X, Y, ADirection) then
StartPullFocusingScrolling(ADirection);
FPullFocusingMousePos := Point(X, Y);
end;
end;
procedure TcxCustomGridTableController.MouseUp(Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
var
AHitTest: TcxCustomGridHitTest;
begin
inherited;
ClickedCellViewInfo := nil;
StopPullFocusing;
AHitTest := ViewInfo.GetHitTest(X, Y);
if (Button = mbLeft) and CanProcessMultiSelect(AHitTest, Shift) then
MultiSelectMouseUp(AHitTest, Shift);
FinishSelection;
end;
function TcxCustomGridTableController.ProcessDetailDialogChar(ADetail: TcxCustomGridView;
ACharCode: Word): Boolean;
var
ARecord: TcxCustomGridRecord;
begin
Result := inherited ProcessDetailDialogChar(ADetail, ACharCode);
if not Result then
begin
ARecord := ViewData.GetRecordByIndex(ADetail.MasterGridRecordIndex);
Result := (ARecord <> nil) and (ARecord.ViewInfo <> nil) and
ARecord.ViewInfo.ProcessDialogChar(ACharCode);
end;
end;
function TcxCustomGridTableController.ProcessDialogChar(ACharCode: Word): Boolean;
begin
Result :=
(FocusedRecord <> nil) and (FocusedRecord.ViewInfo <> nil) and
FocusedRecord.ViewInfo.ProcessDialogChar(ACharCode) or
inherited ProcessDialogChar(ACharCode);
end;
function TcxCustomGridTableController.SupportsTabAccelerators(AGridRecord: TcxCustomGridRecord): Boolean;
begin
Result := AGridRecord.Focused;
end;
procedure TcxCustomGridTableController.BeforeStartDrag;
begin
inherited;
if DataController.IsEditing then
if dceModified in DataController.EditState then
DataController.Post
else
DataController.Cancel;
end;
function TcxCustomGridTableController.CanDrag(X, Y: Integer): Boolean;
var
AHitTest: TcxCustomGridHitTest;
begin
Result := inherited CanDrag(X, Y);
if Result then
begin
AHitTest := ViewInfo.GetHitTest(X, Y);
Result := IsClickableRecordHitTest(AHitTest);
end;
end;
procedure TcxCustomGridTableController.DragDrop(Source: TObject; X, Y: Integer);
begin
if GridView.OptionsBehavior.DragFocusing = dfDragDrop then
ProcessDragFocusing(X, Y);
inherited;
end;
procedure TcxCustomGridTableController.DragOver(Source: TObject; X, Y: Integer;
State: TDragState; var Accept: Boolean);
procedure ProcessScrolling;
var
ADirection: TcxDirection;
begin
ADirection := GetDragScrollDirection(X, Y);
if (ADirection = dirNone) or (State = dsDragLeave) then
StopDragScroll
else
StartDragScroll(ADirection);
end;
procedure ProcessOpening;
var
AHitTest: TcxCustomGridHitTest;
ADragOpenInfo: TcxCustomGridDragOpenInfo;
begin
AHitTest := ViewInfo.GetHitTest(X, Y);
if (State <> dsDragLeave) and IsDragOpenHitTest(AHitTest, ADragOpenInfo) then
TcxCustomGrid(Control).Controller.StartDragOpen(ADragOpenInfo)
else
TcxCustomGrid(Control).Controller.StopDragOpen;
end;
procedure ProcessDragHighlighting;
var
AHitTest: TcxCustomGridHitTest;
begin
AHitTest := ViewInfo.GetHitTest(X, Y);
if (State <> dsDragLeave) and (AHitTest is TcxGridRecordHitTest) then
DragHighlightedRecord := TcxGridRecordHitTest(AHitTest).GridRecord
else
DragHighlightedRecord := nil;
end;
begin
inherited;
if GridView.OptionsBehavior.DragScrolling then
ProcessScrolling;
if GridView.OptionsBehavior.DragOpening then
ProcessOpening;
if GridView.OptionsBehavior.DragHighlighting then
ProcessDragHighlighting;
if (State <> dsDragLeave) and (GridView.OptionsBehavior.DragFocusing = dfDragOver) then
ProcessDragFocusing(X, Y);
end;
procedure TcxCustomGridTableController.DrawDragImage(ACanvas: TcxCanvas; R: TRect);
var
AParams: TcxViewParams;
procedure DrawBorder(R: TRect);
var
I: Integer;
begin
for I := 1 to DragDropTextBorderSize do
begin
ACanvas.DrawFocusRect(R);
InflateRect(R, -1, -1);
end;
end;
procedure DrawText(const R: TRect);
begin
with ACanvas do
begin
Font := AParams.Font;
Font.Color := AParams.TextColor;
Brush.Style := bsClear;
DrawText(FDragDropText, R, 0);
Brush.Style := bsSolid;
end;
end;
begin
if FDragDropText = '' then Exit;
GetDragDropTextViewParams(AParams);
with ACanvas do
begin
Brush.Color := AParams.Color;
FillRect(R);
end;
Inc(R.Left, DragDropTextAreaOffset);
DrawBorder(R);
InflateRect(R, -DragDropTextIndent, -DragDropTextIndent);
DrawText(R);
end;
procedure TcxCustomGridTableController.EndDrag(Target: TObject; X, Y: Integer);
begin
DragHighlightedRecord := nil;
TcxCustomGrid(Control).Controller.StopDragOpen;
StopDragScroll;
inherited;
end;
function TcxCustomGridTableController.GetDragDropText(ADragObject: TDragObject): string;
begin
if GridView.OptionsBehavior.DragDropText then
Result := GridView.DoGetDragDropText(FocusedRecord, FocusedItem)
else
Result := '';
end;
procedure TcxCustomGridTableController.GetDragDropTextViewParams(out AParams: TcxViewParams);
begin
GridView.Styles.GetContentParams(nil, nil, AParams);
end;
function TcxCustomGridTableController.GetDragImagesSize: TPoint;
var
AParams: TcxViewParams;
ACanvas: TcxCanvas;
begin
if FDragDropText = '' then
Result := Point(0, 0)
else
begin
GetDragDropTextViewParams(AParams);
ACanvas := ViewInfo.Canvas;
ACanvas.Font := AParams.Font;
Result := Point(
DragDropTextAreaOffset + DragDropTextIndent + ACanvas.TextWidth(FDragDropText) + DragDropTextIndent,
DragDropTextIndent + ACanvas.TextHeight(FDragDropText) + DragDropTextIndent);
end;
end;
function TcxCustomGridTableController.HasDragImages: Boolean;
begin
Result := True;
end;
procedure TcxCustomGridTableController.StartDrag(var DragObject: TDragObject);
function GetCursor: TCursor;
begin
if SelectedRecordCount > 1 then
Result := crcxGridMultiDrag
else
Result := crcxGridDrag;
end;
begin
inherited;
TControlAccess(Site).DragCursor := GetCursor;
FDragDropText := GetDragDropText(DragObject);
end;
procedure TcxCustomGridTableController.CancelIncSearching;
begin
DataController.Search.Cancel;
end;
function TcxCustomGridTableController.CheckEditing(var AFocusedRecordIndex: Integer;
AGoForward: Boolean): Boolean;
var
AGridViewLink: TcxGridListenerLink;
begin
Result := False;
//AGridView.BeginUpdate; - commented because of dialog calling in OnBeforePost
AGridViewLink := GridView.AddListenerLink;
try
try
if DataController.IsEditing then
begin
EditingController.UpdateValue;
if not (dceModified in DataController.EditState) then
begin
if DataController.EditState = [dceInsert] then
begin
Result := AGoForward xor DataController.IsEOF;
if Result then DataController.Cancel;
end;
Exit;
end;
DataController.Post;
if AGridViewLink.GridView = nil then Exit;
if AFocusedRecordIndex <> -1 then
AFocusedRecordIndex := FocusedRecordIndex;
end;
finally
if AGridViewLink.GridView = nil then
Result := True
else
begin
//AGridView.EndUpdate;
end;
end;
finally
AGridViewLink.Free;
end;
end;
procedure TcxCustomGridTableController.CheckScrolling(const P: TPoint);
begin
end;
procedure TcxCustomGridTableController.ClearSelection;
begin
DataController.ClearSelection;
end;
procedure TcxCustomGridTableController.CreateNewRecord(AtEnd: Boolean);
var
AIsEditing: Boolean;
begin
GridView.Focused := True;
AIsEditing := IsEditing;
if AtEnd then
if CanAppend(False) then
DataController.Append
else
else
if CanInsert(False) then
begin
DataController.Insert;
if MultiSelect and (ViewData.EditingRecord <> nil) then
ViewData.EditingRecord.Selected := True;
end;
if (dceInsert in DataController.EditState) and
GridView.OptionsBehavior.FocusFirstCellOnNewRecord then
begin
FocusFirstAvailableItem;
if AIsEditing then
FEditingController.ShowEdit;
end;
end;
procedure TcxCustomGridTableController.DeleteSelection;
var
AMultiSelect: Boolean;
function GetConfirmationText: string;
begin
if AMultiSelect then
Result := cxGetResourceString(@scxGridDeletingSelectedConfirmationText)
else
Result := cxGetResourceString(@scxGridDeletingFocusedConfirmationText);
end;
begin
if not CanDelete(False) then Exit;
AMultiSelect := MultiSelect and (SelectedRecordCount <> 0) and
((SelectedRecordCount > 1) or (SelectedRecords[0] = nil) or
(FocusedRecordIndex <> SelectedRecords[0].Index));
if not GridView.OptionsData.DeletingConfirmation or
(cxMessageDlg(GetConfirmationText,
cxGetResourceString(@scxGridDeletingConfirmationCaption),
mtConfirmation, [mbOK, mbCancel], 0) = mrOk)
then
if AMultiSelect then
DataController.DeleteSelection
else
DataController.DeleteFocused;
end;
function TcxCustomGridTableController.FocusFirstAvailableItem: Boolean;
begin
Result := FocusNextItem(-1, True, False, False);
end;
function TcxCustomGridTableController.FocusNextCell(AGoForward: Boolean;
AProcessCellsOnly: Boolean = True; AAllowCellsCycle: Boolean = True): Boolean;
begin
if FocusedRecordHasCells(True) then
Result := FocusNextItem(FocusedItemIndex, AGoForward, False,
AAllowCellsCycle and GridView.OptionsBehavior.FocusCellOnCycle)
else
if AProcessCellsOnly or not GridView.OptionsBehavior.FocusCellOnCycle then
Result := False
else
begin
Result := FocusNextRecord(FocusedRecordIndex, AGoForward, False, False, False);
if FocusedRecordHasCells(True) then
FocusNextItem(-1, AGoForward, True, False);
end;
end;
function TcxCustomGridTableController.FocusNextItem(AFocusedItemIndex: Integer;
AGoForward, AGoOnCycle, AGoToNextRecordOnCycle: Boolean): Boolean;
var
ANextItemIndex: Integer;
ACycleChanged: Boolean;
begin
ANextItemIndex := FindNextItem(AFocusedItemIndex, AGoForward,
AGoOnCycle or AGoToNextRecordOnCycle, ACycleChanged, FocusedRecord);
Result := CanFocusNextItem(AFocusedItemIndex, ANextItemIndex, AGoForward,
AGoOnCycle, AGoToNextRecordOnCycle);
if Result then
begin
if ACycleChanged and AGoToNextRecordOnCycle then
if FocusedRecord.IsNewItemRecord then
begin
DataController.Post;
if ViewData.NewItemRecord <> nil then
ViewData.NewItemRecord.Focused := True;
Result := True;
end
else
Result := FocusNextRecord(FocusedRecordIndex, AGoForward, False, False, False){ and
FocusedRecordHasCells(True)}
else
Result := True;
if Result then
GridView.VisibleItems[ANextItemIndex].Focused := True;
end;
end;
function TcxCustomGridTableController.FocusNextRecord(AFocusedRecordIndex: Integer;
AGoForward, AGoOnCycle, AGoIntoDetail, AGoOutOfDetail: Boolean): Boolean;
var
AGridViewLink: TcxGridListenerLink;
APrevFocused, ACycleChanged: Boolean;
APrevFocusedRecord, ANextRecord, AChildRecord: TcxCustomGridRecord;
ANextRecordIndex: Integer;
procedure CheckGridMode;
begin
if DataController.IsGridMode and (AFocusedRecordIndex = -1) then
if AGoForward then
DataController.GotoFirst
else
if AGoOnCycle then
DataController.GotoLast;
end;
procedure ProcessMultiSelect;
var
AFocusedView: TcxCustomGridView;
begin
if GridView.Focused = APrevFocused then Exit;
CheckFocusedRecordSelectionWhenExit(APrevFocusedRecord);
AFocusedView := TcxCustomGrid(Control).FocusedView;
if AFocusedView is TcxCustomGridTableView then
TcxCustomGridTableView(AFocusedView).Controller.SelectFocusedRecord;
end;
begin
Result := CheckEditing(AFocusedRecordIndex, AGoForward);
if Result then Exit;
AGridViewLink := GridView.AddListenerLink;
try
CheckGridMode;
APrevFocused := GridView.Focused;
APrevFocusedRecord := FocusedRecord;
try
if AGoForward and AGoIntoDetail and GridView.IsMaster and
(AFocusedRecordIndex <> -1) then
ANextRecord := ViewData.Records[AFocusedRecordIndex].GetFirstFocusableChild
else
ANextRecord := nil;
if ANextRecord = nil then
begin
ANextRecordIndex := FindNextRecord(AFocusedRecordIndex, AGoForward,
AGoOnCycle, ACycleChanged);
if ANextRecordIndex <> -1 then
begin
ANextRecord := ViewData.Records[ANextRecordIndex];
if not AGoForward and AGoIntoDetail and GridView.IsMaster then
begin
AChildRecord := ANextRecord.GetLastFocusableChild(True);
if AChildRecord <> nil then
ANextRecord := AChildRecord;
end;
end
else
if AGoForward and CanAppend(True) and (DataController.EditState <> [dceInsert]) then
begin
CreateNewRecord(True);
Result := True;
Exit;
end
else
if GridView.IsDetail and AGoOutOfDetail then
if not AGoForward and GridView.MasterGridRecord.CanFocus then
ANextRecord := GridView.MasterGridRecord
else
begin
Result := not DataController.IsGridMode and
MasterController.FocusNextRecord(GridView.MasterGridRecordIndex,
AGoForward, AGoOnCycle, not AGoForward, True);
Exit;
end;
end;
Result := ANextRecord <> nil;
if Result then
ANextRecord.Focused := True;
finally
if (AGridViewLink.GridView <> nil) and Result then
begin
ProcessMultiSelect;
//Site.Update;
end;
end;
finally
AGridViewLink.Free;
end;
end;
function TcxCustomGridTableController.FocusNextRecordWithSelection(AFocusedRecordIndex: Integer;
AGoForward, AGoOnCycle, AGoIntoDetail: Boolean; ASyncSelection: Boolean = True): Boolean;
begin
Result := FocusNextRecord(AFocusedRecordIndex, AGoForward, AGoOnCycle,
AGoIntoDetail, AGoIntoDetail);
if Result and ASyncSelection then
SelectFocusedRecord;
end;
function TcxCustomGridTableController.FocusRecord(AFocusedRecordIndex: Integer;
ASyncSelection: Boolean): Boolean;
begin
FocusedRecordIndex := AFocusedRecordIndex;
Result := FocusedRecordIndex = AFocusedRecordIndex;
if Result and ASyncSelection then
SelectFocusedRecord;
end;
procedure TcxCustomGridTableController.MakeFocusedItemVisible;
begin
MakeItemVisible(FocusedItem);
end;
procedure TcxCustomGridTableController.MakeFocusedRecordVisible;
begin
if not IsFocusing then
MakeRecordVisible(FocusedRecord);
end;
procedure TcxCustomGridTableController.MakeRecordVisible(ARecord: TcxCustomGridRecord);
var
AFocusedView: TcxCustomGridView;
AIndex, APrevTopRecordIndex: Integer;
begin
if (ARecord = nil) or (GridView.Control = nil) then Exit;
AFocusedView := TcxCustomGrid(GridView.Control).FocusedView;
if (AFocusedView is TcxCustomGridTableView) and
not GridView.Focused and AFocusedView.HasAsMaster(GridView) and
TcxCustomGridTableView(AFocusedView).DontMakeMasterRecordVisible then Exit;
AIndex := ARecord.Index;
if AIndex <> -1 then
begin
if AIndex < TopRecordIndex then InternalTopRecordIndex := AIndex;
if ViewInfo.VisibleRecordCount = 0 then
if AIndex > TopRecordIndex then
InternalTopRecordIndex := AIndex
else
else
begin
Site.LockScrollBars;
try
while AIndex >= TopRecordIndex + ViewInfo.VisibleRecordCount do
begin
APrevTopRecordIndex := TopRecordIndex;
InternalTopRecordIndex := AIndex - GetVisibleRecordCount(AIndex, False) + 1;
if TopRecordIndex = APrevTopRecordIndex then Break;
end;
finally
Site.UnlockScrollBars;
end;
end;
end;
GridView.MakeMasterGridRecordVisible;
end;
procedure TcxCustomGridTableController.SelectAll;
begin
SelectAllRecords;
end;
procedure TcxCustomGridTableController.SelectAllRecords;
begin
DataController.SelectAll;
end;
function TcxCustomGridTableController.GoToFirst(ASyncSelection: Boolean = True): Boolean;
begin
Result := FocusNextRecordWithSelection(-1, True, False, False, ASyncSelection);
end;
function TcxCustomGridTableController.GoToLast(AGoIntoDetail: Boolean;
ASyncSelection: Boolean = True): Boolean;
begin
Result := FocusNextRecordWithSelection(-1, False, True, AGoIntoDetail, ASyncSelection);
end;
function TcxCustomGridTableController.GoToNext(AGoIntoDetail: Boolean;
ASyncSelection: Boolean = True): Boolean;
begin
Result := FocusNextRecordWithSelection(FocusedRecordIndex, True, False,
AGoIntoDetail, ASyncSelection);
end;
function TcxCustomGridTableController.GoToPrev(AGoIntoDetail: Boolean;
ASyncSelection: Boolean = True): Boolean;
begin
Result := FocusNextRecordWithSelection(FocusedRecordIndex, False, False,
AGoIntoDetail, ASyncSelection);
end;
function TcxCustomGridTableController.IsFinish: Boolean;
var
ACycleChanged: Boolean;
begin
if DataController.IsGridMode then
Result := DataController.IsEOF
else
Result := FindNextRecord(FocusedRecordIndex, True, False, ACycleChanged) = -1;
end;
function TcxCustomGridTableController.IsStart: Boolean;
var
ACycleChanged: Boolean;
begin
if DataController.IsGridMode then
Result := DataController.IsBOF
else
Result := FindNextRecord(FocusedRecordIndex, False, False, ACycleChanged) = -1;
end;
{ TcxCustomGridFilterButtonPainter }
function TcxCustomGridFilterButtonPainter.GetViewInfo: TcxCustomGridFilterButtonViewInfo;
begin
Result := TcxCustomGridFilterButtonViewInfo(inherited ViewInfo);
end;
function TcxCustomGridFilterButtonPainter.ExcludeFromClipRect: Boolean;
begin
Result := True;
end;
{ TcxGridFilterCloseButtonPainter }
procedure TcxGridFilterCloseButtonPainter.DrawContent;
begin
ViewInfo.LookAndFeelPainter.DrawFilterCloseButton(Canvas, ViewInfo.Bounds,
ViewInfo.ButtonState);
end;
{ TcxGridFilterActivateButtonPainter }
function TcxGridFilterActivateButtonPainter.GetViewInfo: TcxGridFilterActivateButtonViewInfo;
begin
Result := TcxGridFilterActivateButtonViewInfo(inherited ViewInfo);
end;
procedure TcxGridFilterActivateButtonPainter.DrawContent;
begin
ViewInfo.LookAndFeelPainter.DrawFilterActivateButton(Canvas, ViewInfo.Bounds,
ViewInfo.ButtonState, ViewInfo.Checked);
end;
{ TcxGridFilterDropDownButtonPainter }
procedure TcxGridFilterDropDownButtonPainter.DrawContent;
begin
ViewInfo.LookAndFeelPainter.DrawFilterDropDownButton(Canvas, ViewInfo.Bounds,
ViewInfo.ButtonState, False);
end;
{ TcxGridFilterCustomizeButtonPainter }
procedure TcxGridFilterCustomizeButtonPainter.Paint;
begin
Canvas.Font := ViewInfo.Params.Font;
ViewInfo.LookAndFeelPainter.DrawButton(Canvas, ViewInfo.Bounds, ViewInfo.Text,
ViewInfo.ButtonState);
end;
{ TcxGridFilterPainter }
function TcxGridFilterPainter.GetViewInfo: TcxGridFilterViewInfo;
begin
Result := TcxGridFilterViewInfo(inherited ViewInfo);
end;
procedure TcxGridFilterPainter.DrawBackground(const R: TRect);
begin
with ViewInfo do
LookAndFeelPainter.DrawFilterPanel(Canvas, R, Transparent, Params.Color,
BackgroundBitmap);
end;
procedure TcxGridFilterPainter.DrawButtons;
var
I: Integer;
begin
with ViewInfo.ButtonsViewInfo do
for I := 0 to Count - 1 do
Items[I].Paint;
end;
function TcxGridFilterPainter.ExcludeFromClipRect: Boolean;
begin
Result := True;
end;
procedure TcxGridFilterPainter.Paint;
begin
// DrawButtons; - commented because of XP
inherited;
DrawButtons;
end;
procedure TcxGridFilterPainter.PrepareCanvasForDrawText;
begin
inherited;
FTextWasUnderlined := False;
if ViewInfo.State in [gcsSelected, gcsPressed] then
with Canvas.Font do
if not (fsUnderline in Style) then
begin
Style := Style + [fsUnderline];
FTextWasUnderlined := True;
end;
end;
procedure TcxGridFilterPainter.UnprepareCanvasForDrawText;
begin
if FTextWasUnderlined then
with Canvas.Font do
Style := Style - [fsUnderline];
inherited;
end;
{ TcxGridTableDataCellPainter }
function TcxGridTableDataCellPainter.GetViewInfo: TcxGridTableDataCellViewInfo;
begin
Result := TcxGridTableDataCellViewInfo(inherited ViewInfo);
end;
procedure TcxGridTableDataCellPainter.DrawContent;
begin
if ViewInfo.Transparent and (ViewInfo.BackgroundBitmap <> nil) then
DrawBackground;
ViewInfo.EditViewInfo.Paint(Canvas);
end;
procedure TcxGridTableDataCellPainter.DrawFocusRect;
begin
with ViewInfo do
if Focused and HasFocusRect then
GridViewInfo.Painter.DrawFocusRect(ContentBounds, GridView.OptionsSelection.HideFocusRectOnExit);
end;
procedure TcxGridTableDataCellPainter.Paint;
begin
inherited;
DrawFocusRect;
end;
{ TcxCustomGridRecordPainter }
function TcxCustomGridRecordPainter.GetViewInfo: TcxCustomGridRecordViewInfo;
begin
Result := TcxCustomGridRecordViewInfo(inherited ViewInfo);
end;
procedure TcxCustomGridRecordPainter.AfterPaint;
begin
DrawFocusRect;
if ViewInfo.GridRecord.Expandable and not DrawExpandButtonBeforePaint then
DrawExpandButton;
ViewInfo.GridViewInfo.Painter.ExcludeFromBackground(ViewInfo.Bounds);
inherited;
end;
procedure TcxCustomGridRecordPainter.BeforePaint;
begin
inherited;
if ViewInfo.GridRecord.Expandable and DrawExpandButtonBeforePaint then
DrawExpandButton;
DrawBackground;
end;
procedure TcxCustomGridRecordPainter.DrawBackground;
begin
if ViewInfo.Transparent then
DrawBackground(ViewInfo.BackgroundBitmapBounds);
end;
procedure TcxCustomGridRecordPainter.DrawExpandButton;
var
AClipRegion: TcxRegion;
begin
AClipRegion := Canvas.GetClipRegion;
try
ViewInfo.GridViewInfo.LookAndFeelPainter.DrawExpandButton(Canvas,
ViewInfo.ExpandButtonBounds, ViewInfo.Expanded);
finally
Canvas.SetClipRegion(AClipRegion, roSet); // for speed
end;
end;
function TcxCustomGridRecordPainter.DrawExpandButtonBeforePaint: Boolean;
begin
Result := False; // ViewInfo.GridViewInfo.LookAndFeelPainter.DrawExpandButtonFirst; - for speed
end;
procedure TcxCustomGridRecordPainter.DrawFocusRect;
begin
with ViewInfo do
if Focused and HasFocusRect then
GridViewInfo.Painter.DrawFocusRect(FocusRectBounds, HideFocusRectOnExit);
end;
procedure TcxCustomGridRecordPainter.Paint;
begin
end;
{ TcxCustomGridRecordsPainter }
constructor TcxCustomGridRecordsPainter.Create(ACanvas: TcxCanvas;
AViewInfo: TcxCustomGridRecordsViewInfo);
begin
inherited Create;
FCanvas := ACanvas;
FViewInfo := AViewInfo;
end;
(*procedure TcxCustomGridRecordsPainter.BeforePaint;
begin {4}
with ViewInfo do //!!! cache bitmaps!
BackgroundBitmap := GetBackgroundBitmap;
end;*)
procedure TcxCustomGridRecordsPainter.Paint;
var
I: Integer;
begin
with FViewInfo do
for I := 0 to Count - 1 do
with Items[I] do
if Calculated then Paint;
end;
procedure TcxCustomGridRecordsPainter.MainPaint;
begin
//BeforePaint;
Paint;
end;
{ TcxNavigatorSitePainter }
function TcxNavigatorSitePainter.ExcludeFromClipRect: Boolean;
begin
Result := True;
end;
{ TcxCustomGridTablePainter }
function TcxCustomGridTablePainter.GetController: TcxCustomGridTableController;
begin
Result := TcxCustomGridTableController(inherited Controller);
end;
function TcxCustomGridTablePainter.GetViewInfo: TcxCustomGridTableViewInfo;
begin
Result := TcxCustomGridTableViewInfo(inherited ViewInfo);
end;
function TcxCustomGridTablePainter.CanOffset(AItemsOffset, DX, DY: Integer): Boolean;
begin
Result := not GridView.IsDesigning and // because of the DesignSelector
(ViewInfo.BackgroundBitmap = nil) and (ViewInfo.RecordsViewInfo.BackgroundBitmap = nil) and
not ViewInfo.NoDataInfoTextAreaVisible;
end;
procedure TcxCustomGridTablePainter.DrawBackground;
begin
inherited;
if ViewInfo.NoDataInfoTextAreaVisible then
DrawInfoText;
end;
procedure TcxCustomGridTablePainter.DrawFilterBar;
begin
ViewInfo.FilterViewInfo.Paint;
end;
procedure TcxCustomGridTablePainter.DrawInfoText;
var
AParams: TcxViewParams;
begin
ViewInfo.GetNoDataInfoTextParams(AParams);
with Canvas do
begin
SetParams(AParams);
Brush.Style := bsClear;
DrawText(ViewInfo.NoDataInfoText, ViewInfo.NoDataInfoTextAreaBounds,
cxAlignCenter or cxWordBreak, True);
Brush.Style := bsSolid;
end;
end;
procedure TcxCustomGridTablePainter.DrawNavigator;
begin
with ViewInfo do
if NavigatorSiteViewInfo.Visible then
begin
NavigatorViewInfo.Paint;
NavigatorSiteViewInfo.Paint;
end;
end;
procedure TcxCustomGridTablePainter.DrawRecords;
begin
ViewInfo.RecordsViewInfo.Paint;
end;
procedure TcxCustomGridTablePainter.Offset(AItemsOffset: Integer);
begin
GridView.ViewChanged;
end;
procedure TcxCustomGridTablePainter.Offset(DX, DY: Integer);
begin
GridView.ViewChanged;
end;
procedure TcxCustomGridTablePainter.PaintBefore;
begin
inherited;
DrawNavigator;
end;
procedure TcxCustomGridTablePainter.PaintContent;
begin
inherited;
DrawRecords;
end;
procedure TcxCustomGridTablePainter.DoOffset(AItemsOffset, DX, DY: Integer);
begin
if not Site.HandleAllocated then Exit;
if CanOffset(AItemsOffset, DX, DY) then
begin
Controller.BeforePaint;
try
if AItemsOffset = 0 then
Offset(DX, DY)
else
Offset(AItemsOffset);
finally
Controller.AfterPaint;
end;
end
else
GridView.ViewChanged;
end;
procedure TcxCustomGridTablePainter.DrawFocusRect(const R: TRect; AHideFocusRect: Boolean);
begin
if ViewInfo.GridView.OptionsView.FocusRect then inherited;
end;
{ TcxCustomGridPartViewInfo }
constructor TcxCustomGridPartViewInfo.Create(AGridViewInfo: TcxCustomGridTableViewInfo);
begin
inherited Create(AGridViewInfo);
if IsPart then
GridViewInfo.AddPart(Self);
end;
destructor TcxCustomGridPartViewInfo.Destroy;
begin
if IsPart then
GridViewInfo.RemovePart(Self);
inherited;
end;
function TcxCustomGridPartViewInfo.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
function TcxCustomGridPartViewInfo.GetGridViewInfo: TcxCustomGridTableViewInfo;
begin
Result := TcxCustomGridTableViewInfo(inherited GridViewInfo);
end;
function TcxCustomGridPartViewInfo.GetIndex: Integer;
begin
Result := GridViewInfo.FParts.IndexOf(Self);
end;
procedure TcxCustomGridPartViewInfo.SetIndex(Value: Integer);
begin
if Index <> Value then
GridViewInfo.FParts.Move(Index, Value);
end;
function TcxCustomGridPartViewInfo.CalculateBounds: TRect;
begin
Result := GridViewInfo.CalculatePartBounds(Self);
end;
procedure TcxCustomGridPartViewInfo.CalculateInvisible;
begin
FHeight := 0;
inherited Calculate(0, 0, 0, 0);
end;
procedure TcxCustomGridPartViewInfo.CalculateVisible;
begin
FHeight := CalculateHeight;
with CalculateBounds do
Calculate(Left, Top, Right - Left, Bottom - Top);
end;
function TcxCustomGridPartViewInfo.CustomDrawBackground(ACanvas: TcxCanvas): Boolean;
begin
Result := inherited CustomDrawBackground(ACanvas);
if not Result then
GridView.DoCustomDrawPartBackground(ACanvas, Self, Result);
end;
{function TcxCustomGridPartViewInfo.GetHeight: Integer;
begin
Result := inherited GetHeight;
if Result = 0 then Result := FHeight;
end;}
function TcxCustomGridPartViewInfo.GetIsPart: Boolean;
begin
Result := True;
end;
function TcxCustomGridPartViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
begin
Result := TcxCustomGridPartPainter;
end;
function TcxCustomGridPartViewInfo.HasCustomDrawBackground: Boolean;
begin
Result := GridView.HasCustomDrawPartBackground;
end;
procedure TcxCustomGridPartViewInfo.InitHitTest(AHitTest: TcxCustomGridHitTest);
begin
inherited;
GridViewInfo.InitHitTest(AHitTest);
end;
procedure TcxCustomGridPartViewInfo.MainCalculate;
begin
if Visible then
CalculateVisible
else
CalculateInvisible;
end;
{ TcxCustomGridFilterButtonViewInfo }
constructor TcxCustomGridFilterButtonViewInfo.Create(AContainer: TcxGridFilterButtonsViewInfo);
begin
inherited Create(AContainer.FilterViewInfo.GridViewInfo);
FContainer := AContainer;
end;
function TcxCustomGridFilterButtonViewInfo.GetFilter: TcxDataFilterCriteria;
begin
Result := FContainer.FilterViewInfo.Filter;
end;
function TcxCustomGridFilterButtonViewInfo.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
function TcxCustomGridFilterButtonViewInfo.CaptureMouseOnPress: Boolean;
begin
Result := True;
end;
function TcxCustomGridFilterButtonViewInfo.GetAlignment: TcxGridFilterButtonAlignment;
begin
Result := fbaLeft;
end;
function TcxCustomGridFilterButtonViewInfo.GetCanvas: TcxCanvas;
begin
Result := FContainer.FilterViewInfo.Canvas;
end;
function TcxCustomGridFilterButtonViewInfo.GetHotTrack: Boolean;
begin
Result := True;
end;
function TcxCustomGridFilterButtonViewInfo.GetVisible: Boolean;
begin
Result := not Filter.IsEmpty;
end;
{ TcxGridFilterCloseButtonViewInfo }
function TcxGridFilterCloseButtonViewInfo.CalculateHeight: Integer;
begin
Result := LookAndFeelPainter.FilterCloseButtonSize.Y;
end;
function TcxGridFilterCloseButtonViewInfo.CalculateWidth: Integer;
begin
Result := LookAndFeelPainter.FilterCloseButtonSize.X;
end;
procedure TcxGridFilterCloseButtonViewInfo.Click;
begin
inherited;
Filter.Clear;
end;
function TcxGridFilterCloseButtonViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
begin
Result := TcxGridFilterCloseButtonHitTest;
end;
function TcxGridFilterCloseButtonViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
begin
Result := TcxGridFilterCloseButtonPainter;
end;
{ TcxGridFilterActivateButtonViewInfo }
function TcxGridFilterActivateButtonViewInfo.GetChecked: Boolean;
begin
Result := Filter.Active;
end;
function TcxGridFilterActivateButtonViewInfo.CalculateHeight: Integer;
begin
Result := LookAndFeelPainter.FilterActivateButtonSize.Y;
end;
function TcxGridFilterActivateButtonViewInfo.CalculateWidth: Integer;
begin
Result := LookAndFeelPainter.FilterActivateButtonSize.X;
end;
procedure TcxGridFilterActivateButtonViewInfo.Click;
begin
inherited;
with Filter do
Active := not Active;
end;
function TcxGridFilterActivateButtonViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
begin
Result := TcxGridFilterActivateButtonHitTest;
end;
function TcxGridFilterActivateButtonViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
begin
Result := TcxGridFilterActivateButtonPainter;
end;
{ TcxGridFilterDropDownButtonViewInfo }
function TcxGridFilterDropDownButtonViewInfo.GetDropDownWindowValue: TcxGridFilterMRUItemsPopup;
begin
Result := TcxGridFilterMRUItemsPopup(inherited DropDownWindow);
end;
procedure TcxGridFilterDropDownButtonViewInfo.BeforeStateChange;
begin
inherited;
if State = gcsPressed then
Container.FilterViewInfo.State := gcsNone;
end;
function TcxGridFilterDropDownButtonViewInfo.CalculateHeight: Integer;
begin
Result := LookAndFeelPainter.FilterCloseButtonSize.Y;
end;
function TcxGridFilterDropDownButtonViewInfo.CalculateWidth: Integer;
begin
Result := LookAndFeelPainter.FilterCloseButtonSize.X;
end;
function TcxGridFilterDropDownButtonViewInfo.CaptureMouseOnPress: Boolean;
begin
Result := False;
end;
function TcxGridFilterDropDownButtonViewInfo.GetAlignment: TcxGridFilterButtonAlignment;
begin
Result := fbaRight;
end;
function TcxGridFilterDropDownButtonViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
begin
Result := TcxGridFilterDropDownButtonHitTest;
end;
function TcxGridFilterDropDownButtonViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
begin
Result := TcxGridFilterDropDownButtonPainter;
end;
function TcxGridFilterDropDownButtonViewInfo.GetVisible: Boolean;
begin
Result := GridView.Filtering.IsMRUItemsListAvailable;
end;
function TcxGridFilterDropDownButtonViewInfo.DropDownWindowExists: Boolean;
begin
Result := GridView.Controller.HasFilterMRUItemsPopup;
end;
function TcxGridFilterDropDownButtonViewInfo.GetDropDownWindow: TcxCustomGridPopup;
begin
Result := GridView.Controller.FilterMRUItemsPopup;
end;
function TcxGridFilterDropDownButtonViewInfo.GetDropDownWindowOwnerBounds: TRect;
begin
Result := Bounds;
Result.Left := Container.FilterViewInfo.TextAreaBounds.Left -
(DropDownWindow.BorderWidths[bLeft] + DropDownWindow.TextOffsetHorz);
end;
procedure TcxGridFilterDropDownButtonViewInfo.Calculate(ALeftBound, ATopBound: Integer;
AWidth: Integer = -1; AHeight: Integer = -1);
begin
ALeftBound := Min(ALeftBound, Container.FilterViewInfo.TextBounds.Right +
cxGridCellTextOffset + FilterTextOffset + FilterButtonsOffset);
inherited;
end;
{ TcxGridFilterCustomizeButtonViewInfo }
function TcxGridFilterCustomizeButtonViewInfo.CalculateHeight: Integer;
begin
Result := BorderWidth[bTop] + BorderWidth[bBottom] + TextHeightWithOffset +
2 * LookAndFeelPainter.ButtonTextOffset;
end;
function TcxGridFilterCustomizeButtonViewInfo.CalculateWidth: Integer;
begin
Result := BorderWidth[bLeft] + BorderWidth[bRight] + TextWidthWithOffset +
2 * LookAndFeelPainter.ButtonTextOffset;
end;
procedure TcxGridFilterCustomizeButtonViewInfo.Click;
begin
inherited;
GridView.Filtering.RunCustomizeDialog;
end;
function TcxGridFilterCustomizeButtonViewInfo.GetAlignment: TcxGridFilterButtonAlignment;
begin
Result := fbaRight;
end;
function TcxGridFilterCustomizeButtonViewInfo.GetAlignmentHorz: TAlignment;
begin
Result := taCenter;
end;
function TcxGridFilterCustomizeButtonViewInfo.GetAlignmentVert: TcxAlignmentVert;
begin
Result := vaCenter;
end;
function TcxGridFilterCustomizeButtonViewInfo.GetBorders: TcxBorders;
begin
Result := [bLeft, bTop, bRight, bBottom];
end;
function TcxGridFilterCustomizeButtonViewInfo.GetBorderWidth(AIndex: TcxBorder): Integer;
begin
Result := LookAndFeelPainter.ButtonBorderSize;
end;
function TcxGridFilterCustomizeButtonViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
begin
Result := TcxGridFilterCustomizeButtonHitTest;
end;
function TcxGridFilterCustomizeButtonViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
begin
Result := TcxGridFilterCustomizeButtonPainter;
end;
function TcxGridFilterCustomizeButtonViewInfo.GetText: string;
begin
Result := cxGetResourceString(@scxGridFilterCustomizeButtonCaption);
end;
procedure TcxGridFilterCustomizeButtonViewInfo.GetViewParams(var AParams: TcxViewParams);
begin
AParams.Font := Container.FilterViewInfo.Params.Font;
end;
function TcxGridFilterCustomizeButtonViewInfo.GetVisible: Boolean;
begin
Result := GridView.FilterBox.CustomizeDialog;
end;
{ TcxGridFilterButtonsViewInfo }
constructor TcxGridFilterButtonsViewInfo.Create(AFilterViewInfo: TcxGridFilterViewInfo);
begin
inherited Create;
FFilterViewInfo := AFilterViewInfo;
FItems := TList.Create;
AddItems;
end;
destructor TcxGridFilterButtonsViewInfo.Destroy;
begin
DestroyItems;
FItems.Free;
inherited;
end;
function TcxGridFilterButtonsViewInfo.GetCount: Integer;
begin
Result := FItems.Count;
end;
function TcxGridFilterButtonsViewInfo.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(FFilterViewInfo.GridView);
end;
function TcxGridFilterButtonsViewInfo.GetHeight: Integer;
var
I, AItemHeight: Integer;
begin
Result := 0;
for I := 0 to Count - 1 do
if Items[I].Visible then
begin
AItemHeight := Items[I].CalculateHeight;
if Result < AItemHeight then Result := AItemHeight;
end;
if Result <> 0 then Inc(Result, 2 * FilterButtonsFirstOffset);
end;
function TcxGridFilterButtonsViewInfo.GetItem(Index: Integer): TcxCustomGridFilterButtonViewInfo;
begin
Result := TcxCustomGridFilterButtonViewInfo(FItems[Index]);
end;
function TcxGridFilterButtonsViewInfo.GetWidth(AAlignment: TcxGridFilterButtonAlignment): Integer;
var
I: Integer;
begin
Result := 0;
for I := 0 to Count - 1 do
with Items[I] do
if Visible and (Alignment = AAlignment) then
Inc(Result, CalculateWidth + FilterButtonsOffset);
if Result <> 0 then
Inc(Result, 2 * FilterButtonsFirstOffset - FilterButtonsOffset);
end;
function TcxGridFilterButtonsViewInfo.GetWidthLeftPart: Integer;
begin
Result := GetWidth(fbaLeft);
end;
function TcxGridFilterButtonsViewInfo.GetWidthRightPart: Integer;
begin
Result := GetWidth(fbaRight);
end;
procedure TcxGridFilterButtonsViewInfo.AddItems;
begin
AddItem(TcxGridFilterCloseButtonViewInfo);
AddItem(TcxGridFilterActivateButtonViewInfo);
AddItem(TcxGridFilterCustomizeButtonViewInfo);
FDropDownButtonViewInfo := AddItem(TcxGridFilterDropDownButtonViewInfo) as TcxGridFilterDropDownButtonViewInfo;
end;
procedure TcxGridFilterButtonsViewInfo.DestroyItems;
var
I: Integer;
begin
for I := 0 to Count - 1 do Items[I].Free;
FItems.Clear;
FDropDownButtonViewInfo := nil;
end;
function TcxGridFilterButtonsViewInfo.AddItem(AItemClass: TcxCustomGridFilterButtonViewInfoClass): TcxCustomGridFilterButtonViewInfo;
begin
Result := AItemClass.Create(Self);
FItems.Add(Result);
end;
procedure TcxGridFilterButtonsViewInfo.Calculate(const ABounds: TRect);
var
ALeftMargin, ARightMargin, ALeft, I: Integer;
begin
ALeftMargin := ABounds.Left + FilterButtonsFirstOffset;
ARightMargin := ABounds.Right - FilterButtonsFirstOffset;
for I := 0 to Count - 1 do
with Items[I], ABounds do
if Visible then
begin
if Alignment = fbaLeft then
ALeft := ALeftMargin
else
ALeft := ARightMargin - CalculateWidth;
Calculate(ALeft, MulDiv(Top + Bottom - CalculateHeight, 1, 2));
if Alignment = fbaLeft then
ALeftMargin := Items[I].Bounds.Right + FilterButtonsOffset
else
ARightMargin := Items[I].Bounds.Left - FilterButtonsOffset;
end;
end;
function TcxGridFilterButtonsViewInfo.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
var
I: Integer;
begin
Result := nil;
for I := 0 to Count - 1 do
begin
Result := Items[I].GetHitTest(P);
if Result <> nil then Break;
end;
end;
{ TcxGridFilterViewInfo }
constructor TcxGridFilterViewInfo.Create(AGridViewInfo: TcxCustomGridTableViewInfo);
begin
inherited;
CreateButtonsViewInfo;
end;
destructor TcxGridFilterViewInfo.Destroy;
begin
DestroyButtonsViewInfo;
inherited;
end;
function TcxGridFilterViewInfo.GetFilter: TcxDataFilterCriteria;
begin
Result := GridView.DataController.Filter;
end;
function TcxGridFilterViewInfo.GetFiltering: TcxCustomGridTableFiltering;
begin
Result := TcxCustomGridTableView(GridView).Filtering;
end;
procedure TcxGridFilterViewInfo.CreateButtonsViewInfo;
begin
FButtonsViewInfo := GetButtonsViewInfoClass.Create(Self);
end;
procedure TcxGridFilterViewInfo.DestroyButtonsViewInfo;
begin
FreeAndNil(FButtonsViewInfo);
end;
function TcxGridFilterViewInfo.CalculateButtonsViewInfoBounds: TRect;
begin
Result := Bounds;
end;
function TcxGridFilterViewInfo.CalculateHeight: Integer;
var
AButtonsHeight: Integer;
begin
Result := FilterTextOffset + TextHeightWithOffset + FilterTextOffset;
AButtonsHeight := FButtonsViewInfo.Height;
if Result < AButtonsHeight then Result := AButtonsHeight;
end;
function TcxGridFilterViewInfo.CalculateWidth: Integer;
begin
Result := GridViewInfo.ClientWidth;
end;
function TcxGridFilterViewInfo.GetAlignment: TcxGridPartAlignment;
begin
Result := TcxGridPartAlignment(GridView.FilterBox.Position);
end;
function TcxGridFilterViewInfo.GetAlignmentVert: TcxAlignmentVert;
begin
Result := vaCenter;
end;
function TcxGridFilterViewInfo.GetBackgroundBitmap: TBitmap;
begin
Result := GridView.BackgroundBitmaps.GetBitmap(bbFilterBox);
end;
function TcxGridFilterViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
begin
Result := TcxGridFilterHitTest;
end;
function TcxGridFilterViewInfo.GetHotTrack: Boolean;
begin
Result := Filtering.IsMRUItemsListAvailable;
end;
function TcxGridFilterViewInfo.GetIsAutoWidth: Boolean;
begin
Result := True;
end;
function TcxGridFilterViewInfo.GetIsCheck: Boolean;
begin
Result := True;
end;
function TcxGridFilterViewInfo.GetIsScrollable: Boolean;
begin
Result := False;
end;
function TcxGridFilterViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
begin
Result := TcxGridFilterPainter;
end;
function TcxGridFilterViewInfo.GetText: string;
begin
Result := Filter.FilterCaption;
if Result = '' then
Result := cxGetResourceString(@scxGridFilterIsEmpty);
end;
function TcxGridFilterViewInfo.GetTextAreaBounds: TRect;
begin
Result := inherited GetTextAreaBounds;
Inc(Result.Left, FButtonsViewInfo.WidthLeftPart);
Dec(Result.Right, FButtonsViewInfo.WidthRightPart);
InflateRect(Result, -FilterTextOffset, 0);
end;
procedure TcxGridFilterViewInfo.GetViewParams(var AParams: TcxViewParams);
begin
GridView.Styles.GetViewParams(vsFilterBox, nil, nil, AParams);
end;
function TcxGridFilterViewInfo.GetVisible: Boolean;
begin
Result := (GridView.FilterBox.Visible = fvAlways) or
(GridView.FilterBox.Visible = fvNonEmpty) and not Filter.IsEmpty;
end;
function TcxGridFilterViewInfo.HasMouse(AHitTest: TcxCustomGridHitTest): Boolean;
begin
Result := inherited HasMouse(AHitTest) and PtInRect(TextBounds, AHitTest.Pos);
end;
function TcxGridFilterViewInfo.InvalidateOnStateChange: Boolean;
begin
Result := False;
end;
procedure TcxGridFilterViewInfo.StateChanged(APrevState: TcxGridCellState);
begin
if not IsDestroying then
GridView.ViewChanged(TextBounds);
inherited;
if State = gcsPressed then
FButtonsViewInfo.DropDownButtonViewInfo.State := gcsPressed;
end;
function TcxGridFilterViewInfo.GetButtonsViewInfoClass: TcxGridFilterButtonsViewInfoClass;
begin
Result := TcxGridFilterButtonsViewInfo;
end;
procedure TcxGridFilterViewInfo.Calculate(ALeftBound, ATopBound: Integer;
AWidth: Integer = -1; AHeight: Integer = -1);
begin
inherited;
FButtonsViewInfo.Calculate(CalculateButtonsViewInfoBounds);
end;
function TcxGridFilterViewInfo.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
begin
Result := FButtonsViewInfo.GetHitTest(P);
if Result = nil then
Result := inherited GetHitTest(P);
end;
{ TcxGridTableCellViewInfo }
constructor TcxGridTableCellViewInfo.Create(ARecordViewInfo: TcxCustomGridRecordViewInfo);
begin
inherited Create(ARecordViewInfo.GridViewInfo);
FRecordViewInfo := ARecordViewInfo;
end;
function TcxGridTableCellViewInfo.GetCacheItem: TcxCustomGridTableViewInfoCacheItem;
begin
Result := FRecordViewInfo.CacheItem;
end;
function TcxGridTableCellViewInfo.GetController: TcxCustomGridTableController;
begin
Result := TcxCustomGridTableController(inherited Controller);
end;
function TcxGridTableCellViewInfo.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
function TcxGridTableCellViewInfo.GetGridRecord: TcxCustomGridRecord;
begin
Result := FRecordViewInfo.GridRecord;
end;
function TcxGridTableCellViewInfo.GetSelected: Boolean;
begin
if not FSelectedCalculated then
begin
FSelected := CalculateSelected;
FSelectedCalculated := True;
end;
Result := FSelected;
end;
function TcxGridTableCellViewInfo.GetGridViewInfo: TcxCustomGridTableViewInfo;
begin
Result := FRecordViewInfo.GridViewInfo;
end;
function TcxGridTableCellViewInfo.CalculateSelected: Boolean;
begin
Result := GridView.DrawDataCellSelected(GridRecord, nil, True, Self);
end;
function TcxGridTableCellViewInfo.GetAlwaysSelected: Boolean;
begin
Result := False;
end;
function TcxGridTableCellViewInfo.GetCanvas: TcxCanvas;
begin
Result := GridViewInfo.Canvas;
end;
function TcxGridTableCellViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
begin
Result := TcxGridRecordHitTest;
end;
function TcxGridTableCellViewInfo.GetTransparent: Boolean;
begin {4}
Result := FRecordViewInfo.GetCellTransparent(Self);
end;
procedure TcxGridTableCellViewInfo.InitHitTest(AHitTest: TcxCustomGridHitTest);
begin
inherited;
TcxGridRecordHitTest(AHitTest).GridRecord := GridRecord;
end;
procedure TcxGridTableCellViewInfo.Calculate(ALeftBound, ATopBound: Integer;
AWidth: Integer = -1; AHeight: Integer = -1);
begin
FSelectedCalculated := False;
inherited;
end;
function TcxGridTableCellViewInfo.CanDrawSelected: Boolean;
begin
Result := False;
end;
function TcxGridTableCellViewInfo.MouseDown(AHitTest: TcxCustomGridHitTest;
AButton: TMouseButton; AShift: TShiftState): Boolean;
var
AGridViewLink: TcxGridListenerLink;
begin
AGridViewLink := GridView.AddListenerLink;
try
GridViewInfo.AddActiveViewInfo(Self);
try
Result := FRecordViewInfo.MouseDown(AHitTest, AButton, AShift);
if Result and TcxCustomGridTableView(AGridViewLink.GridView).ViewInfo.IsViewInfoActive(Self) then
inherited MouseDown(AHitTest, AButton, AShift);
finally
if AGridViewLink.GridView <> nil then
TcxCustomGridTableView(AGridViewLink.GridView).ViewInfo.RemoveActiveViewInfo(Self)
else
Result := False;
end;
finally
AGridViewLink.Free;
end;
end;
{ TcxGridTableDataCellViewInfo }
constructor TcxGridTableDataCellViewInfo.Create(ARecordViewInfo: TcxCustomGridRecordViewInfo;
AItem: TcxCustomGridTableItem);
begin
inherited Create(ARecordViewInfo);
FItem := AItem;
FItem.AddCell(Self);
FProperties := FItem.GetProperties(GridRecord);
FEditViewInfo := CreateEditViewInfo;
FStyle := FItem.GetCellStyle;
end;
destructor TcxGridTableDataCellViewInfo.Destroy;
begin
if FItem <> nil then
begin
if FItem.Controller.ClickedCellViewInfo = Self then
FItem.Controller.ClickedCellViewInfo := nil;
if not GridView.IsDestroying then
FItem.ReleaseCellStyle;
FItem.RemoveCell(Self);
end;
FEditViewInfo.Free;
inherited;
end;
function TcxGridTableDataCellViewInfo.GetEditing: Boolean;
begin
Result := FItem.Editing and Focused;
end;
function TcxGridTableDataCellViewInfo.GetMousePos: TPoint;
begin
Result := GridViewInfo.MousePos;
end;
function TcxGridTableDataCellViewInfo.GetProperties: TcxCustomEditProperties;
begin
Result := FProperties;
FItem.InitProperties(Result);
end;
function TcxGridTableDataCellViewInfo.GetShowButtons: Boolean;
begin
Result := FItem.ShowButtons(RecordViewInfo.Focused);
end;
procedure TcxGridTableDataCellViewInfo.AfterCustomDraw(ACanvas: TcxCanvas);
begin
FEditViewInfo.BackgroundColor := ACanvas.Brush.Color;
if FEditViewInfo is TcxCustomTextEditViewInfo then
with TcxCustomTextEditViewInfo(FEditViewInfo) do
begin
Font := ACanvas.Font;
TextColor := ACanvas.Font.Color;
end;
end;
procedure TcxGridTableDataCellViewInfo.BeforeCustomDraw(ACanvas: TcxCanvas);
begin
ACanvas.Brush.Color := FEditViewInfo.BackgroundColor;
if FEditViewInfo is TcxCustomTextEditViewInfo then
with TcxCustomTextEditViewInfo(FEditViewInfo) do
begin
ACanvas.Font := Font;
ACanvas.Font.Color := TextColor;
end;
end;
procedure TcxGridTableDataCellViewInfo.CalculateEditViewInfo(AEditViewInfo: TcxCustomEditViewInfo;
const AMousePos: TPoint);
begin
InitStyle;
CreateEditViewData;
try
FEditViewData.PaintOptions := [];
GetEditViewDataContentOffsets(FEditViewData.ContentOffset);
if AutoHeight or MultiLine then
begin
Include(FEditViewData.PaintOptions, epoAutoHeight);
FEditViewData.MaxLineCount := MaxLineCount;
end;
if ShowEndEllipsis then
Include(FEditViewData.PaintOptions, epoShowEndEllipsis);
FEditViewData.IsSelected := Selected;
AEditViewInfo.Transparent := Transparent; {4}
InitTextSelection;
FEditViewData.InplaceEditParams.Position := GetInplaceEditPosition;
FEditViewData.EditValueToDrawValue(Canvas, DisplayValue, AEditViewInfo);
FEditViewData.Calculate(Canvas, EditViewDataBounds, AMousePos, cxmbNone, [], AEditViewInfo, True);
finally
DestroyEditViewData;
end;
end;
function TcxGridTableDataCellViewInfo.CalculateHeight: Integer;
var
AEditSizeProperties: TcxEditSizeProperties;
begin
CalculateParams;
if FItem.CanAutoHeight then
begin
CreateEditViewData;
try
SetRectEmpty(FEditViewData.ContentOffset);
Include(FEditViewData.PaintOptions, epoAllowZeroHeight);
with AEditSizeProperties do
begin
Height := -1;
MaxLineCount := Self.MaxLineCount;
with TextAreaBounds do
Width := Right - Left;
Inc(Width, 2 * (cxGridCellTextOffset - cxGridEditOffset));
end;
if AEditSizeProperties.Width > 0 then
begin
FEditViewData.InplaceEditParams.Position := GetInplaceEditPosition;
Result := FEditViewData.GetEditSize(Canvas, DisplayValue, AEditSizeProperties).cy;
end
else
Result := 0;
if Result <> 0 then
Inc(Result, 2 * cxGridEditOffset)
else
if not SupportsZeroHeight then
Result := FItem.CalculateDefaultCellHeight(Canvas, Params.Font);
finally
DestroyEditViewData;
end;
end
else
Result := FItem.CalculateDefaultCellHeight(Canvas, Params.Font);
GridView.DoGetCellHeight(GridRecord, FItem, Self, Result);
end;
function TcxGridTableDataCellViewInfo.CalculateSelected: Boolean;
begin
Result := GridView.DrawDataCellSelected(GridRecord, FItem, True, Self);
end;
function TcxGridTableDataCellViewInfo.CanActivateEditOnMouseDown(AButton: TMouseButton): Boolean;
begin
Result := CanShowEdit and
((AButton = mbLeft) and HotTrack or GridView.OptionsBehavior.AlwaysShowEditor);
end;
function TcxGridTableDataCellViewInfo.CanShowEdit: Boolean;
begin
Result := True;
end;
procedure TcxGridTableDataCellViewInfo.CheckEditHotTrack(const AMousePos: TPoint);
var
AEditViewInfo: TcxCustomEditViewInfo;
begin
if not GridView.Visible then Exit;
AEditViewInfo := CreateEditViewInfo;
try
CalculateEditViewInfo(AEditViewInfo, AMousePos);
if FEditViewInfo.Repaint(Control, AEditViewInfo) then
EditHotTrackChanged;
finally
AEditViewInfo.Free;
end;
end;
function TcxGridTableDataCellViewInfo.CustomDraw(ACanvas: TcxCanvas): Boolean;
begin
Result := inherited CustomDraw(ACanvas);
if not Result then
begin
FItem.DoCustomDrawCell(ACanvas, Self, Result);
if not Result then
GridView.DoCustomDrawCell(ACanvas, Self, Result);
end;
end;
procedure TcxGridTableDataCellViewInfo.DoCalculateParams;
begin
inherited;
InitStyle;
end;
procedure TcxGridTableDataCellViewInfo.EditHotTrackChanged;
var
AEditUpdateNeeded: Boolean;
begin
AEditUpdateNeeded := GridView.Controller.EditingController.EditUpdateNeeded;
Invalidate(True);
if not AEditUpdateNeeded then
GridView.Controller.EditingController.CancelEditUpdatePost;
end;
function TcxGridTableDataCellViewInfo.GetAreaBounds: TRect;
begin
Result := RecordViewInfo.RecordsViewInfo.GetAreaBoundsForCell(Self);
end;
function TcxGridTableDataCellViewInfo.GetAutoHeight: Boolean;
begin
Result := RecordViewInfo.AutoHeight;
end;
function TcxGridTableDataCellViewInfo.GetDisplayValue: TcxEditValue;
begin
if Properties.GetEditValueSource(False) = evsValue then
Result := GridRecord.Values[FItem.Index]
else
Result := GridRecord.DisplayTexts[FItem.Index];
end;
function TcxGridTableDataCellViewInfo.GetEditBounds: TRect;
begin
Result := EditViewDataBounds;
InflateRect(Result, -cxGridEditOffset, -cxGridEditOffset);
if FItem.CanScroll then
with GridViewInfo.ScrollableAreaBoundsForEdit do
begin
//if Result.Left < Left then Result.Left := Left;
if Result.Right > Right then Result.Right := Right;
if Result.Bottom > Bottom then Result.Bottom := Bottom;
end;
end;
function TcxGridTableDataCellViewInfo.GetEditViewDataBounds: TRect;
begin
Result := ContentBounds;
end;
procedure TcxGridTableDataCellViewInfo.GetEditViewDataContentOffsets(var R: TRect);
begin
with R do
begin
Left := cxGridEditOffset;
Top := cxGridEditOffset;
Right := cxGridEditOffset;
Bottom := cxGridEditOffset;
end;
end;
function TcxGridTableDataCellViewInfo.GetFocused: Boolean;
begin
Result := FItem.Focused and RecordViewInfo.Focused and (FItem.FocusedCellViewInfo = Self);
end;
function TcxGridTableDataCellViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
begin
Result := TcxGridRecordCellHitTest;
end;
function TcxGridTableDataCellViewInfo.GetHotTrack: Boolean;
begin
Result := ShowButtons or (esoAlwaysHotTrack in Properties.GetSupportedOperations) and
(GridView.OptionsBehavior.ImmediateEditor or Focused);
//Result := ShowButtons or (esoAlwaysHotTrack in Properties.GetSupportedOperations);
end;
function TcxGridTableDataCellViewInfo.GetMaxLineCount: Integer;
begin
Result := GridView.OptionsView.CellTextMaxLineCount;
end;
function TcxGridTableDataCellViewInfo.GetMultiLine: Boolean;
begin
Result := RecordViewInfo.RecordsViewInfo.IsCellMultiLine(Item);
end;
function TcxGridTableDataCellViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
begin
Result := TcxGridTableDataCellPainter;
end;
function TcxGridTableDataCellViewInfo.GetShowEndEllipsis: Boolean;
begin
Result := GridView.OptionsView.CellEndEllipsis;
end;
function TcxGridTableDataCellViewInfo.GetText: string;
begin
if FEditViewInfo is TcxCustomTextEditViewInfo then
Result := TcxCustomTextEditViewInfo(FEditViewInfo).Text
else
Result := '';
end;
function TcxGridTableDataCellViewInfo.GetValue: Variant;
begin
Result := GridRecord.Values[FItem.Index];
end;
procedure TcxGridTableDataCellViewInfo.GetViewParams(var AParams: TcxViewParams);
begin
GridView.Styles.GetDataCellParams(GridRecord, FItem, Params, True, Self);
end;
function TcxGridTableDataCellViewInfo.HasCustomDraw: Boolean;
begin
Result := FItem.HasCustomDrawCell or GridView.HasCustomDrawCell;
end;
function TcxGridTableDataCellViewInfo.HasFocusRect: Boolean;
begin
Result := not GridView.OptionsSelection.InvertSelect and not Editing;
end;
procedure TcxGridTableDataCellViewInfo.InitHitTest(AHitTest: TcxCustomGridHitTest);
begin
inherited;
TcxGridRecordCellHitTest(AHitTest).Item := Item;
end;
procedure TcxGridTableDataCellViewInfo.InitTextSelection;
var
AIncSearchParams: TcxViewParams;
begin
with FEditViewData do
if IsTextSelected then
begin
SelStart := 0;
SelLength := Length(Controller.IncSearchingText);
GridView.Styles.GetViewParams(vsIncSearch, nil, nil, AIncSearchParams);
SelBackgroundColor := AIncSearchParams.Color;
SelTextColor := AIncSearchParams.TextColor;
end
else
SelLength := 0;
end;
function TcxGridTableDataCellViewInfo.InvalidateOnStateChange: Boolean;
begin
Result := False;
end;
function TcxGridTableDataCellViewInfo.IsTextSelected: Boolean;
begin
Result := RecordViewInfo.RecordsViewInfo.IncSearchingCellViewInfo = Self;
end;
procedure TcxGridTableDataCellViewInfo.MouseLeave;
begin
inherited;
if HotTrack then
CheckEditHotTrack(Bounds.BottomRight);
end;
procedure TcxGridTableDataCellViewInfo.Offset(DX, DY: Integer);
begin
inherited;
FEditViewInfo.Offset(DX, DY);
end;
procedure TcxGridTableDataCellViewInfo.RestoreParams(const AParams: TcxViewParams);
begin
FEditViewInfo.BackgroundColor := AParams.Color;
if FEditViewInfo is TcxCustomTextEditViewInfo then
with TcxCustomTextEditViewInfo(FEditViewInfo) do
begin
Font := AParams.Font;
TextColor := AParams.TextColor;
end;
end;
procedure TcxGridTableDataCellViewInfo.SaveParams(out AParams: TcxViewParams);
begin
AParams.Color := FEditViewInfo.BackgroundColor;
if FEditViewInfo is TcxCustomTextEditViewInfo then
with TcxCustomTextEditViewInfo(FEditViewInfo) do
begin
AParams.Font := Font;
AParams.TextColor := TextColor;
end;
end;
procedure TcxGridTableDataCellViewInfo.StateChanged(APrevState: TcxGridCellState);
begin
inherited;
if State = gcsNone then EditHotTrackChanged;
end;
function TcxGridTableDataCellViewInfo.SupportsZeroHeight: Boolean;
begin
Result := False;
end;
function TcxGridTableDataCellViewInfo.CanShowAutoHint: Boolean;
begin
Result := GridView.OptionsBehavior.CellHints;
end;
function TcxGridTableDataCellViewInfo.CanShowCustomHint: Boolean;
begin
Result := Item.HasCellHintHandler;
end;
function TcxGridTableDataCellViewInfo.CanShowHint: Boolean;
begin
Result := (CanShowAutoHint or CanShowCustomHint) and not Editing;
end;
function TcxGridTableDataCellViewInfo.GetCellBoundsForHint: TRect;
begin
Result := ContentBounds;
end;
function TcxGridTableDataCellViewInfo.NeedShowHint(const AMousePos: TPoint;
out AHintText: TCaption; out AIsHintMultiLine: Boolean; out ATextRect: TRect): Boolean;
begin
if CanShowAutoHint then
if UseStandardNeedShowHint then
Result := inherited NeedShowHint(AMousePos, AHintText, AIsHintMultiLine, ATextRect)
else
Result := FEditViewInfo.NeedShowHint(Canvas, AMousePos, GetAreaBoundsForHint,
AHintText, AIsHintMultiLine, ATextRect)
else
Result := False;
if CanShowCustomHint and (Result or HasHintPoint(AMousePos)) then
begin
if not Result then
begin
AHintText := '';
AIsHintMultiLine := False;
ATextRect := GetHintTextRect(AMousePos);
end;
Item.DoGetCellHint(GridRecord, Self, AMousePos, AHintText, AIsHintMultiLine, ATextRect);
if not Result then
Result := AHintText <> '';
end;
end;
function TcxGridTableDataCellViewInfo.UseStandardNeedShowHint: Boolean;
begin
Result := False;
end;
procedure TcxGridTableDataCellViewInfo.InitStyle;
begin
FItem.InitStyle(FStyle, Params, RecordViewInfo.Focused);
end;
function TcxGridTableDataCellViewInfo.CreateEditViewInfo: TcxCustomEditViewInfo;
begin
Result := Properties.GetViewInfoClass.Create as TcxCustomEditViewInfo;
end;
procedure TcxGridTableDataCellViewInfo.CreateEditViewData;
begin
FEditViewData := FItem.GetEditViewData(GetProperties, FIsLocalCopyOfEditViewData);
FEditViewData.Data := GridRecord;
end;
procedure TcxGridTableDataCellViewInfo.DestroyEditViewData;
begin
FItem.ReleaseEditViewData(FEditViewData, FIsLocalCopyOfEditViewData);
end;
procedure TcxGridTableDataCellViewInfo.UpdateEdit;
begin
if not Controller.EditingController.EditPreparing then
Controller.EditingController.UpdateEdit;
end;
procedure TcxGridTableDataCellViewInfo.BeforeRecalculation;
begin
GridViewInfo.UpdateMousePos;
inherited;
end;
procedure TcxGridTableDataCellViewInfo.Calculate(ALeftBound, ATopBound: Integer;
AWidth: Integer = -1; AHeight: Integer = -1);
begin
inherited;
CalculateEditViewInfo(FEditViewInfo, MousePos);
Text := GetText;
if not GridViewInfo.IsInternalUse and Editing then UpdateEdit;
end;
function TcxGridTableDataCellViewInfo.CanDrawSelected: Boolean;
begin
Result := True;
end;
function TcxGridTableDataCellViewInfo.GetInplaceEditPosition: TcxInplaceEditPosition;
begin
Result.Item := FItem;
Result.RecordIndex := RecordViewInfo.GridRecord.RecordIndex;
end;
procedure TcxGridTableDataCellViewInfo.Invalidate(ARecalculate: Boolean);
begin
if IsDestroying then Exit;
if ARecalculate then Recalculate;
inherited Invalidate;
{if ARecalculate then
GridRecord.Invalidate(FItem)
else
inherited Invalidate;}
end;
function TcxGridTableDataCellViewInfo.MouseDown(AHitTest: TcxCustomGridHitTest;
AButton: TMouseButton; AShift: TShiftState): Boolean;
var
AGridViewLink: TcxGridListenerLink;
AItem: TcxCustomGridTableItem;
AActivateEdit, AHotTrack, APostCheckEdit: Boolean;
begin
FWasFocusedBeforeClick := Focused;
AGridViewLink := GridView.AddListenerLink;
try
AItem := FItem;
AActivateEdit := CanActivateEditOnMouseDown(AButton);
AHotTrack := HotTrack;
APostCheckEdit := False;
Controller.AllowCheckEdit := False;
GridView.DontMakeMasterRecordVisible := True;
GridView.ViewInfo.AddActiveViewInfo(Self);
try
if ssDouble in AShift then
begin
Result := GridView.DoCellDblClick(Self, AButton, AShift);
if Result or not AItem.GridView.ViewInfo.IsViewInfoActive(Self) then
begin
Result := False;
Exit;
end;
end;
Result := inherited MouseDown(AHitTest, AButton, AShift);
if Result and not AItem.Controller.EditingController.IsErrorOnEditExit then
begin
AItem.Focused := True;
if AItem.Focused then
if (AButton <> mbMiddle) and (AShift * [ssCtrl, ssShift] = []) and AActivateEdit then
begin
AItem.GridView.Site.FinishDragAndDrop(False);
if AHotTrack then
AItem.Controller.EditingController.ShowEdit(AItem, AShift, AHitTest.Pos.X, AHitTest.Pos.Y)
else
AItem.Controller.EditingController.ShowEdit(AItem);
end
else
AItem.Controller.IsReadyForImmediateEditing := True
else
APostCheckEdit := True;
if AItem.GridView.ViewInfo.IsViewInfoActive(Self) and
(AItem.Controller.EditingItem <> AItem) then
AItem.Controller.ClickedCellViewInfo := Self;
end;
finally
if AGridViewLink.GridView <> nil then
begin
AItem.GridView.ViewInfo.RemoveActiveViewInfo(Self);
AItem.GridView.DontMakeMasterRecordVisible := False;
AItem.Controller.AllowCheckEdit := True;
if APostCheckEdit then
AItem.Controller.PostCheckEdit;
end;
end;
finally
AGridViewLink.Free;
end;
end;
function TcxGridTableDataCellViewInfo.MouseMove(AHitTest: TcxCustomGridHitTest;
AShift: TShiftState): Boolean;
begin
Result := inherited MouseMove(AHitTest, AShift);
if HotTrack then
CheckEditHotTrack(AHitTest.Pos);
end;
function TcxGridTableDataCellViewInfo.MouseUp(AHitTest: TcxCustomGridHitTest;
AButton: TMouseButton; AShift: TShiftState): Boolean;
procedure ShowEdit;
var
AGridView: TcxCustomGridTableView;
begin
AGridView := GridView;
AGridView.DontMakeMasterRecordVisible := True;
try
Controller.EditingController.ShowEdit(FItem, AShift, AHitTest.Pos.X, AHitTest.Pos.Y);
finally
AGridView.DontMakeMasterRecordVisible := False;
end;
end;
begin
inherited MouseUp(AHitTest, AButton, AShift);
if FItem.Controller.ClickedCellViewInfo = Self then
begin
FItem.Controller.ClickedCellViewInfo := nil;
Result := GridView.DoCellClick(Self, AButton, AShift);
if Result then Exit;
end
else
Result := False;
if (AButton = mbLeft) and (AShift * [ssCtrl, ssShift] = []) and
Focused and CanShowEdit then
begin
if not Editing then
if GridView.OptionsBehavior.ImmediateEditor then
if Controller.IsReadyForImmediateEditing then
ShowEdit
else
else
if FWasFocusedBeforeClick and not Controller.IsDblClick then
Controller.EditingController.StartEditShowingTimer(FItem);
Result := True;
end;
end;
{ TcxCustomGridRecordViewInfo }
constructor TcxCustomGridRecordViewInfo.Create(ARecordsViewInfo: TcxCustomGridRecordsViewInfo;
ARecord: TcxCustomGridRecord);
begin
inherited Create(ARecordsViewInfo.GridViewInfo);
FRecordsViewInfo := ARecordsViewInfo;
FRecord := ARecord;
if FRecord <> nil then
begin
FIsRecordViewInfoAssigned := FRecord.ViewInfo <> nil;
if not FIsRecordViewInfoAssigned then
FRecord.FViewInfo := Self;
end;
end;
destructor TcxCustomGridRecordViewInfo.Destroy;
begin
if not FIsRecordViewInfoAssigned and (FRecord <> nil) then
FRecord.FViewInfo := nil;
inherited;
end;
function TcxCustomGridRecordViewInfo.GetCacheItem: TcxCustomGridTableViewInfoCacheItem;
begin
if FRecord = nil then
Result := nil
else
Result := TcxCustomGridTableViewInfoCacheItem(GridView.ViewInfoCache[FRecord.Index]);
end;
function TcxCustomGridRecordViewInfo.GetExpanded: Boolean;
begin
if not FExpandedCalculated then
begin
FExpanded := (FRecord <> nil) and FRecord.Expanded;
FExpandedCalculated := True;
end;
Result := FExpanded;
end;
function TcxCustomGridRecordViewInfo.GetFocused: Boolean;
begin
Result := GridView.DrawRecordFocused(GridRecord);
end;
function TcxCustomGridRecordViewInfo.GetGridView: TcxCustomGridTableView;
begin
Result := GridViewInfo.GridView;
end;
function TcxCustomGridRecordViewInfo.GetGridViewInfo: TcxCustomGridTableViewInfo;
begin
Result := FRecordsViewInfo.GridViewInfo;
end;
function TcxCustomGridRecordViewInfo.GetIndex: Integer;
begin
Result := FRecordsViewInfo.FItems.IndexOf(Self);
end;
function TcxCustomGridRecordViewInfo.GetSelected: Boolean;
begin
if not FSelectedCalculated then
begin
FSelected := CalculateSelected;
FSelectedCalculated := True;
end;
Result := FSelected;
end;
function TcxCustomGridRecordViewInfo.CalculateSelected: Boolean;
begin
Result := GridView.DrawRecordSelected(GridRecord);
end;
function TcxCustomGridRecordViewInfo.CanGenerateExpandButtonHitTest: Boolean;
begin
Result := True;
end;
procedure TcxCustomGridRecordViewInfo.ControlFocusChanged;
begin
end;
function TcxCustomGridRecordViewInfo.GetAutoHeight: Boolean;
begin
Result := False;
end;
function TcxCustomGridRecordViewInfo.GetBackgroundBitmap: TBitmap;
begin
Result := FRecordsViewInfo.BackgroundBitmap;
end;
function TcxCustomGridRecordViewInfo.GetBackgroundBitmapBounds: TRect;
begin
Result := ContentBounds;
end;
function TcxCustomGridRecordViewInfo.GetCanvas: TcxCanvas;
begin
Result := FRecordsViewInfo.Canvas;
end;
function TcxCustomGridRecordViewInfo.GetCellTransparent(ACell: TcxGridTableCellViewInfo): Boolean;
begin
Result := Transparent;
end;
function TcxCustomGridRecordViewInfo.GetContentBounds: TRect;
begin
Result := Bounds;
end;
function TcxCustomGridRecordViewInfo.GetExpandButtonAreaBounds: TRect;
begin
Result := cxEmptyRect;
end;
function TcxCustomGridRecordViewInfo.GetFocusRectBounds: TRect;
begin
Result := Bounds;
end;
function TcxCustomGridRecordViewInfo.GetHeight: Integer;
begin
if CacheItem.IsHeightAssigned then
Result := CacheItem.Height
else
begin
Result := CalculateHeight;
CacheItem.Height := Result;
end;
end;
function TcxCustomGridRecordViewInfo.GetHideFocusRectOnExit: Boolean;
begin
Result := GridView.OptionsSelection.HideFocusRectOnExit;
end;
function TcxCustomGridRecordViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
begin
Result := TcxGridRecordHitTest;
end;
function TcxCustomGridRecordViewInfo.GetVisible: Boolean;
begin
Result := Index < FRecordsViewInfo.VisibleCount;
end;
function TcxCustomGridRecordViewInfo.HasFocusRect: Boolean;
begin
Result := not GridRecord.CanFocusCells or GridView.OptionsSelection.InvertSelect;
end;
procedure TcxCustomGridRecordViewInfo.InitHitTest(AHitTest: TcxCustomGridHitTest);
begin
inherited;
(AHitTest as TcxGridRecordHitTest).GridRecord := GridRecord;
end;
function TcxCustomGridRecordViewInfo.IsClickHitTest(AHitTest: TcxCustomGridHitTest): Boolean;
begin
Result := TcxCustomGridTableController(Controller).IsClickableRecordHitTest(AHitTest);
end;
function TcxCustomGridRecordViewInfo.IsDetailVisible(ADetail: TcxCustomGridView): Boolean;
begin
Result := False;
end;
procedure TcxCustomGridRecordViewInfo.Offset(DX, DY: Integer);
begin
inherited;
OffsetRect(FExpandButtonBounds, DX, DY);
end;
procedure TcxCustomGridRecordViewInfo.VisibilityChanged(AVisible: Boolean);
begin
end;
procedure TcxCustomGridRecordViewInfo.BeforeRecalculation;
begin
inherited;
FRecordsViewInfo.BeforeItemRecalculation;
end;
function TcxCustomGridRecordViewInfo.Click(AHitTest: TcxCustomGridHitTest;
AButton: TMouseButton; AShift: TShiftState): Boolean;
var
AGridViewLink: TcxGridListenerLink;
begin
Result := ssDouble in AShift;
if not Result then
begin
AGridViewLink := GridView.AddListenerLink;
try
GridViewInfo.Controller.FocusedRecord := GridRecord;
finally
Result := AGridViewLink.GridView <> nil; {!!!}
AGridViewLink.Free;
end;
end;
end;
function TcxCustomGridRecordViewInfo.GetBoundsForInvalidate(AItem: TcxCustomGridTableItem): TRect;
begin
if AItem = nil then
Result := Bounds
else
Result := GetBoundsForItem(AItem);
end;
function TcxCustomGridRecordViewInfo.GetBoundsForItem(AItem: TcxCustomGridTableItem): TRect;
begin
Result := Rect(0, 0, 0, 0);
end;
function TcxCustomGridRecordViewInfo.GetCellViewInfoByItem(AItem: TcxCustomGridTableItem): TcxGridTableDataCellViewInfo;
begin
Result := nil;
end;
{procedure TcxCustomGridRecordViewInfo.GetDataCellViewParams(AItem: TcxCustomGridTableItem;
ACellViewInfo: TcxGridTableCellViewInfo; var AParams: TcxViewParams);
begin
RecordsViewInfo.GetDataCellViewParams(GridRecord, AItem, ACellViewInfo, AParams);
end;}
function TcxCustomGridRecordViewInfo.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
begin
if CanGenerateExpandButtonHitTest and
GridRecord.Expandable and PtInRect(ExpandButtonAreaBounds, P) then
begin
Result := TcxGridExpandButtonHitTest.Instance(P);
InitHitTest(Result);
end
else
Result := inherited GetHitTest(P);
end;
procedure TcxCustomGridRecordViewInfo.MainCalculate(ALeftBound, ATopBound: Integer);
begin
FSelectedCalculated := False;
Calculate(ALeftBound, ATopBound, Width, Height);
if GridRecord.Expandable then
CalculateExpandButtonBounds(FExpandButtonBounds);
end;
function TcxCustomGridRecordViewInfo.MouseDown(AHitTest: TcxCustomGridHitTest;
AButton: TMouseButton; AShift: TShiftState): Boolean;
begin
Result := inherited MouseDown(AHitTest, AButton, AShift);
if not Result and (AButton = mbLeft) and (AHitTest.HitTestCode = htExpandButton) then
begin
GridRecord.ToggleExpanded;
Result := True;
end;
if not Result and (AButton <> mbMiddle) and IsClickHitTest(AHitTest) and
GridView.Site.IsFocused then
Result := Click(AHitTest, AButton, AShift);
end;
function TcxCustomGridRecordViewInfo.ProcessDialogChar(ACharCode: Word): Boolean;
begin
Result := False;
end;
procedure TcxCustomGridRecordViewInfo.Recalculate;
begin
BeforeRecalculation;
MainCalculate(Bounds.Left, Bounds.Top);
AfterRecalculation;
end;
{ TcxCustomGridRecordsViewInfo }
constructor TcxCustomGridRecordsViewInfo.Create(AGridViewInfo: TcxCustomGridTableViewInfo);
begin
inherited Create;
FGridViewInfo := AGridViewInfo;
CreateItems;
end;
destructor TcxCustomGridRecordsViewInfo.Destroy;
begin
DestroyItems;
inherited;
end;
function TcxCustomGridRecordsViewInfo.GetCanvas: TcxCanvas;
begin
Result := FGridViewInfo.Canvas;
end;
function TcxCustomGridRecordsViewInfo.GetController: TcxCustomGridTableController;
begin
Result := FGridViewInfo.Controller;
end;
function TcxCustomGridRecordsViewInfo.GetCount: Integer;
begin
Result := FItems.Count;
end;
function TcxCustomGridRecordsViewInfo.GetFirstRecordIndex: Integer;
begin
Result := FGridViewInfo.FirstRecordIndex;
end;
function TcxCustomGridRecordsViewInfo.GetGridView: TcxCustomGridTableView;
begin
Result := FGridViewInfo.GridView;
end;
function TcxCustomGridRecordsViewInfo.GetIncSearchingCellViewInfo: TcxGridTableDataCellViewInfo;
begin
if not FIsIncSearchingCellViewInfoCalculated then
FIncSearchingCellViewInfo := CalculateIncSearchingCellViewInfo;
Result := FIncSearchingCellViewInfo;
end;
function TcxCustomGridRecordsViewInfo.GetItem(Index: Integer): TcxCustomGridRecordViewInfo;
begin
if Index < Count then
begin
Result := TcxCustomGridRecordViewInfo(FItems[Index]);
if Result.GridRecord = nil then
Result := nil;
end
else
begin
Result := CreateRecordViewInfo(Index);
FItems.Add(Result);
end;
end;
function TcxCustomGridRecordsViewInfo.GetMaxCount: Integer;
begin
if (FirstRecordIndex = -1) or (ViewData.RecordCount = 0) then
Result := 0
else
if GridViewInfo.CalculateDown then
Result := ViewData.RecordCount - FirstRecordIndex
else
Result := FirstRecordIndex + 1;
if Result < 0 then Result := 0;
end;
function TcxCustomGridRecordsViewInfo.GetTopRecordIndex: Integer;
begin
Result := GridViewInfo.Controller.TopRecordIndex;
end;
function TcxCustomGridRecordsViewInfo.GetViewData: TcxCustomGridTableViewData;
begin
Result := FGridViewInfo.ViewData;
end;
procedure TcxCustomGridRecordsViewInfo.CreateItems;
begin
FItems := TList.Create;
end;
procedure TcxCustomGridRecordsViewInfo.DestroyItems;
var
I: Integer;
begin
for I := 0 to Count - 1 do
TObject(FItems[I]).Free;
FItems.Free;
end;
function TcxCustomGridRecordsViewInfo.CreateRecordViewInfo(AIndex: Integer): TcxCustomGridRecordViewInfo;
var
ARecord: TcxCustomGridRecord;
begin
ARecord := ViewData.Records[GetRecordIndex(AIndex)];
Result := ARecord.GetViewInfoClass.Create(Self, ARecord);
end;
procedure TcxCustomGridRecordsViewInfo.AfterCalculate;
begin
DestroyEditViewDatas;
if FGridViewInfo.Visible then
Controller.EditingController.AfterViewInfoCalculate;
end;
procedure TcxCustomGridRecordsViewInfo.BeforeCalculate;
begin
FBackgroundBitmap := GetBackgroundBitmap;
if FGridViewInfo.Visible then
Controller.EditingController.BeforeViewInfoCalculate;
CreateEditViewDatas;
end;
procedure TcxCustomGridRecordsViewInfo.BeforeItemRecalculation;
begin
GridViewInfo.UpdateMousePos;
FIsIncSearchingCellViewInfoCalculated := False;
end;
procedure TcxCustomGridRecordsViewInfo.AfterOffset;
begin
end;
procedure TcxCustomGridRecordsViewInfo.BeforeOffset;
begin
FIsIncSearchingCellViewInfoCalculated := False;
end;
procedure TcxCustomGridRecordsViewInfo.Calculate;
begin
FBounds := CalculateBounds;
FContentBounds := CalculateContentBounds;
end;
function TcxCustomGridRecordsViewInfo.CalculateBounds: TRect;
begin
Result := FGridViewInfo.ClientBounds;
end;
function TcxCustomGridRecordsViewInfo.CalculateContentBounds: TRect;
begin
Result := Bounds;
end;
function TcxCustomGridRecordsViewInfo.CalculateIncSearchingCellViewInfo: TcxGridTableDataCellViewInfo;
begin
if Controller.IsIncSearching then
begin
Result := Controller.IncSearchingItem.FocusedCellViewInfo;
FIsIncSearchingCellViewInfoCalculated := Result <> nil;
end
else
begin
Result := nil;
FIsIncSearchingCellViewInfoCalculated := True;
end;
end;
procedure TcxCustomGridRecordsViewInfo.CalculateVisibleCount;
begin
FVisibleCount := 0;
end;
procedure TcxCustomGridRecordsViewInfo.CreateEditViewDatas;
var
I: Integer;
begin
with GridView do
for I := 0 to ItemCount - 1 do
Items[I].DoCreateEditViewData;
end;
procedure TcxCustomGridRecordsViewInfo.DestroyEditViewDatas;
var
I: Integer;
begin
with GridView do
for I := 0 to ItemCount - 1 do
Items[I].DoDestroyEditViewData;
end;
function TcxCustomGridRecordsViewInfo.GetAreaBoundsForCell(ACellViewInfo: TcxGridTableDataCellViewInfo): TRect;
begin
Result := GridViewInfo.ScrollableAreaBounds;
end;
function TcxCustomGridRecordsViewInfo.GetAutoDataCellHeight: Boolean;
begin
Result := AutoRecordHeight;
end;
function TcxCustomGridRecordsViewInfo.GetAutoDataRecordHeight: Boolean;
begin
Result := AutoDataCellHeight;
end;
function TcxCustomGridRecordsViewInfo.GetAutoRecordHeight: Boolean;
begin
Result := GridView.OptionsView.CellAutoHeight or GridView.IsGetCellHeightAssigned;
end;
function TcxCustomGridRecordsViewInfo.GetBackgroundBitmap: TBitmap;
begin
Result := GridView.BackgroundBitmaps.GetBitmap(bbContent);
end;
function TcxCustomGridRecordsViewInfo.GetRecordIndex(AViewInfoIndex: Integer): Integer;
begin
if FGridViewInfo.CalculateDown then
Result := FGridViewInfo.FirstRecordIndex + AViewInfoIndex
else
Result := FGridViewInfo.FirstRecordIndex - AViewInfoIndex;
end;
function TcxCustomGridRecordsViewInfo.GetViewInfoIndex(ARecordIndex: Integer): Integer;
begin
if FGridViewInfo.CalculateDown then
Result := ARecordIndex - FGridViewInfo.FirstRecordIndex
else
Result := FGridViewInfo.FirstRecordIndex - ARecordIndex;
if (Result < -1) or (Result >= Count) then Result := -1
end;
function TcxCustomGridRecordsViewInfo.IsEmpty: Boolean;
begin
Result := Count = 0;
end;
procedure TcxCustomGridRecordsViewInfo.ControlFocusChanged;
var
I: Integer;
begin
for I := 0 to Count - 1 do
if Items[I] <> nil then
Items[I].ControlFocusChanged;
end;
procedure TcxCustomGridRecordsViewInfo.VisibilityChanged(AVisible: Boolean);
var
I: Integer;
begin
for I := 0 to Count - 1 do
if Items[I] <> nil then
Items[I].VisibilityChanged(AVisible);
end;
function TcxCustomGridRecordsViewInfo.GetPainterClass: TcxCustomGridRecordsPainterClass;
begin
Result := TcxCustomGridRecordsPainter;
end;
function TcxCustomGridRecordsViewInfo.CanOffset(AItemCountDelta: Integer): Boolean;
begin
Result := (Count <> 0) and (Abs(AItemCountDelta) < Count);
end;
function TcxCustomGridRecordsViewInfo.GetCellHeight(ACellContentHeight: Integer): Integer;
begin
Result := ACellContentHeight;
end;
function TcxCustomGridRecordsViewInfo.GetHitTest(const P: TPoint): TcxCustomGridHitTest;
var
I: Integer;
begin
for I := 0 to Count - 1 do
begin
Result := Items[I].GetHitTest(P);
if Result <> nil then Exit;
end;
Result := nil;
end;
function TcxCustomGridRecordsViewInfo.GetRealItem(ARecord: TcxCustomGridRecord): TcxCustomGridRecordViewInfo;
var
AIndex: Integer;
begin
AIndex := GetViewInfoIndex(ARecord.Index);
if AIndex = -1 then
Result := nil
else
Result := Items[AIndex];
end;
function TcxCustomGridRecordsViewInfo.IsCellMultiLine(AItem: TcxCustomGridTableItem): Boolean;
begin
Result := False;
end;
procedure TcxCustomGridRecordsViewInfo.MainCalculate;
begin
BeforeCalculate;
Calculate;
AfterCalculate;
end;
procedure TcxCustomGridRecordsViewInfo.Offset(AItemCountDelta: Integer);
var
AMoveCount: Integer;
procedure DeleteItems;
var
I: Integer;
begin
if AItemCountDelta < 0 then
I := Count + AItemCountDelta
else
I := 0;
for I := I to I + Abs(AItemCountDelta) - 1 do
Items[I].Free;
end;
procedure OffsetItemsList;
var
AIndexFrom: Integer;
begin
if AItemCountDelta < 0 then
AIndexFrom := 0
else
AIndexFrom := AItemCountDelta;
with FItems do
System.Move(List[AIndexFrom], List[AIndexFrom - AItemCountDelta], SizeOf(Pointer) * AMoveCount);
end;
procedure OffsetItems;
var
AIndexFrom, I: Integer;
begin
if AItemCountDelta < 0 then
AIndexFrom := Abs(AItemCountDelta)
else
AIndexFrom := 0;
for I := AIndexFrom to AIndexFrom + AMoveCount - 1 do
OffsetItem(I, FItemsOffset);
end;
procedure CreateItems;
var
I: Integer;
begin
if AItemCountDelta < 0 then
I := 0
else
I := Count - AItemCountDelta;
if Count > MaxCount then
FItems.Count := MaxCount;
for I := I to I + Abs(AItemCountDelta) - 1 do
if I < Count then
begin
FItems[I] := CreateRecordViewInfo(I);
Items[I].MainCalculate(GetItemLeftBound(I), GetItemTopBound(I));
end;
end;
procedure CheckForAppearedItems;
var
I: Integer;
begin
for I := 0 to Count - 1 do
if not Items[I].Calculated then
Items[I].MainCalculate(GetItemLeftBound(I), GetItemTopBound(I));
end;
begin
FItemsOffset := 0;
if AItemCountDelta = 0 then Exit;
AMoveCount := Count - Abs(AItemCountDelta);
if AItemCountDelta > 0 then
FItemsOffset := GetItemsOffset(AItemCountDelta);
DeleteItems;
OffsetItemsList;
if AItemCountDelta > 0 then OffsetItems;
CreateItems;
if AItemCountDelta < 0 then
begin
FItemsOffset := GetItemsOffset(AItemCountDelta);
OffsetItems;
end;
CalculateVisibleCount;
CheckForAppearedItems;
end;
procedure TcxCustomGridRecordsViewInfo.Offset(DX, DY: Integer);
begin
OffsetRect(FBounds, DX, DY);
OffsetRect(FContentBounds, DX, DY);
end;
procedure TcxCustomGridRecordsViewInfo.Paint;
begin
with GetPainterClass.Create(Canvas, Self) do
try
MainPaint;
finally
Free;
end;
end;
{ TcxNavigatorSiteViewInfo }
destructor TcxNavigatorSiteViewInfo.Destroy;
begin
if State <> gcsNone then
MouseLeave;
inherited;
end;
function TcxNavigatorSiteViewInfo.GetGridViewInfo: TcxCustomGridTableViewInfo;
begin
Result := TcxCustomGridTableViewInfo(inherited GridViewInfo);
end;
function TcxNavigatorSiteViewInfo.GetNavigatorViewInfo: TcxNavigatorViewInfo;
begin
Result := GridViewInfo.NavigatorViewInfo;
end;
function TcxNavigatorSiteViewInfo.CalculateHeight: Integer;
begin
Result := GridViewInfo.Site.HScrollBar.Height;
end;
function TcxNavigatorSiteViewInfo.CalculateWidth: Integer;
begin
with GridViewInfo do
Result := NavigatorSize.X + NavigatorOffset;
end;
function TcxNavigatorSiteViewInfo.GetHeight: Integer;
begin
Result := CalculateHeight;
end;
function TcxNavigatorSiteViewInfo.GetHitTestClass: TcxCustomGridHitTestClass;
begin
Result := TcxGridNavigatorHitTest;
end;
function TcxNavigatorSiteViewInfo.GetHotTrack: Boolean;
begin
Result := True;
end;
function TcxNavigatorSiteViewInfo.GetPainterClass: TcxCustomGridCellPainterClass;
begin
Result := TcxNavigatorSitePainter;
end;
function TcxNavigatorSiteViewInfo.GetVisible: Boolean;
begin
Result := GridViewInfo.GridView.OptionsView.Navigator;
end;
procedure TcxNavigatorSiteViewInfo.MouseLeave;
begin
inherited;
NavigatorViewInfo.MouseMove(-1, -1);
end;
procedure TcxNavigatorSiteViewInfo.GetViewParams(var AParams: TcxViewParams);
begin
AParams.Color := LookAndFeelPainter.DefaultGridDetailsSiteColor;
end;
function TcxNavigatorSiteViewInfo.GetWidth: Integer;
begin
Result := CalculateWidth;
end;
function TcxNavigatorSiteViewInfo.MouseDown(AHitTest: TcxCustomGridHitTest;
AButton: TMouseButton; AShift: TShiftState): Boolean;
begin
with AHitTest.Pos do
NavigatorViewInfo.MouseDown(X, Y);
Result := True;
end;
function TcxNavigatorSiteViewInfo.MouseMove(AHitTest: TcxCustomGridHitTest;
AShift: TShiftState): Boolean;
begin
inherited MouseMove(AHitTest, AShift);
with AHitTest.Pos do
NavigatorViewInfo.MouseMove(X, Y);
Result := True;
end;
function TcxNavigatorSiteViewInfo.MouseUp(AHitTest: TcxCustomGridHitTest;
AButton: TMouseButton; AShift: TShiftState): Boolean;
begin
with AHitTest.Pos do
NavigatorViewInfo.MouseUp(X, Y);
Result := True;
end;
{ TcxCustomGridTableViewInfo }
constructor TcxCustomGridTableViewInfo.Create(AGridView: TcxCustomGridView);
begin
FParts := TList.Create;
inherited;
FCalculateDown := True;
FFirstRecordIndex := RecordIndexNone;
end;
destructor TcxCustomGridTableViewInfo.Destroy;
begin
FreeAndNil(FParts);//.Free;
inherited;
end;
function TcxCustomGridTableViewInfo.GetController: TcxCustomGridTableController;
begin
Result := TcxCustomGridTableController(inherited Controller);
end;
function TcxCustomGridTableViewInfo.GetExpandButtonSize: Integer;
begin
Result := LookAndFeelPainter.ExpandButtonSize;
end;
function TcxCustomGridTableViewInfo.GetFirstRecordIndex: Integer;
begin
if FirstRecordIndexAssigned then
Result := FFirstRecordIndex
else
Result := Controller.TopRecordIndex;
end;
function TcxCustomGridTableViewInfo.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
function TcxCustomGridTableViewInfo.GetPart(Index: Integer): TcxCustomGridPartViewInfo;
begin
Result := TcxCustomGridPartViewInfo(FParts[Index]);
end;
function TcxCustomGridTableViewInfo.GetPartCount: Integer;
begin
Result := FParts.Count;
end;
function TcxCustomGridTableViewInfo.GetPartsBottomHeight: Integer;
begin
Result := GetPartsCustomHeight(gpaBottom);
end;
function TcxCustomGridTableViewInfo.GetPartsCustomHeight(AAlignment: TcxGridPartAlignment): Integer;
var
I: Integer;
begin
Result := 0;
for I := 0 to PartCount - 1 do
with Parts[I] do
if Alignment = AAlignment then Inc(Result, Height);
end;
function TcxCustomGridTableViewInfo.GetPartsTopHeight: Integer;
begin
Result := GetPartsCustomHeight(gpaTop);
end;
function TcxCustomGridTableViewInfo.GetScrollableAreaWidth: Integer;
begin
with ScrollableAreaBoundsHorz do
Result := Right - Left;
end;
function TcxCustomGridTableViewInfo.GetViewData: TcxCustomGridTableViewData;
begin
Result := TcxCustomGridTableViewData(inherited ViewData);
end;
function TcxCustomGridTableViewInfo.GetVisibleRecordCount: Integer;
begin
Result := FRecordsViewInfo.VisibleCount;
end;
procedure TcxCustomGridTableViewInfo.AddPart(AItem: TcxCustomGridPartViewInfo);
begin
FParts.Add(AItem);
end;
procedure TcxCustomGridTableViewInfo.RemovePart(AItem: TcxCustomGridPartViewInfo);
begin
FParts.Remove(AItem);
end;
function TcxCustomGridTableViewInfo.GetNavigatorBounds: TRect;
begin
Result := GetNavigatorSiteBounds;
Result.Right := Result.Left + NavigatorSize.X;
end;
function TcxCustomGridTableViewInfo.GetNavigatorButtons: TcxCustomNavigatorButtons;
begin
Result := GridView.NavigatorButtons;
end;
function TcxCustomGridTableViewInfo.GetNavigatorCanvas: TCanvas;
begin
Result := Canvas.Canvas;
end;
function TcxCustomGridTableViewInfo.GetNavigatorControl: TWinControl;
begin
Result := Site;
end;
function TcxCustomGridTableViewInfo.GetNavigatorFocused: Boolean;
begin
Result := False;
end;
function TcxCustomGridTableViewInfo.GetNavigatorLookAndFeel: TcxLookAndFeel;
begin
Result := GridView.LookAndFeel;
end;
function TcxCustomGridTableViewInfo.GetNavigatorOwner: TComponent;
begin
Result := GridView;
end;
function TcxCustomGridTableViewInfo.GetNavigatorShowHint: Boolean;
begin
Result := GridView.OptionsBehavior.NavigatorHints;
end;
function TcxCustomGridTableViewInfo.GetNavigatorTabStop: Boolean;
begin
Result := False;
end;
procedure TcxCustomGridTableViewInfo.NavigatorButtonsStateChanged;
begin
FNavigatorViewInfo.UpdateButtonsEnabled;
end;
procedure TcxCustomGridTableViewInfo.NavigatorChanged(AChangeType: TcxNavigatorChangeType);
const
ChangeKinds: array[TcxNavigatorChangeType] of TcxGridViewChangeKind = (vcProperty, vcLayout, vcLayout);
begin
GridView.Changed(ChangeKinds[AChangeType]);
end;
procedure TcxCustomGridTableViewInfo.RefreshNavigator;
var
AHeight, AWidth: Integer;
begin
if GridView.IsPattern or (GridView.Control = nil) then Exit;
FNavigatorViewInfo.MakeIsDirty;
AWidth := FNavigatorSize.X;
AHeight := FNavigatorSize.Y;
FNavigatorViewInfo.CheckSize(AWidth, AHeight);
if (FNavigatorSize.X <> AWidth) or (FNavigatorSize.Y <> AHeight) then
GridView.LayoutChanged
else
GridView.ViewChanged;
end;
procedure TcxCustomGridTableViewInfo.CreateViewInfos;
begin
FFilterViewInfo := GetFilterViewInfoClass.Create(Self);
inherited;
FNavigatorSiteViewInfo := GetNavigatorSiteViewInfoClass.Create(Self);
if FNavigatorViewInfo = nil then
FNavigatorViewInfo := GetNavigatorViewInfoClass.Create(Self);
FRecordsViewInfo := GetRecordsViewInfoClass.Create(Self);
end;
procedure TcxCustomGridTableViewInfo.DestroyViewInfos(AIsRecreating: Boolean);
begin
FreeAndNil(FRecordsViewInfo);
FNavigatorSiteViewInfo.Free;
FNavigatorSiteViewInfo := nil;
if not AIsRecreating then
FreeAndNil(FNavigatorViewInfo);
inherited;
FreeAndNil(FFilterViewInfo);
end;
procedure TcxCustomGridTableViewInfo.AdjustClientBounds(var ABounds: TRect);
begin
inherited;
if CalculateDown and NavigatorSiteViewInfo.Visible and not Site.HScrollBarVisible then
Dec(ABounds.Bottom, NavigatorSiteViewInfo.Height);
end;
procedure TcxCustomGridTableViewInfo.AfterCalculating;
begin
inherited;
if Visible then Controller.PostCheckEdit;
end;
procedure TcxCustomGridTableViewInfo.AfterOffset;
begin
FRecordsViewInfo.AfterOffset;
end;
procedure TcxCustomGridTableViewInfo.BeforeOffset;
begin
FRecordsViewInfo.BeforeOffset;
end;
procedure TcxCustomGridTableViewInfo.Calculate;
var
ANavigatorHeight, ANavigatorWidth: Integer;
begin
FRecordsViewInfo.MainCalculate;
inherited;
if FNavigatorSiteViewInfo.Visible then
begin
ANavigatorWidth := 0;
with GetNavigatorSiteBounds do
ANavigatorHeight := Bottom - Top;
FNavigatorViewInfo.CheckSize(ANavigatorWidth, ANavigatorHeight);
FNavigatorSize := Point(ANavigatorWidth, ANavigatorHeight);
FNavigatorSiteViewInfo.Calculate(GetNavigatorSiteBounds);
FNavigatorViewInfo.Calculate;
end;
end;
function TcxCustomGridTableViewInfo.CalculateClientBounds: TRect;
begin
Result := inherited CalculateClientBounds;
Inc(Result.Top, PartsTopHeight);
Dec(Result.Bottom, PartsBottomHeight);
end;
procedure TcxCustomGridTableViewInfo.CalculateHeight(const AMaxSize: TPoint; var AHeight: Integer;
var AFullyVisible: Boolean);
begin
if NavigatorSiteViewInfo.Visible and not Site.HScrollBarVisible then
Inc(AHeight, NavigatorSiteViewInfo.Height);
inherited;
end;
function TcxCustomGridTableViewInfo.CalculatePartBounds(APart: TcxCustomGridPartViewInfo): TRect;
var
I: Integer;
begin
Result := ClientBounds;
if APart.IsAutoWidth then
begin
Result.Left := Bounds.Left;
Result.Right := Bounds.Right;
end
else
Result.Right := Result.Left + APart.CalculateWidth;
for I := PartCount - 1 downto APart.Index do
case Parts[I].Alignment of
gpaTop:
Dec(Result.Top, Parts[I].Height);
gpaBottom:
Inc(Result.Bottom, Parts[I].Height);
end;
case APart.Alignment of
gpaTop:
Result.Bottom := Result.Top + APart.Height;
gpaBottom:
Result.Top := Result.Bottom - APart.Height;
end;
end;
function TcxCustomGridTableViewInfo.CalculateVisibleEqualHeightRecordCount: Integer;
begin
Result := -1;
end;
procedure TcxCustomGridTableViewInfo.ControlFocusChanged;
begin
inherited;
RecordsViewInfo.ControlFocusChanged;
end;
function TcxCustomGridTableViewInfo.DoGetHitTest(const P: TPoint): TcxCustomGridHitTest;
var
I: Integer;
begin
if PtInRect(Site.ClientBounds, P) then
begin
for I := 0 to PartCount - 1 do
if Parts[I].Visible then
begin
Result := Parts[I].GetHitTest(P);
if Result <> nil then Exit;
end;
Result := RecordsViewInfo.GetHitTest(P);
end
else
Result := FNavigatorSiteViewInfo.GetHitTest(P);
if Result = nil then
Result := inherited DoGetHitTest(P);
end;
function TcxCustomGridTableViewInfo.GetDefaultGridModeBufferCount: Integer;
begin
Result := 0;
end;
procedure TcxCustomGridTableViewInfo.GetHScrollBarBounds(var ABounds: TRect);
begin
inherited;
if FNavigatorSiteViewInfo.Visible then
Inc(ABounds.Left, FNavigatorSiteViewInfo.Width);
end;
function TcxCustomGridTableViewInfo.GetFilterViewInfoClass: TcxGridFilterViewInfoClass;
begin
Result := TcxGridFilterViewInfo;
end;
function TcxCustomGridTableViewInfo.GetIsInternalUse: Boolean;
begin
Result := inherited GetIsInternalUse or FirstRecordIndexAssigned;
end;
function TcxCustomGridTableViewInfo.GetNavigatorOffset: Integer;
begin
Result := GridView.OptionsView.NavigatorOffset;
end;
function TcxCustomGridTableViewInfo.GetNavigatorSiteBounds: TRect;
begin
if Site.HScrollBarVisible then
begin
Result := TcxControlAccess(Site).GetHScrollBarBounds;
with Result do
begin
Right := Left;
Left := Right - FNavigatorSiteViewInfo.Width;
end;
end
else
begin
Result := Site.ClientBounds;
if Site.VScrollBarVisible then
Inc(Result.Right, Site.VScrollBar.Width);
Result.Top := Result.Bottom;
Inc(Result.Bottom, NavigatorSiteViewInfo.Height);
end;
end;
function TcxCustomGridTableViewInfo.GetNavigatorSiteViewInfoClass: TcxNavigatorSiteViewInfoClass;
begin
Result := TcxNavigatorSiteViewInfo;
end;
function TcxCustomGridTableViewInfo.GetNavigatorViewInfoClass: TcxNavigatorViewInfoClass;
begin
Result := TcxNavigatorViewInfo;
end;
function TcxCustomGridTableViewInfo.GetNoDataInfoText: string;
begin
Result := GridView.OptionsView.GetNoDataToDisplayInfoText;
end;
function TcxCustomGridTableViewInfo.GetNoDataInfoTextAreaBounds: TRect;
begin
if IsRectEmpty(RecordsViewInfo.ContentBounds) then
Result := ClientBounds
else
IntersectRect(Result, ClientBounds, RecordsViewInfo.ContentBounds);
end;
procedure TcxCustomGridTableViewInfo.GetNoDataInfoTextParams(out AParams: TcxViewParams);
begin
GridView.Styles.GetViewParams(vsBackground, nil, nil, AParams);
end;
function TcxCustomGridTableViewInfo.GetNoDataInfoTextAreaVisible: Boolean;
begin
Result := RecordsViewInfo.IsEmpty and (NoDataInfoText <> '');
end;
function TcxCustomGridTableViewInfo.GetNonRecordsAreaHeight(ACheckScrollBar: Boolean): Integer;
begin
Result := PartsTopHeight + PartsBottomHeight;
if ACheckScrollBar then
begin
AddScrollBarHeight(Result);
if NavigatorSiteViewInfo.Visible and not Site.HScrollBarVisible then
Inc(Result, NavigatorSiteViewInfo.Height);
end;
end;
function TcxCustomGridTableViewInfo.GetScrollableAreaBounds: TRect;
begin
Result := ClientBounds;
end;
function TcxCustomGridTableViewInfo.GetScrollableAreaBoundsForEdit: TRect;
begin
Result := ScrollableAreaBounds;
end;
function TcxCustomGridTableViewInfo.GetScrollableAreaBoundsHorz: TRect;
begin
Result := ScrollableAreaBounds;
end;
function TcxCustomGridTableViewInfo.GetScrollableAreaBoundsVert: TRect;
begin
Result := ScrollableAreaBounds;
end;
function TcxCustomGridTableViewInfo.FirstRecordIndexAssigned: Boolean;
begin
Result := FFirstRecordIndex <> RecordIndexNone;
end;
procedure TcxCustomGridTableViewInfo.Offset(ARecordCountDelta: Integer);
begin
RecordsViewInfo.Offset(ARecordCountDelta);
end;
procedure TcxCustomGridTableViewInfo.Offset(DX, DY: Integer);
begin
RecordsViewInfo.Offset(DX, DY);
end;
procedure TcxCustomGridTableViewInfo.VisibilityChanged(AVisible: Boolean);
begin
RecordsViewInfo.VisibilityChanged(AVisible);
inherited; // should be here for correct hiding (focus)
end;
function TcxCustomGridTableViewInfo.CanOffset(ARecordCountDelta, DX, DY: Integer): Boolean;
begin
Result := True;
end;
function TcxCustomGridTableViewInfo.CanOffsetView(ARecordCountDelta: Integer): Boolean;
begin
Result := RecordsViewInfo.CanOffset(ARecordCountDelta);
end;
procedure TcxCustomGridTableViewInfo.DoOffset(ARecordCountDelta, DX, DY: Integer);
begin
if CanOffset(ARecordCountDelta, DX, DY) then
begin
Controller.BeforeOffset;
BeforeOffset;
if ARecordCountDelta <> 0 then
Offset(ARecordCountDelta)
else
Offset(DX, DY);
AfterOffset;
Controller.AfterOffset;
end
else
Recalculate;
end;
function TcxCustomGridTableViewInfo.GetNearestPopupHeight(AHeight: Integer;
AAdditionalRecord: Boolean = False): Integer;
begin
Result := AHeight;
end;
function TcxCustomGridTableViewInfo.GetPopupHeight(ADropDownRecordCount: Integer): Integer;
begin
Result := 0;
end;
{ TcxCustomGridTableViewInfoCacheItem }
function TcxCustomGridTableViewInfoCacheItem.GetGridRecord: TcxCustomGridRecord;
begin
Result := TcxCustomGridTableViewInfoCache(Owner).ViewData.Records[Index];
end;
procedure TcxCustomGridTableViewInfoCacheItem.SetHeight(Value: Integer);
begin
FHeight := Value;
FIsHeightAssigned := True;
end;
procedure TcxCustomGridTableViewInfoCacheItem.UnassignValues(AKeepMaster: Boolean);
begin
inherited;
FIsHeightAssigned := False;
end;
{ TcxCustomGridTableViewInfoCache }
function TcxCustomGridTableViewInfoCache.GetViewData: TcxCustomGridTableViewData;
begin
Result := TcxCustomGridTableViewData(inherited ViewData);
end;
function TcxCustomGridTableViewInfoCache.GetItemClass(Index: Integer): TcxCustomGridViewInfoCacheItemClass;
begin
Result := ViewData.Records[Index].GetViewInfoCacheItemClass;
end;
{ TcxCustomGridTableItemCustomOptions }
constructor TcxCustomGridTableItemCustomOptions.Create(AItem: TcxCustomGridTableItem);
begin
inherited Create;
FItem := AItem;
end;
function TcxCustomGridTableItemCustomOptions.GetGridView: TcxCustomGridTableView;
begin
Result := FItem.GridView;
end;
procedure TcxCustomGridTableItemCustomOptions.Changed(AChange: TcxGridTableItemChange = ticLayout);
begin
FItem.Changed(AChange);
end;
procedure TcxCustomGridTableItemCustomOptions.Assign(Source: TPersistent);
begin
if not (Source is TcxCustomGridTableItemCustomOptions) then
inherited;
end;
{ TcxCustomGridTableItemOptions }
constructor TcxCustomGridTableItemOptions.Create(AItem: TcxCustomGridTableItem);
begin
inherited;
FEditing := True;
FFiltering := True;
FFilteringFilteredItemsList := True;
FFilteringMRUItemsList := True;
FFilteringPopup := True;
FFilteringPopupMultiSelect := True;
FFocusing := True;
FGrouping := True;
FIgnoreTimeForFiltering := True;
FIncSearch := True;
FMoving := True;
FShowCaption := True;
FSorting := True;
end;
procedure TcxCustomGridTableItemOptions.SetEditing(Value: Boolean);
begin
if FEditing <> Value then
begin
FEditing := Value;
if not FEditing then FItem.Editing := False;
Changed(ticLayout);
end;
end;
procedure TcxCustomGridTableItemOptions.SetFiltering(Value: Boolean);
begin
if FFiltering <> Value then
begin
FFiltering := Value;
GridView.RefreshFilterableItemsList;
Changed;
end;
end;
procedure TcxCustomGridTableItemOptions.SetFilteringFilteredItemsList(Value: Boolean);
begin
if FFilteringFilteredItemsList <> Value then
begin
FFilteringFilteredItemsList := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItemOptions.SetFilteringMRUItemsList(Value: Boolean);
begin
if FFilteringMRUItemsList <> Value then
begin
FFilteringMRUItemsList := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItemOptions.SetFilteringPopup(Value: Boolean);
begin
if FFilteringPopup <> Value then
begin
FFilteringPopup := Value;
Changed(ticSize);
end;
end;
procedure TcxCustomGridTableItemOptions.SetFilteringPopupMultiSelect(Value: Boolean);
begin
if FFilteringPopupMultiSelect <> Value then
begin
FFilteringPopupMultiSelect := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItemOptions.SetFocusing(Value: Boolean);
begin
if FFocusing <> Value then
begin
FFocusing := Value;
if not FFocusing then Item.Focused := False;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItemOptions.SetGrouping(Value: Boolean);
begin
if FGrouping <> Value then
begin
FGrouping := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItemOptions.SetIgnoreTimeForFiltering(Value: Boolean);
begin
if FIgnoreTimeForFiltering <> Value then
begin
FIgnoreTimeForFiltering := Value;
GridView.DataController.Refresh;
end;
end;
procedure TcxCustomGridTableItemOptions.SetIncSearch(Value: Boolean);
begin
if FIncSearch <> Value then
begin
if not Value and Item.IncSearching then
GridView.Controller.CancelIncSearching;
FIncSearch := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItemOptions.SetMoving(Value: Boolean);
begin
if FMoving <> Value then
begin
FMoving := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItemOptions.SetShowCaption(Value: Boolean);
begin
if FShowCaption <> Value then
begin
BeforeShowCaptionChange;
FShowCaption := Value;
Changed(ticSize);
end;
end;
procedure TcxCustomGridTableItemOptions.SetShowEditButtons(Value: TcxGridItemShowEditButtons);
begin
if FShowEditButtons <> Value then
begin
FShowEditButtons := Value;
Changed(ticSize);
end;
end;
procedure TcxCustomGridTableItemOptions.SetSortByDisplayText(Value: TcxGridItemSortByDisplayText);
begin
if FSortByDisplayText <> Value then
begin
FSortByDisplayText := Value;
GridView.DataController.SortByDisplayTextChanged;
end;
end;
procedure TcxCustomGridTableItemOptions.SetSorting(Value: Boolean);
begin
if FSorting <> Value then
begin
FSorting := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItemOptions.BeforeShowCaptionChange;
begin
end;
procedure TcxCustomGridTableItemOptions.Assign(Source: TPersistent);
begin
if Source is TcxCustomGridTableItemOptions then
with TcxCustomGridTableItemOptions(Source) do
begin
Self.Editing := Editing;
Self.Filtering := Filtering;
Self.FilteringFilteredItemsList := FilteringFilteredItemsList;
Self.FilteringMRUItemsList := FilteringMRUItemsList;
Self.FilteringPopup := FilteringPopup;
Self.FilteringPopupMultiSelect := FilteringPopupMultiSelect;
Self.Focusing := Focusing;
Self.Grouping := Grouping;
Self.IgnoreTimeForFiltering := IgnoreTimeForFiltering;
Self.IncSearch := IncSearch;
Self.Moving := Moving;
Self.ShowCaption := ShowCaption;
Self.ShowEditButtons := ShowEditButtons;
Self.SortByDisplayText := SortByDisplayText;
Self.Sorting := Sorting;
end;
inherited;
end;
{ TcxCustomGridTableItemStyles }
function TcxCustomGridTableItemStyles.GetGridViewValue: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
function TcxCustomGridTableItemStyles.GetItem: TcxCustomGridTableItem;
begin
Result := TcxCustomGridTableItem(GetOwner);
end;
procedure TcxCustomGridTableItemStyles.SetOnGetContentStyle(Value: TcxGridGetCellStyleEvent);
begin
if @FOnGetContentStyle <> @Value then
begin
FOnGetContentStyle := Value;
Item.Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItemStyles.GetDefaultViewParams(Index: Integer; AData: TObject;
out AParams: TcxViewParams);
begin
case Index of
isContent:
GridView.Styles.GetRecordContentParams(TcxCustomGridRecord(AData), Item, AParams);
else
inherited;
end;
end;
function TcxCustomGridTableItemStyles.GetGridView: TcxCustomGridView;
begin
Result := Item.GridView;
end;
procedure TcxCustomGridTableItemStyles.Assign(Source: TPersistent);
begin
inherited;
if Source is TcxCustomGridTableItemStyles then
with TcxCustomGridTableItemStyles(Source) do
begin
Self.Content := Content;
Self.OnGetContentStyle := OnGetContentStyle;
end;
end;
procedure TcxCustomGridTableItemStyles.GetContentParams(ARecord: TcxCustomGridRecord;
out AParams: TcxViewParams);
var
AStyle: TcxStyle;
begin
AStyle := nil;
if (ARecord <> nil) and Assigned(FOnGetContentStyle) then
FOnGetContentStyle(GridView, ARecord, Item, AStyle);
GetViewParams(isContent, ARecord, AStyle, AParams);
end;
{ TcxCustomGridTableItem }
constructor TcxCustomGridTableItem.Create(AOwner: TComponent);
begin
inherited;
FCells := TList.Create;
FIndex := -1;
FMinWidth := cxGridItemDefaultMinWidth;
FVisibleIndex := -1;
FVisibleForCustomization := True;
CreateSubClasses;
end;
destructor TcxCustomGridTableItem.Destroy;
var
I: Integer;
begin
if not GridView.IsDestroying and GridView.IsDesigning then
Controller.DesignController.UnselectObject(Self);
RepositoryItem := nil;
FGridView.RemoveItem(Self);
{if FLastUsedDefaultRepositoryItem <> nil then
ItemRemoved(FLastUsedDefaultRepositoryItem);}
DestroySubClasses;
FreeAndNil(FEditData);
FreeAndNil(FCellStyle);
for I := 0 to CellCount - 1 do Cells[I].FItem := nil;
FCells.Free;
inherited;
end;
function TcxCustomGridTableItem.GetActualMinWidth: Integer;
begin
if HasFixedWidth then
Result := 0
else
Result := FMinWidth;
end;
function TcxCustomGridTableItem.GetCaption: string;
begin
if FIsCaptionAssigned then
Result := FCaption
else
Result := DefaultCaption;
end;
function TcxCustomGridTableItem.GetCell(Index: Integer): TcxGridTableDataCellViewInfo;
begin
Result := TcxGridTableDataCellViewInfo(FCells[Index]);
end;
function TcxCustomGridTableItem.GetCellCount: Integer;
begin
Result := FCells.Count;
end;
function TcxCustomGridTableItem.GetController: TcxCustomGridTableController;
begin
Result := FGridView.Controller;
end;
function TcxCustomGridTableItem.GetDataController: TcxCustomDataController;
begin
Result := FGridView.DataController;
end;
function TcxCustomGridTableItem.GetEditing: Boolean;
begin
Result := Controller.EditingItem = Self;
end;
function TcxCustomGridTableItem.GetEditingProperties: TcxCustomEditProperties;
begin
if Controller.EditingController.IsEditing then
Result := Controller.EditingController.Edit.ActiveProperties
else
Result := GetPropertiesForEdit;
end;
function TcxCustomGridTableItem.GetFilterCaption: string;
begin
Result := GetAlternateCaption;
end;
function TcxCustomGridTableItem.GetFiltered: Boolean;
begin
Result := FDataBinding.Filtered;
end;
function TcxCustomGridTableItem.GetFocused: Boolean;
begin
Result := Controller.FocusedItem = Self;
end;
function TcxCustomGridTableItem.GetGroupIndex: Integer;
begin
Result := DataController.Groups.ItemGroupIndex[Index];
end;
function TcxCustomGridTableItem.GetHeaderAlignmentHorz: TAlignment;
begin
if FIsHeaderAlignmentHorzAssigned then
Result := FHeaderAlignmentHorz
else
Result := DefaultHeaderAlignmentHorz;
end;
function TcxCustomGridTableItem.GetHeaderAlignmentVert: TcxAlignmentVert;
begin
if FIsHeaderAlignmentVertAssigned then
Result := FHeaderAlignmentVert
else
Result := DefaultHeaderAlignmentVert;
end;
function TcxCustomGridTableItem.GetHidden: Boolean;
begin
Result := not VisibleForCustomization;
end;
function TcxCustomGridTableItem.GetIsLoading: Boolean;
begin
Result := not FIgnoreLoadingStatus and
((csLoading in ComponentState) or FGridView.IsLoading);
end;
function TcxCustomGridTableItem.GetIncSearching: Boolean;
begin
Result := Controller.IncSearchingItem = Self;
end;
function TcxCustomGridTableItem.GetIsDestroying: Boolean;
begin
Result := csDestroying in ComponentState;
end;
function TcxCustomGridTableItem.GetIsFirst: Boolean;
begin
Result := VisibleIndex = 0;
end;
function TcxCustomGridTableItem.GetIsLast: Boolean;
begin
Result := VisibleIndex = FGridView.VisibleItemCount - 1;
end;
function TcxCustomGridTableItem.GetIsReading: Boolean;
begin
Result := csReading in ComponentState;
end;
function TcxCustomGridTableItem.GetIsUpdating: Boolean;
begin
Result := csUpdating in ComponentState;
end;
function TcxCustomGridTableItem.GetMinWidth: Integer;
begin
if HasFixedWidth then
Result := Width
else
Result := FMinWidth;
end;
function TcxCustomGridTableItem.GetPropertiesClassName: string;
begin
if FProperties = nil then
Result := ''
else
Result := FProperties.ClassName;
end;
function TcxCustomGridTableItem.GetSortIndex: Integer;
begin
Result := DataController.GetItemSortingIndex(Index);
end;
function TcxCustomGridTableItem.GetSortOrder: TcxGridSortOrder;
begin
Result := DataController.GetItemSortOrder(Index);
end;
function TcxCustomGridTableItem.GetTag: TcxTag;
begin
Result := inherited Tag;
end;
function TcxCustomGridTableItem.GetViewData: TcxCustomGridTableViewData;
begin
Result := FGridView.ViewData;
end;
function TcxCustomGridTableItem.GetWidth: Integer;
begin
if FIsWidthAssigned then
Result := FWidth
else
Result := DefaultWidth;
end;
procedure TcxCustomGridTableItem.SetAlternateCaption(const Value: string);
begin
if FAlternateCaption <> Value then
begin
FAlternateCaption := Value;
CaptionChanged;
end;
end;
procedure TcxCustomGridTableItem.SetBestFitMaxWidth(Value: Integer);
begin
if Value < 0 then Value := 0;
if FBestFitMaxWidth <> Value then
begin
FBestFitMaxWidth := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItem.SetCaption(const Value: string);
begin
if Caption <> Value then
begin
FCaption := Value;
FIsCaptionAssigned := True;
CaptionChanged;
end;
end;
procedure TcxCustomGridTableItem.SetDataBinding(Value: TcxGridItemDataBinding);
begin
FDataBinding.Assign(Value);
end;
procedure TcxCustomGridTableItem.SetDateTimeGrouping(Value: TcxGridDateTimeGrouping);
begin
if FDateTimeGrouping <> Value then
begin
FDateTimeGrouping := Value;
DateTimeGroupingChanged;
end;
end;
procedure TcxCustomGridTableItem.SetEditing(Value: Boolean);
begin
if Value then
Controller.EditingItem := Self
else
if Editing then
Controller.EditingItem := nil;
end;
procedure TcxCustomGridTableItem.SetFiltered(Value: Boolean);
begin
FDataBinding.Filtered := Value;
end;
procedure TcxCustomGridTableItem.SetFocused(Value: Boolean);
begin
if Value then
Controller.FocusedItem := Self
else
if Focused then
if not Controller.FocusNextItem(VisibleIndex, True, True, False) then
Controller.FocusedItem := nil;
end;
procedure TcxCustomGridTableItem.SetGroupIndex(Value: Integer);
begin
if FGridView.IsAssigningItems and (Value <> -1) then
FGridView.AssigningGroupedItems[Value] := Self
else
ChangeGroupIndex(Value);
end;
procedure TcxCustomGridTableItem.SetHeaderAlignmentHorz(Value: TAlignment);
begin
if HeaderAlignmentHorz <> Value then
begin
FHeaderAlignmentHorz := Value;
FIsHeaderAlignmentHorzAssigned := True;
Changed(ticLayout);
end;
end;
procedure TcxCustomGridTableItem.SetHeaderAlignmentVert(Value: TcxAlignmentVert);
begin
if HeaderAlignmentVert <> Value then
begin
FHeaderAlignmentVert := Value;
FIsHeaderAlignmentVertAssigned := True;
Changed(ticLayout);
end;
end;
procedure TcxCustomGridTableItem.SetHidden(Value: Boolean);
begin
VisibleForCustomization := not Value;
end;
procedure TcxCustomGridTableItem.SetIndex(Value: Integer);
begin
if FGridView.IsRestoring then
FGridView.RestoringItems[Value] := Self
else
FGridView.ChangeItemIndex(Self, Value);
end;
procedure TcxCustomGridTableItem.SetMinWidth(Value: Integer);
begin
if Value < 0 then Value := 0;
if FMinWidth <> Value then
begin
FMinWidth := Value;
if IsLoading then Exit;
if Width < FMinWidth then
Width := FMinWidth
else
Changed(ticSize);
end;
end;
procedure TcxCustomGridTableItem.SetOnCustomDrawCell(Value: TcxGridTableDataCellCustomDrawEvent);
begin
if @FOnCustomDrawCell <> @Value then
begin
FOnCustomDrawCell := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItem.SetOnGetCellHint(Value: TcxGridGetCellHintEvent);
begin
if @FOnGetCellHint <> @Value then
begin
FOnGetCellHint := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItem.SetOnGetDataText(Value: TcxGridGetDataTextEvent);
begin
if @FOnGetDataText <> @Value then
begin
FOnGetDataText := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItem.SetOnGetDisplayText(Value: TcxGridGetDisplayTextEvent);
begin
if @FOnGetDisplayText <> @Value then
begin
FOnGetDisplayText := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItem.SetOnGetFilterDisplayText(Value: TcxGridGetFilterDisplayTextEvent);
begin
if @FOnGetFilterDisplayText <> @Value then
begin
FOnGetFilterDisplayText := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItem.SetOnGetFilterValues(Value: TcxGridGetFilterValuesEvent);
begin
if @FOnGetFilterValues <> @Value then
begin
FOnGetFilterValues := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItem.SetOnGetProperties(Value: TcxGridGetPropertiesEvent);
begin
if @FOnGetProperties <> @Value then
begin
FOnGetProperties := Value;
Changed(ticLayout);
end;
end;
procedure TcxCustomGridTableItem.SetOnGetPropertiesForEdit(Value: TcxGridGetPropertiesEvent);
begin
if @FOnGetPropertiesForEdit <> @Value then
begin
FOnGetPropertiesForEdit := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItem.SetOnGetStoredProperties(Value: TcxGridTableItemGetStoredPropertiesEvent);
begin
if @FOnGetStoredProperties <> @Value then
begin
FOnGetStoredProperties := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItem.SetOnGetStoredPropertyValue(Value: TcxGridTableItemGetStoredPropertyValueEvent);
begin
if @FOnGetStoredPropertyValue <> @Value then
begin
FOnGetStoredPropertyValue := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItem.SetOnInitFilteringDateRanges(Value: TcxGridInitDateRangesEvent);
begin
if @FOnInitFilteringDateRanges <> @Value then
begin
FOnInitFilteringDateRanges := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItem.SetOnInitGroupingDateRanges(Value: TcxGridInitDateRangesEvent);
begin
if @FOnInitGroupingDateRanges <> @Value then
begin
FOnInitGroupingDateRanges := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItem.SetOnSetStoredPropertyValue(Value: TcxGridTableItemSetStoredPropertyValueEvent);
begin
if @FOnSetStoredPropertyValue <> @Value then
begin
FOnSetStoredPropertyValue := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItem.SetOnUserFiltering(Value: TcxGridUserFilteringEvent);
begin
if @FOnUserFiltering <> @Value then
begin
FOnUserFiltering := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItem.SetOptions(Value: TcxCustomGridTableItemOptions);
begin
FOptions.Assign(Value);
end;
procedure TcxCustomGridTableItem.SetProperties(Value: TcxCustomEditProperties);
begin
if (FProperties <> nil) and (Value <> nil) then FProperties.Assign(Value);
end;
procedure TcxCustomGridTableItem.SetPropertiesClass(Value: TcxCustomEditPropertiesClass);
begin
if FPropertiesClass <> Value then
begin
if FProperties <> nil then
Controller.EditingController.RemoveEdit(FProperties);
FPropertiesClass := Value;
RecreateProperties;
PropertiesValueChanged;
PropertiesChanged;
end;
end;
procedure TcxCustomGridTableItem.SetPropertiesClassName(const Value: string);
begin
PropertiesClass := TcxCustomEditPropertiesClass(GetRegisteredEditProperties.FindByClassName(Value));
end;
procedure TcxCustomGridTableItem.SetRepositoryItem(Value: TcxEditRepositoryItem);
begin
if FRepositoryItem <> Value then
begin
if FRepositoryItem <> nil then
begin
FRepositoryItem.RemoveListener(Self);
Controller.EditingController.RemoveEdit(FRepositoryItem.Properties);
end;
FRepositoryItem := Value;
if FRepositoryItem <> nil then
FRepositoryItem.AddListener(Self);
PropertiesValueChanged;
PropertiesChanged;
end;
end;
procedure TcxCustomGridTableItem.SetSortIndex(Value: Integer);
begin
if FGridView.IsAssigningItems and (Value <> -1) then
FGridView.AssigningSortedItems[Value] := Self
else
ChangeSortIndex(Value);
end;
procedure TcxCustomGridTableItem.SetSortOrder(Value: TcxGridSortOrder);
begin
if SortOrder <> Value then
begin
ShowHourglassCursor;
try
DataController.ChangeSorting(Index, Value);
finally
HideHourglassCursor;
end;
end;
end;
procedure TcxCustomGridTableItem.SetStyles(Value: TcxCustomGridTableItemStyles);
begin
FStyles.Assign(Value);
end;
procedure TcxCustomGridTableItem.SetTag(Value: TcxTag);
begin
if Tag <> Value then
begin
inherited Tag := Value;
Changed(ticProperty);
end;
end;
procedure TcxCustomGridTableItem.SetVisible(Value: Boolean);
begin
if Visible <> Value then
begin
GridView.SaveItemVisibles;
FVisible := Value;
VisibleChanged;
GridView.CheckItemVisibles;
GridView.RefreshCustomizationForm;
end;
end;
procedure TcxCustomGridTableItem.SetVisibleForCustomization(Value: Boolean);
begin
if VisibleForCustomization <> Value then
begin
FVisibleForCustomization := Value;
VisibleForCustomizationChanged;
end;
end;
procedure TcxCustomGridTableItem.SetWidth(Value: Integer);
begin
CheckWidthValue(Value);
if IsLoading or (Width <> Value) then
begin
FWidth := Value;
FIsWidthAssigned := True;
Changed(ticSize);
end;
end;
procedure TcxCustomGridTableItem.ReadHidden(Reader: TReader);
begin
Hidden := Reader.ReadBoolean;
end;
procedure TcxCustomGridTableItem.ReadIsCaptionAssigned(Reader: TReader);
begin
FIsCaptionAssigned := Reader.ReadBoolean;
end;
procedure TcxCustomGridTableItem.WriteIsCaptionAssigned(Writer: TWriter);
begin
Writer.WriteBoolean(FIsCaptionAssigned);
end;
function TcxCustomGridTableItem.IsCaptionStored: Boolean;
begin
Result := FIsCaptionAssigned and (FCaption <> DefaultCaption);
end;
function TcxCustomGridTableItem.IsSortOrderStored: Boolean;
begin
Result := (SortOrder <> soNone) and (SortIndex <> -1);
end;
function TcxCustomGridTableItem.IsTagStored: Boolean;
begin
Result := Tag <> 0;
end;
function TcxCustomGridTableItem.IsWidthStored: Boolean;
begin
Result := FIsWidthAssigned //and (FWidth <> DefaultWidth);
end;
function TcxCustomGridTableItem.GetDataBindingClass: TcxGridItemDataBindingClass;
begin
Result := FGridView.GetItemDataBindingClass;
end;
procedure TcxCustomGridTableItem.CreateProperties;
begin
if FPropertiesClass <> nil then
begin
FProperties := FPropertiesClass.Create(Self);
FProperties.OnPropertiesChanged := PropertiesChangedHandler;
end;
end;
procedure TcxCustomGridTableItem.DestroyProperties;
begin
FreeAndNil(FProperties);
end;
procedure TcxCustomGridTableItem.RecreateProperties;
begin
DestroyProperties;
CreateProperties;
end;
procedure TcxCustomGridTableItem.DefineProperties(Filer: TFiler);
begin
inherited;
Filer.DefineProperty('Hidden', ReadHidden, nil, True);
Filer.DefineProperty('IsCaptionAssigned', ReadIsCaptionAssigned, WriteIsCaptionAssigned,
FIsCaptionAssigned and (Caption = ''));
end;
procedure TcxCustomGridTableItem.SetParentComponent(AParent: TComponent);
begin
if AParent is TcxCustomGridTableView then
TcxCustomGridTableView(AParent).AddItem(Self);
end;
procedure TcxCustomGridTableItem.ItemRemoved(Sender: TcxEditRepositoryItem);
begin
if Sender = FLastUsedDefaultRepositoryItem then
PropertiesValueChanged
else
RepositoryItem := nil;
end;
procedure TcxCustomGridTableItem.RepositoryItemPropertiesChanged(Sender: TcxEditRepositoryItem);
begin
if not GridView.IsPattern then PropertiesChanged;
end;
function TcxCustomGridTableItem.GetObjectName: string;
begin
if GridView.IsStoringNameMode then
Result := IntToStr(ID)
else
Result := Name;
end;
function TcxCustomGridTableItem.GetStoredProperties(AProperties: TStrings): Boolean;
begin
with AProperties do
begin
Add('AlignmentHorz');
Add('Index');
Add('Visible');
Add('SortOrder');
Add('SortIndex');
Add('WasVisibleBeforeGrouping');
end;
if Assigned(FOnGetStoredProperties) then
FOnGetStoredProperties(Self, AProperties);
Result := True;
end;
procedure TcxCustomGridTableItem.GetPropertyValue(const AName: string; var AValue: Variant);
begin
if AName = 'AlignmentHorz' then
AValue := Variant(GetProperties.Alignment.Horz)
else
if AName = 'Index' then
AValue := Index
else
if AName = 'Visible' then
AValue := Visible
else
if AName = 'SortOrder' then
AValue := Variant(SortOrder)
else
if AName = 'SortIndex' then
AValue := SortIndex
else
if AName = 'WasVisibleBeforeGrouping' then
AValue := WasVisibleBeforeGrouping
else
if Assigned(FOnGetStoredPropertyValue) then
FOnGetStoredPropertyValue(Self, AName, AValue);
end;
procedure TcxCustomGridTableItem.SetPropertyValue(const AName: string; const AValue: Variant);
begin
if AName = 'AlignmentHorz' then
if GetProperties.Alignment.Horz <> TAlignment((AValue)) then
begin
if (FRepositoryItem = nil) and (FProperties = nil) then
PropertiesClass := TcxCustomEditPropertiesClass(GetProperties.ClassType);
GetProperties.Alignment.Horz := TAlignment((AValue));
end
else
else
if AName = 'Index' then
Index := AValue
else
if AName = 'Visible' then
Visible := AValue
else
if AName = 'SortOrder' then
SortOrder := TcxDataSortOrder((AValue))
else
if AName = 'SortIndex' then
SortIndex := AValue
else
if AName = 'WasVisibleBeforeGrouping' then
FWasVisibleBeforeGrouping := AValue
else
if Assigned(FOnSetStoredPropertyValue) then
FOnSetStoredPropertyValue(Self, AName, AValue);
end;
procedure TcxCustomGridTableItem.CreateDataBinding;
begin
FDataBinding := GetDataBindingClass.Create(Self);
with FDataBinding do
ValueTypeClass := GetDefaultValueTypeClass;
end;
procedure TcxCustomGridTableItem.DestroyDataBinding;
begin
FreeAndNil(FDataBinding);
end;
procedure TcxCustomGridTableItem.CreateSubClasses;
begin
FFilteringDateRanges := GetFilteringDateRangesClass.Create;
FGroupingDateRanges := GetGroupingDateRangesClass.Create;
FOptions := GetOptionsClass.Create(Self);
FStyles := GetStylesClass.Create(Self);
end;
procedure TcxCustomGridTableItem.DestroySubClasses;
begin
DestroyProperties;
FreeAndNil(FStyles);
FreeAndNil(FOptions);
FreeAndNil(FGroupingDateRanges);
FreeAndNil(FFilteringDateRanges);
end;
function TcxCustomGridTableItem.GetFilteringDateRangesClass: TcxGridFilteringDateRangesClass;
begin
Result := TcxGridFilteringDateRanges;
end;
function TcxCustomGridTableItem.GetGroupingDateRangesClass: TcxGridGroupingDateRangesClass;
begin
Result := TcxGridGroupingDateRanges;
end;
function TcxCustomGridTableItem.GetOptionsClass: TcxCustomGridTableItemOptionsClass;
begin
Result := TcxCustomGridTableItemOptions;
end;
function TcxCustomGridTableItem.GetStylesClass: TcxCustomGridTableItemStylesClass;
begin
Result := TcxCustomGridTableItemStyles;
end;
function TcxCustomGridTableItem.IsHeaderAlignmentHorzStored: Boolean;
begin
Result := FIsHeaderAlignmentHorzAssigned and
(FHeaderAlignmentHorz <> DefaultHeaderAlignmentHorz);
end;
function TcxCustomGridTableItem.IsHeaderAlignmentVertStored: Boolean;
begin
Result := FIsHeaderAlignmentVertAssigned and
(FHeaderAlignmentVert <> DefaultHeaderAlignmentVert);
end;
procedure TcxCustomGridTableItem.BestFitApplied(AFireEvents: Boolean);
begin
Controller.DesignerModified;
end;
function TcxCustomGridTableItem.CalculateBestFitWidth: Integer;
var
ACanvas: TcxCanvas;
AIsCalcByValue: Boolean;
AEditSizeProperties: TcxEditSizeProperties;
AParams: TcxViewParams;
AEditViewData: TcxCustomEditViewData;
I, AWidth: Integer;
ARecord: TcxCustomGridRecord;
AValue: Variant;
AEditMinContentSize: TSize;
function GetFirstRecordIndex: Integer;
begin
Result := GridView.OptionsBehavior.BestFitMaxRecordCount;
if Result <> 0 then
begin
Result := Controller.TopRecordIndex;
if Result < 0 then Result := 0;
end;
end;
function GetLastRecordIndex: Integer;
begin
Result := GridView.OptionsBehavior.BestFitMaxRecordCount;
if Result = 0 then
Result := ViewData.RecordCount
else
begin
Result := GetFirstRecordIndex + Result;
if Result > ViewData.RecordCount then
Result := ViewData.RecordCount;
end;
Dec(Result);
end;
begin
Result := 0;
ACanvas := FGridView.Painter.Canvas;
AIsCalcByValue := GetProperties.GetEditValueSource(False) = evsValue;
with AEditSizeProperties do
begin
Height := -1;
MaxLineCount := 0;
Width := -1;
end;
AEditViewData := CreateEditViewData(GetProperties);
try
if GridView.ViewInfo.RecordsViewInfo.AutoDataCellHeight or
GridView.ViewInfo.RecordsViewInfo.IsCellMultiLine(Self) then
begin
Include(AEditViewData.PaintOptions, epoAutoHeight);
AEditViewData.MaxLineCount := GridView.OptionsView.CellTextMaxLineCount;
end;
AEditViewData.InplaceEditParams.Position.Item := Self;
for I := GetFirstRecordIndex to GetLastRecordIndex do
begin
ARecord := ViewData.Records[I];
if ARecord.HasCells then
begin
FStyles.GetContentParams(ARecord, AParams);
InitStyle(AEditViewData.Style, AParams, True);
if AIsCalcByValue then
AValue := ARecord.Values[FIndex]
else
AValue := ARecord.DisplayTexts[FIndex];
AEditViewData.InplaceEditParams.Position.RecordIndex := ARecord.RecordIndex;
AEditViewData.Data := ARecord;
AWidth := AEditViewData.GetEditContentSize(ACanvas, AValue, AEditSizeProperties).cx;
if AWidth > Result then Result := AWidth;
end;
end;
FStyles.GetContentParams(nil, AParams);
InitStyle(AEditViewData.Style, AParams, True);
AWidth := AEditViewData.GetEditConstantPartSize(ACanvas, AEditSizeProperties,
AEditMinContentSize).cx;
if Result < AEditMinContentSize.cx then
Result := AEditMinContentSize.cx;
Inc(Result, AWidth);
finally
DestroyEditViewData(AEditViewData);
end;
if Result <> 0 then
Inc(Result, 2 * cxGridEditOffset);
end;
function TcxCustomGridTableItem.CanAutoHeight: Boolean;
begin
Result := esoAutoHeight in GetProperties.GetSupportedOperations;
end;
function TcxCustomGridTableItem.CanEdit: Boolean;
begin
Result := CanFocus(Controller.FocusedRecord) and Editable and
(FocusedCellViewInfo <> nil) and (dceoShowEdit in DataController.EditOperations);
end;
function TcxCustomGridTableItem.CanFilter(AVisually: Boolean): Boolean;
begin
Result :=
(esoFiltering in GetProperties.GetSupportedOperations) and FOptions.Filtering and
(not AVisually or GridView.OptionsCustomize.ItemFiltering and FOptions.FilteringPopup);
end;
function TcxCustomGridTableItem.CanFilterUsingChecks: Boolean;
begin
Result := GridView.Filtering.ItemPopup.MultiSelect and FOptions.FilteringPopupMultiSelect;
end;
function TcxCustomGridTableItem.CanFilterMRUValueItems: Boolean;
begin
Result := GridView.Filtering.ItemMRUItemsList and FOptions.FilteringMRUItemsList and
not CanFilterUsingChecks;
end;
function TcxCustomGridTableItem.CanFocus(ARecord: TcxCustomGridRecord): Boolean;
begin
Result := ActuallyVisible and FOptions.Focusing and
((ARecord = nil) and GridView.OptionsSelection.CellSelect or
(ARecord <> nil) and ARecord.CanFocusCells);
end;
function TcxCustomGridTableItem.CanGroup: Boolean;
begin
Result := (esoSorting in GetProperties.GetSupportedOperations) and
GridView.OptionsCustomize.ItemGrouping and FOptions.Grouping;
end;
function TcxCustomGridTableItem.CanHide: Boolean;
begin
Result := not (IsFirst and IsLast) and CanMove;
end;
function TcxCustomGridTableItem.CanHorzSize: Boolean;
begin
Result := not HasFixedWidth;
end;
function TcxCustomGridTableItem.CanIgnoreTimeForFiltering: Boolean;
begin
Result := IsDateTimeValueTypeClass(FDataBinding.ValueTypeClass) and
GridView.DateTimeHandling.IgnoreTimeForFiltering and FOptions.IgnoreTimeForFiltering;
end;
function TcxCustomGridTableItem.CanIncSearch: Boolean;
begin
Result := (esoIncSearch in GetProperties.GetSupportedOperations) and
GridView.OptionsBehavior.IncSearch and FOptions.IncSearch;
end;
function TcxCustomGridTableItem.CanInitEditing: Boolean;
begin
Result := DataController.CanInitEditing(Index);
end;
function TcxCustomGridTableItem.CanMove: Boolean;
begin
Result := IsDesigning or GridView.OptionsCustomize.ItemMoving and Options.Moving;
end;
function TcxCustomGridTableItem.CanScroll: Boolean;
begin
Result := True;
end;
function TcxCustomGridTableItem.CanSort: Boolean;
begin
Result := (esoSorting in GetProperties.GetSupportedOperations) and
GridView.OptionsCustomize.ItemSorting and Options.Sorting;
end;
procedure TcxCustomGridTableItem.CaptionChanged;
begin
GridView.ItemCaptionChanged(Self);
end;
procedure TcxCustomGridTableItem.Changed(AChange: TcxGridTableItemChange);
begin
if GridView <> nil then
GridView.Changed(TcxGridViewChangeKind(AChange));
end;
procedure TcxCustomGridTableItem.ChangeGroupIndex(Value: Integer);
begin
if GroupIndex <> Value then
begin
ShowHourglassCursor;
try
if (GroupIndex = -1) and not GridView.IsAfterAssigningItems then
FWasVisibleBeforeGrouping := Visible;
DataController.Groups.ChangeGrouping(Index, Value);
finally
HideHourglassCursor;
end;
end;
end;
procedure TcxCustomGridTableItem.ChangeSortIndex(Value: Integer);
begin
if SortIndex <> Value then
begin
ShowHourglassCursor;
try
DataController.ChangeItemSortingIndex(Index, Value);
finally
HideHourglassCursor;
end;
end;
end;
procedure TcxCustomGridTableItem.CheckWidthValue(var Value: Integer);
begin
if Value < ActualMinWidth then Value := ActualMinWidth;
end;
procedure TcxCustomGridTableItem.DataChanged;
begin
FDataBinding.Init;
end;
procedure TcxCustomGridTableItem.DateTimeGroupingChanged;
begin
InitGroupingDateRanges;
DataController.Refresh;
end;
procedure TcxCustomGridTableItem.ForceWidth(Value: Integer);
begin
Controller.ForcingWidthItem := Self;
try
Width := Value;
finally
Controller.ForcingWidthItem := nil;
end;
end;
function TcxCustomGridTableItem.GetActuallyVisible: Boolean;
begin
Result := Visible;
end;
function TcxCustomGridTableItem.GetBestFitWidth: Integer;
begin
Result := CalculateBestFitWidth;
if (FBestFitMaxWidth <> 0) and (Result > FBestFitMaxWidth) then
Result := FBestFitMaxWidth;
end;
function TcxCustomGridTableItem.GetDateTimeFilters: TcxGridDateTimeFilters;
begin
Result := GridView.DateTimeHandling.Filters;
end;
function TcxCustomGridTableItem.GetDateTimeGrouping: TcxGridDateTimeGrouping;
begin
Result := FDateTimeGrouping;
if Result = dtgDefault then
Result := GridView.DateTimeHandling.Grouping;
end;
function TcxCustomGridTableItem.GetEditable: Boolean;
begin
Result := GridView.OptionsData.Editing and FOptions.Editing;
end;
function TcxCustomGridTableItem.GetEditPartVisible: Boolean;
var
R: TRect;
begin
if CanScroll then
begin
R := GridView.ViewInfo.ScrollableAreaBoundsForEdit;
with FocusedCellViewInfo.EditBounds do
Result :=
(Left < R.Left) or (Right > R.Right) or
(Top < R.Top) or (Bottom > R.Bottom);
end
else
Result := False;
end;
function TcxCustomGridTableItem.GetEditValue: Variant;
begin
if Controller.FocusedRecord <> nil then
Result := DataController.GetEditValue(Index, EditingProperties.GetEditValueSource(True))
else
Result := Unassigned;
end;
function TcxCustomGridTableItem.GetFilterable: Boolean;
begin
Result := CanFilter(False);
end;
procedure TcxCustomGridTableItem.GetFilterDisplayText(const AValue: Variant;
var ADisplayText: string);
begin
if Assigned(FOnGetFilterDisplayText) then
FOnGetFilterDisplayText(Self, AValue, ADisplayText);
end;
function TcxCustomGridTableItem.GetFixed: Boolean;
begin
Result := (Controller.ForcingWidthItem = Self) or HasFixedWidth;
end;
function TcxCustomGridTableItem.GetFocusedCellViewInfo: TcxGridTableDataCellViewInfo;
begin
with Controller do
if FocusedRecordHasCells(False) and (FocusedRecord.ViewInfo <> nil) then
Result := FocusedRecord.ViewInfo.GetCellViewInfoByItem(Self)
else
Result := nil;
end;
function TcxCustomGridTableItem.GetPropertiesForEdit: TcxCustomEditProperties;
begin
Result := GetProperties(Controller.FocusedRecord);
DoGetPropertiesForEdit(Controller.FocusedRecord, Result);
InitProperties(Result);
end;
function TcxCustomGridTableItem.GetPropertiesValue: TcxCustomEditProperties;
begin
if FLastUsedDefaultRepositoryItem <> nil then
begin
FLastUsedDefaultRepositoryItem.RemoveListener(Self);
FLastUsedDefaultRepositoryItem := nil;
end;
if FGridView = nil then // because of EditViewData - it needs Style which needs GridView
Result := nil
else
if UseOwnProperties then
Result := FProperties
else
if GetRepositoryItem = nil then
Result := nil
else
Result := GetRepositoryItem.Properties;
end;
function TcxCustomGridTableItem.GetVisible: Boolean;
begin
Result := FVisible;
end;
function TcxCustomGridTableItem.GetVisibleCaption: string;
begin
Result := Caption;
end;
function TcxCustomGridTableItem.GetVisibleForCustomization: Boolean;
begin
Result := FVisibleForCustomization;
end;
function TcxCustomGridTableItem.GetVisibleIndex: Integer;
begin
Result := FGridView.FVisibleItems.IndexOf(Self);
end;
function TcxCustomGridTableItem.GetVisibleInQuickCustomizationPopup: Boolean;
begin
Result := VisibleForCustomization;
end;
procedure TcxCustomGridTableItem.GroupingChanging;
begin
if SupportsGroupingDateRanges(True) then
InitGroupingDateRanges;
end;
function TcxCustomGridTableItem.HasCustomDrawCell: Boolean;
begin
Result := Assigned(FOnCustomDrawCell);
end;
function TcxCustomGridTableItem.HasFixedWidth: Boolean;
begin
Result := False;
end;
procedure TcxCustomGridTableItem.InitFilteringDateRanges;
begin
FilteringDateRanges.Init(GridView.DateTimeHandling, GetDateTimeFilters);
DoInitFilteringDateRanges;
end;
procedure TcxCustomGridTableItem.InitGroupingDateRanges;
begin
GroupingDateRanges.Init(GridView.DateTimeHandling, GetDateTimeGrouping);
DoInitGroupingDateRanges;
end;
procedure TcxCustomGridTableItem.InitProperties(AProperties: TcxCustomEditProperties);
begin
if AProperties <> nil then
with AProperties do
begin
LockUpdate(True);
IDefaultValuesProvider := GetDefaultValuesProvider(AProperties);
LockUpdate(False);
end;
end;
function TcxCustomGridTableItem.IsSortingByDisplayText(ASortByDisplayText: Boolean): Boolean;
begin
if FOptions.SortByDisplayText = isbtDefault then
Result := HasDataTextHandler or ASortByDisplayText and
(esoSortingByDisplayText in GetProperties.GetSupportedOperations)
else
Result := FOptions.SortByDisplayText = isbtOn;
end;
function TcxCustomGridTableItem.IsVisibleStored: Boolean;
begin
Result := True;
end;
function TcxCustomGridTableItem.IsVisibleForCustomizationStored: Boolean;
begin
Result := not VisibleForCustomization;
end;
procedure TcxCustomGridTableItem.PropertiesChanged;
begin
if GridView.PatternGridView.IgnorePropertiesChanges then Exit;
if not IsDestroying then
GridView.RefreshFilterableItemsList;
if FEditData <> nil then FEditData.Clear;
if not IsDestroying and not DataController.ItemPropertiesChanged(Index) then
Changed(ticSize);
end;
procedure TcxCustomGridTableItem.PropertiesChangedHandler(Sender: TObject);
begin
if not GridView.IsPattern then PropertiesChanged;
end;
procedure TcxCustomGridTableItem.PropertiesValueChanged;
begin
FPropertiesValue := GetPropertiesValue;
if not IsDestroying and (FPropertiesValue <> nil) then
DataController.SortByDisplayTextChanged; // for Options.SortByDisplayText = isbtDefault
end;
procedure TcxCustomGridTableItem.RecalculateDefaultWidth;
begin
if not FIsWidthAssigned then
FWidth := DefaultWidth;
end;
procedure TcxCustomGridTableItem.SetEditValue(const Value: Variant);
begin
DataController.SetEditValue(Index, Value, EditingProperties.GetEditValueSource(True));
end;
procedure TcxCustomGridTableItem.SetGridView(Value: TcxCustomGridTableView);
begin
FGridView := Value;
if Value <> nil then
CreateDataBinding
else
DestroyDataBinding;
PropertiesValueChanged;
if GridView <> nil then InitGroupingDateRanges;
end;
function TcxCustomGridTableItem.ShowButtons(AFocused: Boolean): Boolean;
var
AGridShowEditButtons: TcxGridShowEditButtons;
begin
AGridShowEditButtons := FGridView.OptionsView.ShowEditButtons;
Result :=
(FOptions.ShowEditButtons = isebAlways) or
(FOptions.ShowEditButtons = isebDefault) and
((AGridShowEditButtons = gsebAlways) or
(AGridShowEditButtons = gsebForFocusedRecord) and AFocused);
end;
function TcxCustomGridTableItem.ShowOnUngrouping: Boolean;
begin
Result := True; //!!!
end;
function TcxCustomGridTableItem.SupportsDateTimeFilters(ARelativeFilters: Boolean): Boolean;
begin
Result := IsDateTimeValueTypeClass(FDataBinding.ValueTypeClass) and
(ARelativeFilters and (GetDateTimeFilters * DateTimeRelativeFilters <> []) or
not ARelativeFilters and
((GetDateTimeFilters * DateTimeAbsoluteFilters <> []) or HasInitFilteringDateRangesHandlers));
end;
function TcxCustomGridTableItem.SupportsGroupingDateRanges(ACheckCustomHandlers: Boolean): Boolean;
begin
Result := IsDateTimeValueTypeClass(FDataBinding.ValueTypeClass) and
(ACheckCustomHandlers and HasInitGroupingDateRangesHandlers or
not ACheckCustomHandlers and not GroupingDateRanges.IsEmpty);
end;
function TcxCustomGridTableItem.UseFilteredValuesForFilterValueList: Boolean;
begin
Result := GridView.Filtering.ItemFilteredItemsList and FOptions.FilteringFilteredItemsList;
end;
function TcxCustomGridTableItem.UseOwnProperties: Boolean;
begin
Result := (FRepositoryItem = nil) and (FProperties <> nil);
end;
procedure TcxCustomGridTableItem.ValueTypeClassChanged;
begin
FDataBinding.FilterMRUValueItems.ClearItems;
FDataBinding.Init;
PropertiesValueChanged;
if FProperties <> nil then
FProperties.Changed;
end;
procedure TcxCustomGridTableItem.VisibleChanged;
begin
end;
procedure TcxCustomGridTableItem.VisibleForCustomizationChanged;
begin
with FGridView do
begin
//RefreshFilterableItemsList;
RefreshCustomizationForm;
end;
Changed(ticProperty);
end;
function TcxCustomGridTableItem.DefaultAlternateCaption: string;
begin
Result := Caption;
end;
function TcxCustomGridTableItem.DefaultCaption: string;
begin
Result := FDataBinding.DefaultCaption;
end;
function TcxCustomGridTableItem.DefaultHeaderAlignmentHorz: TAlignment;
begin
Result := taLeftJustify;
end;
function TcxCustomGridTableItem.DefaultHeaderAlignmentVert: TcxAlignmentVert;
begin
Result := vaTop;
end;
function TcxCustomGridTableItem.DefaultRepositoryItem: TcxEditRepositoryItem;
begin
if FDataBinding = nil then
Result := nil
else
Result := FDataBinding.DefaultRepositoryItem;
end;
function TcxCustomGridTableItem.DefaultWidth: Integer;
begin
Result := FDataBinding.DefaultWidth;
end;
function TcxCustomGridTableItem.GetCellStyle: TcxEditStyle;
begin
if FCellStyle = nil then
FCellStyle := CreateEditStyle;
Result := FCellStyle;
Inc(FCellStyleUseCounter);
end;
procedure TcxCustomGridTableItem.InitStyle(AStyle: TcxCustomEditStyle;
const AParams: TcxViewParams; AFocused: Boolean);
begin
with AParams do
begin
AStyle.Color := Color;
AStyle.Font := Font;
AStyle.StyleData.FontColor := TextColor;
end;
with AStyle do
begin
if Self.ShowButtons(AFocused) then
ButtonTransparency := ebtNone
else
ButtonTransparency := ebtHideInactive;
HotTrack := True;
end;
end;
procedure TcxCustomGridTableItem.ReleaseCellStyle;
begin
Dec(FCellStyleUseCounter);
if FCellStyleUseCounter = 0 then FreeAndNil(FCellStyle);
end;
procedure TcxCustomGridTableItem.AddCell(ACell: TcxGridTableDataCellViewInfo);
begin
FCells.Add(ACell);
end;
procedure TcxCustomGridTableItem.RemoveCell(ACell: TcxGridTableDataCellViewInfo);
begin
FCells.Remove(ACell);
end;
function TcxCustomGridTableItem.CreateEditViewData(AProperties: TcxCustomEditProperties): TcxCustomEditViewData;
begin
if AProperties <> nil then
begin
Result := AProperties.CreateViewData(GetCellStyle, True);
Result.OnGetDisplayText := EditViewDataGetDisplayTextHandler;
end
else
Result := nil;
end;
procedure TcxCustomGridTableItem.DestroyEditViewData(var AEditViewData: TcxCustomEditViewData);
begin
if AEditViewData <> nil then
begin
FreeAndNil(AEditViewData);
ReleaseCellStyle;
end;
end;
procedure TcxCustomGridTableItem.DoCreateEditViewData;
begin
FEditViewData := CreateEditViewData(GetProperties);
end;
procedure TcxCustomGridTableItem.DoDestroyEditViewData;
begin
DestroyEditViewData(FEditViewData);
end;
procedure TcxCustomGridTableItem.EditViewDataGetDisplayTextHandler(Sender: TcxCustomEditViewData;
var AText: string);
var
AGridRecord: TcxCustomGridRecord;
begin
if Sender.Data is TcxCustomGridRecord then
AGridRecord := TcxCustomGridRecord(Sender.Data)
else
AGridRecord := nil;
DoGetDisplayText(AGridRecord, AText);
end;
function TcxCustomGridTableItem.GetEditViewData(AProperties: TcxCustomEditProperties;
out AIsLocalCopy: Boolean): TcxCustomEditViewData;
begin
AIsLocalCopy := HasCustomPropertiesHandler or (FEditViewData = nil);
if AIsLocalCopy then
Result := CreateEditViewData(AProperties)
else
Result := FEditViewData;
end;
procedure TcxCustomGridTableItem.ReleaseEditViewData(var AEditViewData: TcxCustomEditViewData;
AIsLocalCopy: Boolean);
begin
if AIsLocalCopy then
DestroyEditViewData(AEditViewData)
else
AEditViewData := nil;
end;
procedure TcxCustomGridTableItem.CheckVisible;
begin
if ActuallyVisible <> FSavedVisible then
GridView.ItemVisibilityChanged(Self, ActuallyVisible);
end;
procedure TcxCustomGridTableItem.SaveVisible;
begin
FSavedVisible := ActuallyVisible;
end;
procedure TcxCustomGridTableItem.DoCustomDrawCell(ACanvas: TcxCanvas;
AViewInfo: TcxGridTableDataCellViewInfo; var ADone: Boolean);
begin
if HasCustomDrawCell then
FOnCustomDrawCell(GridView, ACanvas, AViewInfo, ADone);
end;
procedure TcxCustomGridTableItem.DoGetCellHint(ARecord: TcxCustomGridRecord;
ACellViewInfo: TcxGridTableDataCellViewInfo; const AMousePos: TPoint;
var AHintText: TCaption; var AIsHintMultiLine: Boolean; var AHintTextRect: TRect);
begin
if HasCellHintHandler then
FOnGetCellHint(Self, ARecord, ACellViewInfo, AMousePos, AHintText, AIsHintMultiLine, AHintTextRect);
end;
procedure TcxCustomGridTableItem.DoGetDataText(ARecordIndex: Integer;
var AText: string);
begin
if HasDataTextHandler then FOnGetDataText(Self, ARecordIndex, AText);
end;
procedure TcxCustomGridTableItem.DoGetDisplayText(ARecord: TcxCustomGridRecord;
var AText: string);
begin
if Assigned(FOnGetDisplayText) then FOnGetDisplayText(Self, ARecord, AText);
end;
procedure TcxCustomGridTableItem.DoGetFilterValues(AValueList: TcxDataFilterValueList);
begin
if Assigned(FOnGetFilterValues) then FOnGetFilterValues(Self, AValueList);
end;
function TcxCustomGridTableItem.DoGetProperties(ARecord: TcxCustomGridRecord): TcxCustomEditProperties;
begin
Result := FPropertiesValue;
if HasCustomPropertiesHandler then FOnGetProperties(Self, ARecord, Result);
end;
procedure TcxCustomGridTableItem.DoGetPropertiesForEdit(ARecord: TcxCustomGridRecord;
var AProperties: TcxCustomEditProperties);
begin
if HasCustomPropertiesForEditHandler then
FOnGetPropertiesForEdit(Self, ARecord, AProperties);
end;
procedure TcxCustomGridTableItem.DoInitFilteringDateRanges;
begin
GridView.DoInitFilteringDateRanges(Self);
if HasInitFilteringDateRangesHandler then
FOnInitFilteringDateRanges(Self, FilteringDateRanges);
end;
procedure TcxCustomGridTableItem.DoInitGroupingDateRanges;
begin
GridView.DoInitGroupingDateRanges(Self);
if HasInitGroupingDateRangesHandler then
FOnInitGroupingDateRanges(Self, GroupingDateRanges);
end;
procedure TcxCustomGridTableItem.DoUserFiltering(const AValue: Variant; const ADisplayText: string);
begin
if Assigned(FOnUserFiltering) then FOnUserFiltering(Self, AValue, ADisplayText);
end;
function TcxCustomGridTableItem.HasCellHintHandler: Boolean;
begin
Result := Assigned(FOnGetCellHint);
end;
function TcxCustomGridTableItem.HasCustomPropertiesForEditHandler: Boolean;
begin
Result := Assigned(FOnGetPropertiesForEdit);
end;
function TcxCustomGridTableItem.HasCustomPropertiesHandler: Boolean;
begin
Result := Assigned(FOnGetProperties);
end;
function TcxCustomGridTableItem.HasDataTextHandler: Boolean;
begin
Result := Assigned(FOnGetDataText);
end;
function TcxCustomGridTableItem.HasInitFilteringDateRangesHandler: Boolean;
begin
Result := Assigned(FOnInitFilteringDateRanges);
end;
function TcxCustomGridTableItem.HasInitFilteringDateRangesHandlers: Boolean;
begin
Result := GridView.HasInitFilteringDateRangesHandler or HasInitFilteringDateRangesHandler;
end;
function TcxCustomGridTableItem.HasInitGroupingDateRangesHandler: Boolean;
begin
Result := Assigned(FOnInitGroupingDateRanges);
end;
function TcxCustomGridTableItem.HasInitGroupingDateRangesHandlers: Boolean;
begin
Result := GridView.HasInitGroupingDateRangesHandler or HasInitGroupingDateRangesHandler;
end;
procedure TcxCustomGridTableItem.Assign(Source: TPersistent);
begin
if Source is TcxCustomGridTableItem then
with TcxCustomGridTableItem(Source) do
begin
Self.AlternateCaption := AlternateCaption;
Self.BestFitMaxWidth := BestFitMaxWidth;
Self.DataBinding := DataBinding;
Self.FIsCaptionAssigned := FIsCaptionAssigned;
Self.Caption := Caption;
Self.DateTimeGrouping := DateTimeGrouping;
Self.GroupIndex := GroupIndex;
Self.FIsHeaderAlignmentHorzAssigned := FIsHeaderAlignmentHorzAssigned;
Self.HeaderAlignmentHorz := HeaderAlignmentHorz;
Self.FIsHeaderAlignmentVertAssigned := FIsHeaderAlignmentVertAssigned;
Self.HeaderAlignmentVert := HeaderAlignmentVert;
Self.MinWidth := MinWidth;
Self.Options := Options;
Self.PropertiesClass := PropertiesClass;
Self.Properties := Properties;
Self.RepositoryItem := RepositoryItem;
Self.SortOrder := SortOrder;
Self.SortIndex := SortIndex;
Self.Styles := Styles;
Self.Tag := Tag;
Self.Visible := Visible;
Self.VisibleForCustomization := VisibleForCustomization;
Self.FIsWidthAssigned := FIsWidthAssigned;
Self.Width := Width;
Self.OnCustomDrawCell := OnCustomDrawCell;
Self.OnGetCellHint := OnGetCellHint;
Self.OnGetDataText := OnGetDataText;
Self.OnGetDisplayText := OnGetDisplayText;
Self.OnGetFilterDisplayText := OnGetFilterDisplayText;
Self.OnGetFilterValues := OnGetFilterValues;
Self.OnGetProperties := OnGetProperties;
Self.OnGetPropertiesForEdit := OnGetPropertiesForEdit;
Self.OnGetStoredProperties := OnGetStoredProperties;
Self.OnGetStoredPropertyValue := OnGetStoredPropertyValue;
Self.OnInitFilteringDateRanges := OnInitFilteringDateRanges;
Self.OnInitGroupingDateRanges := OnInitGroupingDateRanges;
Self.OnSetStoredPropertyValue := OnSetStoredPropertyValue;
Self.OnUserFiltering := OnUserFiltering;
end
else
inherited;
end;
function TcxCustomGridTableItem.GetParentComponent: TComponent;
begin
Result := FGridView;
end;
function TcxCustomGridTableItem.HasParent: Boolean;
begin
Result := FGridView <> nil;
end;
procedure TcxCustomGridTableItem.ApplyBestFit(ACheckSizingAbility: Boolean = False;
AFireEvents: Boolean = False);
begin
if GridView.IsPattern or ACheckSizingAbility and not CanHorzSize then Exit;
ShowHourglassCursor;
try
ForceWidth(GetBestFitWidth);
Changed(ticSize);
finally
HideHourglassCursor;
BestFitApplied(AFireEvents);
end;
end;
function TcxCustomGridTableItem.CalculateDefaultCellHeight(ACanvas: TcxCanvas;
AFont: TFont): Integer;
var
AEditStyle: TcxEditStyle;
AEditSizeProperties: TcxEditSizeProperties;
begin
AEditStyle := GetCellStyle;
try
AEditStyle.Font := AFont;
with AEditSizeProperties do
begin
Height := -1;
MaxLineCount := 0;
Width := -1;
end;
Result := GetProperties.GetEditSize(ACanvas, AEditStyle, True, Null, AEditSizeProperties).cy;
if Result <> 0 then
Inc(Result, 2 * cxGridEditOffset);
finally
ReleaseCellStyle;
end;
end;
function TcxCustomGridTableItem.CreateEditStyle: TcxEditStyle;
begin
Result := GetProperties.GetStyleClass.Create(nil, True) as TcxEditStyle;
if GridView.Control <> nil then
Result.LookAndFeel.MasterLookAndFeel := GridView.LookAndFeel;
end;
procedure TcxCustomGridTableItem.FocusWithSelection;
begin
Focused := True;
end;
function TcxCustomGridTableItem.GetAlternateCaption: string;
begin
Result := FAlternateCaption;
if Result = '' then
Result := DefaultAlternateCaption;
end;
function TcxCustomGridTableItem.GetDefaultValuesProvider(AProperties: TcxCustomEditProperties = nil): IcxEditDefaultValuesProvider;
begin
if FDataBinding = nil then
Result := nil
else
Result := FDataBinding.GetDefaultValuesProvider(AProperties);
end;
function TcxCustomGridTableItem.GetProperties: TcxCustomEditProperties;
begin
Result := FPropertiesValue;
InitProperties(Result);
end;
function TcxCustomGridTableItem.GetProperties(ARecord: TcxCustomGridRecord): TcxCustomEditProperties;
begin
Result := DoGetProperties(ARecord);
InitProperties(Result);
end;
function TcxCustomGridTableItem.GetProperties(ARecordIndex: Integer): TcxCustomEditProperties;
var
ARecord: TcxCustomGridRecord;
begin
if HasCustomPropertiesHandler then
begin
ARecord := ViewData.GetRecordByRecordIndex(ARecordIndex);
if ARecord = nil then
Result := GetProperties
else
Result := GetProperties(ARecord);
end
else
Result := GetProperties;
end;
function TcxCustomGridTableItem.GetRepositoryItem: TcxEditRepositoryItem;
begin
Result := FRepositoryItem;
if (Result = nil) and not IsDestroying then
begin
Result := DefaultRepositoryItem;
if Result <> nil then
begin
Result.AddListener(Self);
FLastUsedDefaultRepositoryItem := Result;
end;
end;
end;
procedure TcxCustomGridTableItem.MakeVisible;
begin
Controller.MakeItemVisible(Self);
end;
procedure TcxCustomGridTableItem.RestoreDefaults;
begin
FIsCaptionAssigned := False;
FIsHeaderAlignmentHorzAssigned := False;
FIsHeaderAlignmentVertAssigned := False;
FIsWidthAssigned := False;
Changed(ticSize);
end;
{ TcxCustomGridTableBackgroundBitmaps }
function TcxCustomGridTableBackgroundBitmaps.GetBitmapStyleIndex(Index: Integer): Integer;
begin
case Index of
bbContent:
Result := vsContent;
bbFilterBox:
Result := vsFilterBox;
else
Result := inherited GetBitmapStyleIndex(Index);
end;
end;
procedure TcxCustomGridTableBackgroundBitmaps.Assign(Source: TPersistent);
begin
if Source is TcxCustomGridTableBackgroundBitmaps then
with TcxCustomGridTableBackgroundBitmaps(Source) do
begin
Self.Content := Content;
Self.FilterBox := FilterBox;
end;
inherited;
end;
{ TcxCustomGridTableDateTimeHandling }
constructor TcxCustomGridTableDateTimeHandling.Create(AGridView: TcxCustomGridView);
begin
inherited;
FGrouping := dtgByDateAndTime;
FUseLongDateFormat := True;
FUseShortTimeFormat := True;
end;
function TcxCustomGridTableDateTimeHandling.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
procedure TcxCustomGridTableDateTimeHandling.SetDateFormat(const Value: string);
begin
if FDateFormat <> Value then
begin
FDateFormat := Value;
Changed(vcSize);
end;
end;
procedure TcxCustomGridTableDateTimeHandling.SetFilters(Value: TcxGridDateTimeFilters);
begin
if FFilters <> Value then
begin
FFilters := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableDateTimeHandling.SetGrouping(Value: TcxGridDateTimeGrouping);
begin
if Value = dtgDefault then Value := dtgByDateAndTime;
if FGrouping <> Value then
begin
FGrouping := Value;
GroupingChanged;
end;
end;
procedure TcxCustomGridTableDateTimeHandling.SetHourFormat(const Value: string);
begin
if FHourFormat <> Value then
begin
FHourFormat := Value;
Changed(vcSize);
end;
end;
procedure TcxCustomGridTableDateTimeHandling.SetIgnoreTimeForFiltering(Value: Boolean);
begin
if FIgnoreTimeForFiltering <> Value then
begin
FIgnoreTimeForFiltering := Value;
GridView.DataController.Refresh;
end;
end;
procedure TcxCustomGridTableDateTimeHandling.SetMonthFormat(const Value: string);
begin
if FMonthFormat <> Value then
begin
FMonthFormat := Value;
Changed(vcSize);
end;
end;
procedure TcxCustomGridTableDateTimeHandling.SetUseLongDateFormat(Value: Boolean);
begin
if FUseLongDateFormat <> Value then
begin
FUseLongDateFormat := Value;
Changed(vcSize);
end;
end;
procedure TcxCustomGridTableDateTimeHandling.SetUseShortTimeFormat(Value: Boolean);
begin
if FUseShortTimeFormat <> Value then
begin
FUseShortTimeFormat := Value;
Changed(vcSize);
end;
end;
procedure TcxCustomGridTableDateTimeHandling.SetYearFormat(const Value: string);
begin
if FYearFormat <> Value then
begin
FYearFormat := Value;
Changed(vcSize);
end;
end;
procedure TcxCustomGridTableDateTimeHandling.Assign(Source: TPersistent);
begin
inherited;
if Source is TcxCustomGridTableDateTimeHandling then
with TcxCustomGridTableDateTimeHandling(Source) do
begin
Self.DateFormat := DateFormat;
Self.Filters := Filters;
Self.Grouping := Grouping;
Self.HourFormat := HourFormat;
Self.IgnoreTimeForFiltering := IgnoreTimeForFiltering;
Self.MonthFormat := MonthFormat;
Self.UseLongDateFormat := UseLongDateFormat;
Self.UseShortTimeFormat := UseShortTimeFormat;
Self.YearFormat := YearFormat;
end;
end;
function TcxCustomGridTableDateTimeHandling.GetDateFormat: string;
begin
Result := FDateFormat;
if Result = '' then
if UseLongDateFormat then
Result := LongDateFormat
else
Result := '';
end;
function TcxCustomGridTableDateTimeHandling.GetHourFormat: string;
begin
Result := FHourFormat;
if Result = '' then
if UseShortTimeFormat then
Result := ShortTimeFormat
else
Result := '';
end;
function TcxCustomGridTableDateTimeHandling.GetMonthFormat: string;
begin
Result := FMonthFormat;
if Result = '' then
Result := cxGetResourceString(@scxGridMonthFormat);
end;
function TcxCustomGridTableDateTimeHandling.GetYearFormat: string;
begin
Result := FYearFormat;
if Result = '' then
Result := cxGetResourceString(@scxGridYearFormat);
end;
procedure TcxCustomGridTableDateTimeHandling.GroupingChanged;
var
I: Integer;
begin
if GridView.ItemCount = 0 then
Changed(vcProperty)
else
begin
GridView.BeginUpdate;
try
for I := 0 to GridView.ItemCount - 1 do
GridView.Items[I].DateTimeGroupingChanged;
finally
GridView.EndUpdate;
end;
end;
end;
{ TcxGridFilterMRUItem }
function GetFilterStream(AFilter: TcxDataFilterCriteria): TMemoryStream;
begin
Result := TMemoryStream.Create;
AFilter.WriteData(Result);
end;
constructor TcxGridFilterMRUItem.Create(AFilter: TcxDataFilterCriteria);
begin
inherited Create;
Filter := AFilter.DataController.CreateFilter;
Filter.Assign(AFilter);
end;
destructor TcxGridFilterMRUItem.Destroy;
begin
Filter.Free;
inherited;
end;
function TcxGridFilterMRUItem.GetCaption: string;
begin
Result := Filter.FilterCaption;
end;
function TcxGridFilterMRUItem.StreamEquals(AStream: TMemoryStream): Boolean;
var
AOwnStream: TMemoryStream;
begin
AOwnStream := GetStream;
try
Result := StreamsEqual(AOwnStream, AStream);
finally
AStream.Free;
AOwnStream.Free;
end;
end;
procedure TcxGridFilterMRUItem.AssignTo(AFilter: TcxDataFilterCriteria);
begin
AFilter.AssignItems(Filter);
end;
function TcxGridFilterMRUItem.Equals(AItem: TcxMRUItem): Boolean;
begin
Result := StreamEquals(TcxGridFilterMRUItem(AItem).GetStream);
end;
function TcxGridFilterMRUItem.FilterEquals(AFilter: TcxDataFilterCriteria): Boolean;
begin
Result := StreamEquals(GetFilterStream(AFilter));
end;
function TcxGridFilterMRUItem.GetStream: TMemoryStream;
begin
Result := GetFilterStream(Filter);
end;
{ TcxGridFilterMRUItems }
constructor TcxGridFilterMRUItems.Create(AFiltering: TcxCustomGridTableFiltering);
begin
inherited Create;
FFiltering := AFiltering;
FVisibleItems := TList.Create;
end;
destructor TcxGridFilterMRUItems.Destroy;
begin
FVisibleItems.Free;
inherited;
end;
function TcxGridFilterMRUItems.GetItem(Index: Integer): TcxGridFilterMRUItem;
begin
Result := TcxGridFilterMRUItem(inherited Items[Index]);
end;
function TcxGridFilterMRUItems.GetVisibleCount: Integer;
begin
Result := FVisibleItems.Count;
end;
function TcxGridFilterMRUItems.GetVisibleItem(Index: Integer): TcxGridFilterMRUItem;
begin
Result := TcxGridFilterMRUItem(FVisibleItems[Index]);
end;
procedure TcxGridFilterMRUItems.DeleteEmptyItems;
var
APrevCount, I: Integer;
begin
APrevCount := Count;
for I := Count - 1 downto 0 do
if Items[I].Filter.IsEmpty then
Delete(I);
if Count <> APrevCount then
RefreshVisibleItemsList;
end;
procedure TcxGridFilterMRUItems.FilterChanged;
begin
RefreshVisibleItemsList;
end;
procedure TcxGridFilterMRUItems.RefreshVisibleItemsList;
var
APrevVisibleCount: Integer;
AFilter: TcxDataFilterCriteria;
I: Integer;
AItem: TcxGridFilterMRUItem;
begin
APrevVisibleCount := VisibleCount;
AFilter := FFiltering.GridView.DataController.Filter;
FVisibleItems.Clear;
for I := 0 to Count - 1 do
begin
AItem := Items[I];
if not AItem.FilterEquals(AFilter) then FVisibleItems.Add(AItem);
end;
if VisibleCount <> APrevVisibleCount then
FFiltering.MRUItemsVisibleCountChanged(APrevVisibleCount, VisibleCount);
end;
procedure TcxGridFilterMRUItems.Add(AFilter: TcxDataFilterCriteria);
begin
if not AFilter.IsEmpty then
begin
inherited Add(TcxGridFilterMRUItem.Create(AFilter));
RefreshVisibleItemsList;
end;
end;
{ TcxGridFilterBox }
constructor TcxGridFilterBox.Create(AGridView: TcxCustomGridView);
begin
inherited;
FCustomizeDialog := True;
FPosition := fpBottom;
FVisible := fvNonEmpty;
end;
procedure TcxGridFilterBox.SetCustomizeDialog(Value: Boolean);
begin
if FCustomizeDialog <> Value then
begin
FCustomizeDialog := Value;
Changed(vcLayout);
end;
end;
procedure TcxGridFilterBox.SetMRUItemsListDropDownCount(Value: Integer);
begin
if Value < 0 then Value := 0;
if FMRUItemsListDropDownCount <> Value then
begin
FMRUItemsListDropDownCount := Value;
Changed(vcProperty);
end;
end;
procedure TcxGridFilterBox.SetPosition(Value: TcxGridFilterPosition);
begin
if FPosition <> Value then
begin
FPosition := Value;
Changed(vcLayout);
end;
end;
procedure TcxGridFilterBox.SetVisible(Value: TcxGridFilterVisible);
begin
if FVisible <> Value then
begin
FVisible := Value;
Changed(vcSize);
end;
end;
procedure TcxGridFilterBox.Assign(Source: TPersistent);
begin
inherited;
if Source is TcxGridFilterBox then
with TcxGridFilterBox(Source) do
begin
Self.CustomizeDialog := CustomizeDialog;
Self.MRUItemsListDropDownCount := MRUItemsListDropDownCount;
Self.Position := Position;
Self.Visible := Visible;
end;
end;
{ TcxGridItemFilterPopupOptions }
constructor TcxGridItemFilterPopupOptions.Create(AGridView: TcxCustomGridView);
begin
inherited;
FMaxDropDownItemCount := cxGridFilterDefaultItemPopupMaxDropDownItemCount;
FMultiSelect := True;
end;
procedure TcxGridItemFilterPopupOptions.SetApplyMultiSelectChanges(Value: TcxGridItemFilterPopupApplyChangesMode);
begin
if FApplyMultiSelectChanges <> Value then
begin
FApplyMultiSelectChanges := Value;
Changed(vcProperty);
end;
end;
procedure TcxGridItemFilterPopupOptions.SetDropDownWidth(Value: Integer);
begin
if Value < 0 then Value := 0;
if FDropDownWidth <> Value then
begin
FDropDownWidth := Value;
Changed(vcProperty);
end;
end;
procedure TcxGridItemFilterPopupOptions.SetMaxDropDownItemCount(Value: Integer);
begin
if Value < 0 then Value := 0;
if FMaxDropDownItemCount <> Value then
begin
FMaxDropDownItemCount := Value;
Changed(vcProperty);
end;
end;
procedure TcxGridItemFilterPopupOptions.SetMultiSelect(Value: Boolean);
begin
if FMultiSelect <> Value then
begin
FMultiSelect := Value;
Changed(vcProperty);
end;
end;
procedure TcxGridItemFilterPopupOptions.Assign(Source: TPersistent);
begin
inherited;
if Source is TcxGridItemFilterPopupOptions then
with TcxGridItemFilterPopupOptions(Source) do
begin
Self.ApplyMultiSelectChanges := ApplyMultiSelectChanges;
Self.DropDownWidth := DropDownWidth;
Self.MaxDropDownItemCount := MaxDropDownItemCount;
Self.MultiSelect := MultiSelect;
end;
end;
{ TcxCustomGridTableFiltering }
constructor TcxCustomGridTableFiltering.Create(AGridView: TcxCustomGridView);
begin
inherited;
FItemMRUItemsList := True;
FItemMRUItemsListCount := cxGridFilterDefaultItemMRUItemsListCount;
FItemPopup := GetItemPopupClass.Create(GridView);
FMRUItems := GetMRUItemsClass.Create(Self);
FMRUItemsList := True;
FMRUItemsListCount := cxGridFilterDefaultMRUItemsListCount;
end;
destructor TcxCustomGridTableFiltering.Destroy;
begin
FMRUItems.Free;
FItemPopup.Free;
inherited;
end;
function TcxCustomGridTableFiltering.GetCustomizeDialog: Boolean;
begin
Result := GridView.FilterBox.CustomizeDialog;
end;
function TcxCustomGridTableFiltering.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
function TcxCustomGridTableFiltering.GetMRUItemsListDropDownCount: Integer;
begin
Result := GridView.FilterBox.MRUItemsListDropDownCount;
end;
function TcxCustomGridTableFiltering.GetPosition: TcxGridFilterPosition;
begin
Result := GridView.FilterBox.Position;
end;
function TcxCustomGridTableFiltering.GetVisible: TcxGridFilterVisible;
begin
Result := GridView.FilterBox.Visible;
end;
procedure TcxCustomGridTableFiltering.SetCustomizeDialog(Value: Boolean);
begin
GridView.FilterBox.CustomizeDialog := Value;
end;
procedure TcxCustomGridTableFiltering.SetItemFilteredItemsList(Value: Boolean);
begin
if FItemFilteredItemsList <> Value then
begin
FItemFilteredItemsList := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableFiltering.SetItemMRUItemsList(Value: Boolean);
begin
if FItemMRUItemsList <> Value then
begin
FItemMRUItemsList := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableFiltering.SetItemMRUItemsListCount(Value: Integer);
var
I: Integer;
begin
if Value < 0 then Value := 0;
if FItemMRUItemsListCount <> Value then
begin
FItemMRUItemsListCount := Value;
for I := 0 to GridView.ItemCount - 1 do
GridView.Items[I].DataBinding.FilterMRUValueItems.MaxCount := FItemMRUItemsListCount;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableFiltering.SetItemPopup(Value: TcxGridItemFilterPopupOptions);
begin
FItemPopup.Assign(Value);
end;
procedure TcxCustomGridTableFiltering.SetMRUItemsList(Value: Boolean);
begin
if FMRUItemsList <> Value then
begin
FMRUItemsList := Value;
Changed(vcSize);
end;
end;
procedure TcxCustomGridTableFiltering.SetMRUItemsListCount(Value: Integer);
function GetMRUItemsMaxCount: Integer;
begin
Result := FMRUItemsListCount;
if Result <> 0 then Inc(Result); // for current filter
end;
begin
if Value < 0 then Value := 0;
if FMRUItemsListCount <> Value then
begin
FMRUItemsListCount := Value;
FMRUItems.MaxCount := GetMRUItemsMaxCount;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableFiltering.SetMRUItemsListDropDownCount(Value: Integer);
begin
GridView.FilterBox.MRUItemsListDropDownCount := Value;
end;
procedure TcxCustomGridTableFiltering.SetPosition(Value: TcxGridFilterPosition);
begin
GridView.FilterBox.Position := Value;
end;
procedure TcxCustomGridTableFiltering.SetVisible(Value: TcxGridFilterVisible);
begin
GridView.FilterBox.Visible := Value;
end;
procedure TcxCustomGridTableFiltering.FilterControlDialogApply(Sender: TObject);
begin
with GridView.DataController.Filter do
if not IsEmpty then Active := True;
AddFilterToMRUItems;
end;
procedure TcxCustomGridTableFiltering.ReadCustomizeDialog(Reader: TReader);
begin
CustomizeDialog := Reader.ReadBoolean;
end;
procedure TcxCustomGridTableFiltering.ReadMRUItemsListDropDownCount(Reader: TReader);
begin
MRUItemsListDropDownCount := Reader.ReadInteger;
end;
procedure TcxCustomGridTableFiltering.ReadPosition(Reader: TReader);
begin
Position := TcxGridFilterPosition(GetEnumValue(TypeInfo(TcxGridFilterPosition), Reader.ReadIdent));
end;
procedure TcxCustomGridTableFiltering.ReadVisible(Reader: TReader);
begin
Visible := TcxGridFilterVisible(GetEnumValue(TypeInfo(TcxGridFilterVisible), Reader.ReadIdent));
end;
procedure TcxCustomGridTableFiltering.DefineProperties(Filer: TFiler);
begin
inherited;
Filer.DefineProperty('CustomizeDialog', ReadCustomizeDialog, nil, True);
Filer.DefineProperty('DropDownWidth', ReadItemPopupDropDownWidth, nil, True);
Filer.DefineProperty('MaxDropDownCount', ReadItemPopupMaxDropDownCount, nil, True);
Filer.DefineProperty('MRUItemsListDropDownCount', ReadMRUItemsListDropDownCount, nil, True);
Filer.DefineProperty('Position', ReadPosition, nil, True);
Filer.DefineProperty('Visible', ReadVisible, nil, True);
end;
procedure TcxCustomGridTableFiltering.FilterChanged;
begin
FMRUItems.FilterChanged;
end;
function TcxCustomGridTableFiltering.GetItemPopupClass: TcxGridItemFilterPopupOptionsClass;
begin
Result := TcxGridItemFilterPopupOptions;
end;
function TcxCustomGridTableFiltering.GetMRUItemsClass: TcxGridFilterMRUItemsClass;
begin
Result := TcxGridFilterMRUItems;
end;
function TcxCustomGridTableFiltering.IsMRUItemsListAvailable: Boolean;
begin
Result := FMRUItemsList and (FMRUItems.VisibleCount <> 0);
end;
procedure TcxCustomGridTableFiltering.MRUItemsVisibleCountChanged(AOldCount, ANewCount: Integer);
begin
if FMRUItemsList and ((AOldCount = 0) or (ANewCount = 0)) then
Changed(vcSize);
end;
function TcxCustomGridTableFiltering.GetItemPopupDropDownWidth: Integer;
begin
Result := FItemPopup.DropDownWidth;
end;
function TcxCustomGridTableFiltering.GetItemPopupMaxDropDownItemCount: Integer;
begin
Result := FItemPopup.MaxDropDownItemCount;
end;
procedure TcxCustomGridTableFiltering.SetItemPopupDropDownWidth(Value: Integer);
begin
FItemPopup.DropDownWidth := Value;
end;
procedure TcxCustomGridTableFiltering.SetItemPopupMaxDropDownItemCount(Value: Integer);
begin
FItemPopup.MaxDropDownItemCount := Value;
end;
procedure TcxCustomGridTableFiltering.ReadItemPopupDropDownWidth(Reader: TReader);
begin
DropDownWidth := Reader.ReadInteger;
end;
procedure TcxCustomGridTableFiltering.ReadItemPopupMaxDropDownCount(Reader: TReader);
begin
MaxDropDownCount := Reader.ReadInteger;
end;
procedure TcxCustomGridTableFiltering.AddFilterToMRUItems(AFilter: TcxDataFilterCriteria = nil);
begin
if AFilter = nil then
AFilter := GridView.DataController.Filter;
FMRUItems.Add(AFilter);
end;
procedure TcxCustomGridTableFiltering.Assign(Source: TPersistent);
begin
if Source is TcxCustomGridTableFiltering then
with TcxCustomGridTableFiltering(Source) do
begin
Self.ItemFilteredItemsList := ItemFilteredItemsList;
Self.ItemMRUItemsList := ItemMRUItemsList;
Self.ItemMRUItemsListCount := ItemMRUItemsListCount;
Self.ItemPopup := ItemPopup;
Self.MRUItemsList := MRUItemsList;
Self.MRUItemsListCount := MRUItemsListCount;
end
else
inherited;
end;
procedure TcxCustomGridTableFiltering.RunCustomizeDialog(AItem: TcxCustomGridTableItem);
begin
if GridView.DoFilterDialogShow(AItem) then Exit;
if (AItem = nil) or IsFilterControlDialogNeeded(GridView.DataController.Filter) then
if not GridView.DoFilterCustomization then
ExecuteFilterControlDialog(GridView, GridView.LookAndFeel,
FilterControlDialogApply, GridView.OnFilterControlDialogShow, clDefault,
'', TcxCustomGrid(GridView.Control).Font)
else
else
if ShowFilterDialog(GridView.DataController.Filter, AItem,
AItem.GetProperties, AItem.FilterCaption, AItem.DataBinding.ValueTypeClass,
GridView.LookAndFeel, TcxCustomGrid(GridView.Control).Font) then
begin
GridView.DataController.Filter.Active := True;
AddFilterToMRUItems;
end;
end;
{ TcxCustomGridTableOptionsBehavior }
constructor TcxCustomGridTableOptionsBehavior.Create(AGridView: TcxCustomGridView);
begin
inherited;
FCopyCaptionsToClipboard := True;
FDragHighlighting := True;
FDragOpening := True;
FDragScrolling := True;
FImmediateEditor := True;
end;
function TcxCustomGridTableOptionsBehavior.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
procedure TcxCustomGridTableOptionsBehavior.SetAlwaysShowEditor(Value: Boolean);
begin
if FAlwaysShowEditor <> Value then
begin
FAlwaysShowEditor := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.SetBestFitMaxRecordCount(Value: Integer);
begin
if Value < 0 then Value := 0;
if FBestFitMaxRecordCount <> Value then
begin
FBestFitMaxRecordCount := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.SetCellHints(Value: Boolean);
begin
if FCellHints <> Value then
begin
FCellHints := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.SetCopyCaptionsToClipboard(Value: Boolean);
begin
if FCopyCaptionsToClipboard <> Value then
begin
FCopyCaptionsToClipboard := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.SetDragDropText(Value: Boolean);
begin
if FDragDropText <> Value then
begin
FDragDropText := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.SetDragFocusing(Value: TcxGridDragFocusing);
begin
if FDragFocusing <> Value then
begin
FDragFocusing := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.SetDragHighlighting(Value: Boolean);
begin
if FDragHighlighting <> Value then
begin
FDragHighlighting := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.SetDragOpening(Value: Boolean);
begin
if FDragOpening <> Value then
begin
FDragOpening := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.SetDragScrolling(Value: Boolean);
begin
if FDragScrolling <> Value then
begin
FDragScrolling := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.SetFocusCellOnCycle(Value: Boolean);
begin
if FFocusCellOnCycle <> Value then
begin
FFocusCellOnCycle := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.SetFocusCellOnTab(Value: Boolean);
begin
if FFocusCellOnTab <> Value then
begin
FFocusCellOnTab := Value;
with GridView.Site do
if FFocusCellOnTab then
Keys := Keys + [kTab]
else
Keys := Keys - [kTab];
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.SetFocusFirstCellOnNewRecord(Value: Boolean);
begin
if FFocusFirstCellOnNewRecord <> Value then
begin
FFocusFirstCellOnNewRecord := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.SetGoToNextCellOnEnter(Value: Boolean);
begin
if FGoToNextCellOnEnter <> Value then
begin
FGoToNextCellOnEnter := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.SetImmediateEditor(Value: Boolean);
begin
if FImmediateEditor <> Value then
begin
FImmediateEditor := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.SetIncSearch(Value: Boolean);
begin
if FIncSearch <> Value then
begin
if not Value then
GridView.Controller.CancelIncSearching;
FIncSearch := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.SetIncSearchItem(Value: TcxCustomGridTableItem);
begin
if FIncSearchItem <> Value then
begin
FIncSearchItem := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.SetNavigatorHints(Value: Boolean);
begin
if FNavigatorHints <> Value then
begin
FNavigatorHints := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.SetPullFocusing(Value: Boolean);
begin
if FPullFocusing <> Value then
begin
FPullFocusing := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsBehavior.Assign(Source: TPersistent);
begin
if Source is TcxCustomGridTableOptionsBehavior then
with TcxCustomGridTableOptionsBehavior(Source) do
begin
Self.AlwaysShowEditor := AlwaysShowEditor;
Self.BestFitMaxRecordCount := BestFitMaxRecordCount;
Self.CellHints := CellHints;
Self.CopyCaptionsToClipboard := CopyCaptionsToClipboard;
Self.DragDropText := DragDropText;
Self.DragFocusing := DragFocusing;
Self.DragHighlighting := DragHighlighting;
Self.DragOpening := DragOpening;
Self.DragScrolling := DragScrolling;
Self.FocusCellOnCycle := FocusCellOnCycle;
Self.FocusCellOnTab := FocusCellOnTab;
Self.FocusFirstCellOnNewRecord := FocusFirstCellOnNewRecord;
Self.GoToNextCellOnEnter := GoToNextCellOnEnter;
Self.ImmediateEditor := ImmediateEditor;
Self.IncSearch := IncSearch;
Self.IncSearchItem := IncSearchItem;
Self.NavigatorHints := NavigatorHints;
Self.PullFocusing := PullFocusing;
end;
inherited;
end;
{ TcxCustomGridTableOptionsCustomize }
constructor TcxCustomGridTableOptionsCustomize.Create(AGridView: TcxCustomGridView);
begin
inherited;
FItemFiltering := True;
FItemGrouping := True;
FItemMoving := True;
FItemSorting := True;
end;
procedure TcxCustomGridTableOptionsCustomize.SetItemFiltering(Value: Boolean);
begin
if FItemFiltering <> Value then
begin
FItemFiltering := Value;
Changed(vcSize);
end;
end;
procedure TcxCustomGridTableOptionsCustomize.SetItemGrouping(Value: Boolean);
begin
if FItemGrouping <> Value then
begin
FItemGrouping := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsCustomize.SetItemHiding(Value: Boolean);
begin
if FItemHiding <> Value then
begin
FItemHiding := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsCustomize.SetItemMoving(Value: Boolean);
begin
if FItemMoving <> Value then
begin
FItemMoving := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsCustomize.SetItemSorting(Value: Boolean);
begin
if FItemSorting <> Value then
begin
FItemSorting := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsCustomize.SetItemsQuickCustomization(Value: Boolean);
begin
if FItemsQuickCustomization <> Value then
begin
FItemsQuickCustomization := Value;
Changed(vcSize);
end;
end;
procedure TcxCustomGridTableOptionsCustomize.SetItemsQuickCustomizationMaxDropDownCount(Value: Integer);
begin
if Value < 0 then Value := 0;
if FItemsQuickCustomizationMaxDropDownCount <> Value then
begin
FItemsQuickCustomizationMaxDropDownCount := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsCustomize.SetItemsQuickCustomizationReordering(Value: TcxGridQuickCustomizationReordering);
begin
if FItemsQuickCustomizationReordering <> Value then
begin
FItemsQuickCustomizationReordering := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsCustomize.Assign(Source: TPersistent);
begin
if Source is TcxCustomGridTableOptionsCustomize then
with TcxCustomGridTableOptionsCustomize(Source) do
begin
Self.ItemFiltering := ItemFiltering;
Self.ItemGrouping := ItemGrouping;
Self.ItemHiding := ItemHiding;
Self.ItemMoving := ItemMoving;
Self.ItemSorting := ItemSorting;
Self.ItemsQuickCustomization := ItemsQuickCustomization;
Self.ItemsQuickCustomizationMaxDropDownCount := ItemsQuickCustomizationMaxDropDownCount;
Self.ItemsQuickCustomizationReordering := ItemsQuickCustomizationReordering;
end;
inherited;
end;
function TcxCustomGridTableOptionsCustomize.SupportsItemsQuickCustomizationReordering: Boolean;
begin
Result := GridView.IsDesigning or
(ItemsQuickCustomizationReordering = qcrEnabled) or
(ItemsQuickCustomizationReordering = qcrDefault) and ItemMoving;
end;
{ TcxCustomGridTableOptionsData }
constructor TcxCustomGridTableOptionsData.Create(AGridView: TcxCustomGridView);
begin
inherited;
FCancelOnExit := True;
FDeleting := True;
FDeletingConfirmation := True;
FEditing := True;
FInserting := True;
end;
function TcxCustomGridTableOptionsData.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
procedure TcxCustomGridTableOptionsData.SetAppending(Value: Boolean);
begin
if FAppending <> Value then
begin
FAppending := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsData.SetCancelOnExit(Value: Boolean);
begin
if FCancelOnExit <> Value then
begin
FCancelOnExit := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsData.SetDeleting(Value: Boolean);
begin
if FDeleting <> Value then
begin
FDeleting := Value;
GridView.RefreshNavigators;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsData.SetDeletingConfirmation(Value: Boolean);
begin
if FDeletingConfirmation <> Value then
begin
FDeletingConfirmation := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsData.SetEditing(Value: Boolean);
begin
if FEditing <> Value then
begin
FEditing := Value;
if not FEditing then
GridView.Controller.EditingItem := nil;
GridView.RefreshNavigators;
Changed(vcLayout);
end;
end;
procedure TcxCustomGridTableOptionsData.SetInserting(Value: Boolean);
begin
if FInserting <> Value then
begin
FInserting := Value;
GridView.RefreshNavigators;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsData.Assign(Source: TPersistent);
begin
if Source is TcxCustomGridTableOptionsData then
with TcxCustomGridTableOptionsData(Source) do
begin
Self.Appending := Appending;
Self.CancelOnExit := CancelOnExit;
Self.Deleting := Deleting;
Self.DeletingConfirmation := DeletingConfirmation;
Self.Editing := Editing;
Self.Inserting := Inserting;
end;
inherited;
end;
{ TcxCustomGridTableOptionsSelection }
constructor TcxCustomGridTableOptionsSelection.Create(AGridView: TcxCustomGridView);
begin
inherited;
FCellSelect := True;
FHideFocusRectOnExit := True;
FInvertSelect := True;
FUnselectFocusedRecordOnExit := True;
end;
function TcxCustomGridTableOptionsSelection.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
function TcxCustomGridTableOptionsSelection.GetMultiSelect: Boolean;
begin
Result := GridView.DataController.MultiSelect;
end;
procedure TcxCustomGridTableOptionsSelection.SetHideFocusRectOnExit(Value: Boolean);
begin
if FHideFocusRectOnExit <> Value then
begin
FHideFocusRectOnExit := Value;
Changed(vcLayout);
end;
end;
procedure TcxCustomGridTableOptionsSelection.SetHideSelection(Value: Boolean);
begin
if FHideSelection <> Value then
begin
FHideSelection := Value;
Changed(vcLayout);
end;
end;
procedure TcxCustomGridTableOptionsSelection.SetUnselectFocusedRecordOnExit(Value: Boolean);
begin
if FUnselectFocusedRecordOnExit <> Value then
begin
FUnselectFocusedRecordOnExit := Value;
Changed(vcProperty);
end;
end;
function TcxCustomGridTableOptionsSelection.IsInvertSelectStored: Boolean;
begin
Result := not FInvertSelect;
end;
function TcxCustomGridTableOptionsSelection.IsMultiSelectStored: Boolean;
begin
Result := MultiSelect;
end;
procedure TcxCustomGridTableOptionsSelection.SetCellSelect(Value: Boolean);
begin
if FCellSelect <> Value then
begin
FCellSelect := Value;
if FCellSelect then
GridView.Controller.FocusFirstAvailableItem
else
GridView.Controller.FocusedItem := nil;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsSelection.SetInvertSelect(Value: Boolean);
begin
if FInvertSelect <> Value then
begin
FInvertSelect := Value;
Changed(vcLayout);
end;
end;
procedure TcxCustomGridTableOptionsSelection.SetMultiSelect(Value: Boolean);
begin
if MultiSelect <> Value then
begin
GridView.DataController.MultiSelect := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableOptionsSelection.Assign(Source: TPersistent);
begin
if Source is TcxCustomGridTableOptionsSelection then
with TcxCustomGridTableOptionsSelection(Source) do
begin
Self.CellSelect := CellSelect;
Self.HideFocusRectOnExit := HideFocusRectOnExit;
Self.HideSelection := HideSelection;
Self.InvertSelect := InvertSelect;
Self.MultiSelect := MultiSelect;
Self.UnselectFocusedRecordOnExit := UnselectFocusedRecordOnExit;
end;
inherited;
end;
{ TcxCustomGridTableOptionsView }
constructor TcxCustomGridTableOptionsView.Create(AGridView: TcxCustomGridView);
begin
inherited;
FFocusRect := True;
FNavigatorOffset := cxGridNavigatorDefaultOffset;
FNoDataToDisplayInfoText := scxGridNoDataInfoText;
FShowItemFilterButtons := sfbWhenSelected;
end;
function TcxCustomGridTableOptionsView.GetGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GridView);
end;
procedure TcxCustomGridTableOptionsView.SetCellAutoHeight(Value: Boolean);
begin
if FCellAutoHeight <> Value then
begin
FCellAutoHeight := Value;
Changed(vcSize);
end;
end;
procedure TcxCustomGridTableOptionsView.SetCellEndEllipsis(Value: Boolean);
begin
if FCellEndEllipsis <> Value then
begin
FCellEndEllipsis := Value;
Changed(vcLayout);
end;
end;
procedure TcxCustomGridTableOptionsView.SetCellTextMaxLineCount(Value: Integer);
begin
if Value < 0 then Value := 0;
if FCellTextMaxLineCount <> Value then
begin
FCellTextMaxLineCount := Value;
Changed(vcSize);
end;
end;
procedure TcxCustomGridTableOptionsView.SetFocusRect(Value: Boolean);
begin
if FFocusRect <> Value then
begin
FFocusRect := Value;
Changed(vcLayout);
end;
end;
procedure TcxCustomGridTableOptionsView.SetItemCaptionAutoHeight(Value: Boolean);
begin
if FItemCaptionAutoHeight <> Value then
begin
FItemCaptionAutoHeight := Value;
ItemCaptionAutoHeightChanged;
end;
end;
procedure TcxCustomGridTableOptionsView.SetItemCaptionEndEllipsis(Value: Boolean);
begin
if FItemCaptionEndEllipsis <> Value then
begin
FItemCaptionEndEllipsis := Value;
Changed(vcLayout);
end;
end;
procedure TcxCustomGridTableOptionsView.SetNavigator(Value: Boolean);
begin
if FNavigator <> Value then
begin
FNavigator := Value;
Changed(vcSize);
end;
end;
procedure TcxCustomGridTableOptionsView.SetNavigatorOffset(Value: Integer);
begin
if Value < 0 then Value := 0;
if FNavigatorOffset <> Value then
begin
FNavigatorOffset := Value;
Changed(vcSize);
end;
end;
procedure TcxCustomGridTableOptionsView.SetNoDataToDisplayInfoText(const Value: string);
begin
if FNoDataToDisplayInfoText <> Value then
begin
FNoDataToDisplayInfoText := Value;
Changed(vcLayout);
end;
end;
procedure TcxCustomGridTableOptionsView.SetShowEditButtons(Value: TcxGridShowEditButtons);
begin
if FShowEditButtons <> Value then
begin
FShowEditButtons := Value;
Changed(vcSize);
end;
end;
procedure TcxCustomGridTableOptionsView.SetShowItemFilterButtons(Value: TcxGridShowItemFilterButtons);
begin
if FShowItemFilterButtons <> Value then
begin
FShowItemFilterButtons := Value;
Changed(vcSize);
end;
end;
function TcxCustomGridTableOptionsView.IsNoDataToDisplayInfoTextAssigned: Boolean;
begin
Result := FNoDataToDisplayInfoText <> scxGridNoDataInfoText;
end;
procedure TcxCustomGridTableOptionsView.ItemCaptionAutoHeightChanged;
begin
Changed(vcSize);
end;
procedure TcxCustomGridTableOptionsView.Assign(Source: TPersistent);
begin
if Source is TcxCustomGridTableOptionsView then
with TcxCustomGridTableOptionsView(Source) do
begin
Self.CellAutoHeight := CellAutoHeight;
Self.CellEndEllipsis := CellEndEllipsis;
Self.CellTextMaxLineCount := CellTextMaxLineCount;
Self.FocusRect := FocusRect;
Self.ItemCaptionAutoHeight := ItemCaptionAutoHeight;
Self.ItemCaptionEndEllipsis := ItemCaptionEndEllipsis;
Self.Navigator := Navigator;
Self.NavigatorOffset := NavigatorOffset;
Self.NoDataToDisplayInfoText := NoDataToDisplayInfoText;
Self.ShowEditButtons := ShowEditButtons;
Self.ShowItemFilterButtons := ShowItemFilterButtons;
end;
inherited;
end;
function TcxCustomGridTableOptionsView.GetNoDataToDisplayInfoText: string;
begin
if IsNoDataToDisplayInfoTextAssigned then
Result := FNoDataToDisplayInfoText
else
Result := cxGetResourceString(@scxGridNoDataInfoText);
end;
{ TcxGridCellPos }
constructor TcxGridCellPos.Create(AGridRecord: TcxCustomGridRecord; AItem: TObject);
begin
inherited Create;
GridRecord := AGridRecord;
Item := AItem;
end;
{ TcxGridDataCellPos }
constructor TcxGridDataCellPos.Create(AGridRecord: TcxCustomGridRecord;
AItem: TcxCustomGridTableItem);
begin
inherited Create;
GridRecord := AGridRecord;
Item := AItem;
end;
{ TcxCustomGridTableViewStyles }
function TcxCustomGridTableViewStyles.GetGridViewValue: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited GetGridView);
end;
procedure TcxCustomGridTableViewStyles.SetOnGetContentStyle(Value: TcxGridGetCellStyleEvent);
begin
if @FOnGetContentStyle <> @Value then
begin
FOnGetContentStyle := Value;
GridView.Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableViewStyles.GetDefaultViewParams(Index: Integer; AData: TObject;
out AParams: TcxViewParams);
const
StyleIndexes: array[Boolean] of Integer = (vsContentEven, vsContentOdd);
begin
inherited;
with AParams, LookAndFeelPainter do
case Index of
vsContent:
begin
if AData is TcxCustomGridRecord then
GetDefaultViewParams(StyleIndexes[Odd(TcxCustomGridRecord(AData).Index)],
AData, AParams)
else
begin
Color := DefaultContentColor;
TextColor := DefaultContentTextColor;
end;
end;
vsContentEven:
begin
Color := DefaultContentEvenColor;
TextColor := DefaultContentTextColor;
end;
vsContentOdd:
begin
Color := DefaultContentOddColor;
TextColor := DefaultContentTextColor;
end;
vsFilterBox:
begin
Color := DefaultFilterBoxColor;
TextColor := DefaultFilterBoxTextColor;
end;
vsInactive:
begin
if AData <> nil then
with TcxGridCellPos(AData) do
GetCellContentParams(GridRecord, Item, AParams);
Color := DefaultInactiveColor;
TextColor := DefaultInactiveTextColor;
end;
vsIncSearch:
begin
Color := clDefault;
TextColor := clDefault;
end;
vsSelection:
begin
if AData <> nil then
with TcxGridCellPos(AData) do
GetCellContentParams(GridRecord, Item, AParams);
Color := DefaultSelectionColor;
TextColor := DefaultSelectionTextColor;
end;
end;
end;
procedure TcxCustomGridTableViewStyles.GetSelectionParams(ARecord: TcxCustomGridRecord;
AItem: TObject; out AParams: TcxViewParams);
var
ACellPos: TcxGridCellPos;
begin
if ARecord <> nil then
ACellPos := TcxGridCellPos.Create(ARecord, AItem)
else
ACellPos := nil;
try
if GridView.DrawRecordActive(ARecord) then
GetViewParams(vsSelection, ACellPos, nil, AParams)
else
GetViewParams(vsInactive, ACellPos, nil, AParams);
finally
ACellPos.Free;
end;
AParams.Bitmap := nil; // to use selection color even if [content] bitmap is assigned
end;
procedure TcxCustomGridTableViewStyles.Assign(Source: TPersistent);
begin
inherited;
if Source is TcxCustomGridTableViewStyles then
with TcxCustomGridTableViewStyles(Source) do
begin
Self.Content := Content;
Self.ContentEven := ContentEven;
Self.ContentOdd := ContentOdd;
Self.FilterBox := FilterBox;
Self.Inactive := Inactive;
Self.IncSearch := IncSearch;
Self.Selection := Selection;
Self.OnGetContentStyle := OnGetContentStyle;
end;
end;
procedure TcxCustomGridTableViewStyles.GetCellContentParams(ARecord: TcxCustomGridRecord;
AItem: TObject; out AParams: TcxViewParams);
begin
if (AItem = nil) or (AItem is TcxCustomGridTableItem) then
GetDataCellContentParams(ARecord, TcxCustomGridTableItem(AItem), AParams);
end;
procedure TcxCustomGridTableViewStyles.GetContentParams(ARecord: TcxCustomGridRecord;
AItem: TcxCustomGridTableItem; out AParams: TcxViewParams);
const
StyleIndexes: array[Boolean] of Integer = (vsContentEven, vsContentOdd);
var
AStyle: TcxStyle;
ADataCellPos: TcxGridDataCellPos;
begin
AStyle := nil;
if (ARecord <> nil) and Assigned(FOnGetContentStyle) then
FOnGetContentStyle(GridView, ARecord, AItem, AStyle);
if (ARecord <> nil) and (GetValue(StyleIndexes[Odd(ARecord.Index)]) <> nil) then
begin
ADataCellPos := TcxGridDataCellPos.Create(ARecord, AItem);
try
GetViewParams(StyleIndexes[Odd(ARecord.Index)], ADataCellPos, AStyle, AParams);
finally
ADataCellPos.Free;
end;
end
else
GetViewParams(vsContent, ARecord, AStyle, AParams);
end;
procedure TcxCustomGridTableViewStyles.GetDataCellContentParams(ARecord: TcxCustomGridRecord;
AItem: TcxCustomGridTableItem; out AParams: TcxViewParams);
begin
if AItem = nil then
GetRecordContentParams(ARecord, AItem, AParams)
else
AItem.Styles.GetContentParams(ARecord, AParams);
end;
procedure TcxCustomGridTableViewStyles.GetDataCellParams(ARecord: TcxCustomGridRecord;
AItem: TcxCustomGridTableItem; out AParams: TcxViewParams;
AUseViewInfo: Boolean = False; ACellViewInfo: TcxGridTableCellViewInfo = nil;
AIgnoreSelection: Boolean = False);
begin
if not AIgnoreSelection and
(AUseViewInfo and ACellViewInfo.Selected or
not AUseViewInfo and GridView.DrawDataCellSelected(ARecord, AItem, False, nil)) then
GetSelectionParams(ARecord, AItem, AParams)
else
GetDataCellContentParams(ARecord, AItem, AParams);
end;
procedure TcxCustomGridTableViewStyles.GetRecordContentParams(ARecord: TcxCustomGridRecord;
AItem: TcxCustomGridTableItem; out AParams: TcxViewParams);
begin
GetContentParams(ARecord, AItem, AParams);
end;
{ TcxGridOpenTableItemList }
function TcxGridOpenTableItemList.GetItem(Index: Integer): TcxCustomGridTableItem;
begin
Result := TcxCustomGridTableItem(inherited Items[Index]);
end;
procedure TcxGridOpenTableItemList.SetItem(Index: Integer; Value: TcxCustomGridTableItem);
begin
inherited Items[Index] := Value;
end;
{ TcxCustomGridTableView }
destructor TcxCustomGridTableView.Destroy;
begin
Controller.EditingController.EditingItem := nil;
inherited;
end;
function TcxCustomGridTableView.GetBackgroundBitmaps: TcxCustomGridTableBackgroundBitmaps;
begin
Result := TcxCustomGridTableBackgroundBitmaps(inherited BackgroundBitmaps);
end;
function TcxCustomGridTableView.GetController: TcxCustomGridTableController;
begin
Result := TcxCustomGridTableController(inherited Controller);
end;
function TcxCustomGridTableView.GetFilterableItem(Index: Integer): TcxCustomGridTableItem;
begin
Result := TcxCustomGridTableItem(FFilterableItems[Index]);
end;
function TcxCustomGridTableView.GetFilterableItemCount: Integer;
begin
Result := FFilterableItems.Count;
end;
function TcxCustomGridTableView.GetGroupedItem(Index: Integer): TcxCustomGridTableItem;
begin
Result := Items[DataController.Groups.GroupingItemIndex[Index]];
end;
function TcxCustomGridTableView.GetGroupedItemCount: Integer;
begin
Result := DataController.Groups.GroupingItemCount;
end;
function TcxCustomGridTableView.GetItem(Index: Integer): TcxCustomGridTableItem;
begin
Result := TcxCustomGridTableItem(FItems[Index]);
end;
function TcxCustomGridTableView.GetItemCount: Integer;
begin
Result := FItems.Count;
end;
function TcxCustomGridTableView.GetMasterGridRecord: TcxCustomGridRecord;
begin
if MasterGridRecordIndex = -1 then
Result := nil
else
if (MasterGridView as TcxCustomGridTableView).ViewData.IsRecordIndexValid(MasterGridRecordIndex) then
Result := TcxCustomGridTableView(MasterGridView).ViewData.Records[MasterGridRecordIndex]
else
Result := nil;
end;
function TcxCustomGridTableView.GetOptionsBehavior: TcxCustomGridTableOptionsBehavior;
begin
Result := TcxCustomGridTableOptionsBehavior(inherited OptionsBehavior);
end;
function TcxCustomGridTableView.GetOptionsData: TcxCustomGridTableOptionsData;
begin
Result := TcxCustomGridTableOptionsData(inherited OptionsData);
end;
function TcxCustomGridTableView.GetOptionsSelection: TcxCustomGridTableOptionsSelection;
begin
Result := TcxCustomGridTableOptionsSelection(inherited OptionsSelection);
end;
function TcxCustomGridTableView.GetOptionsView: TcxCustomGridTableOptionsView;
begin
Result := TcxCustomGridTableOptionsView(inherited OptionsView);
end;
function TcxCustomGridTableView.GetPainter: TcxCustomGridTablePainter;
begin
Result := TcxCustomGridTablePainter(inherited Painter);
end;
function TcxCustomGridTableView.GetPatternGridView: TcxCustomGridTableView;
begin
Result := TcxCustomGridTableView(inherited PatternGridView);
end;
function TcxCustomGridTableView.GetNavigatorButtonsControl: IcxNavigator;
begin
Result := Self;
end;
function TcxCustomGridTableView.GetSortedItem(Index: Integer): TcxCustomGridTableItem;
begin
Result := Items[DataController.GetSortingItemIndex(Index)];
end;
function TcxCustomGridTableView.GetSortedItemCount: Integer;
begin
Result := DataController.GetSortingItemCount;
end;
function TcxCustomGridTableView.GetStyles: TcxCustomGridTableViewStyles;
begin
Result := TcxCustomGridTableViewStyles(inherited Styles);
end;
function TcxCustomGridTableView.GetViewData: TcxCustomGridTableViewData;
begin
Result := TcxCustomGridTableViewData(inherited ViewData);
end;
function TcxCustomGridTableView.GetViewInfo: TcxCustomGridTableViewInfo;
begin
Result := TcxCustomGridTableViewInfo(inherited ViewInfo);
end;
function TcxCustomGridTableView.GetVisibleItem(Index: Integer): TcxCustomGridTableItem;
begin
Result := TcxCustomGridTableItem(FVisibleItems[Index]);
end;
function TcxCustomGridTableView.GetVisibleItemCount: Integer;
begin
Result := FVisibleItems.Count;
end;
procedure TcxCustomGridTableView.SetBackgroundBitmaps(Value: TcxCustomGridTableBackgroundBitmaps);
begin
inherited BackgroundBitmaps := Value;
end;
procedure TcxCustomGridTableView.SetDateTimeHandling(Value: TcxCustomGridTableDateTimeHandling);
begin
FDateTimeHandling.Assign(Value);
end;
procedure TcxCustomGridTableView.SetFilterBox(Value: TcxGridFilterBox);
begin
FFilterBox.Assign(Value);
end;
procedure TcxCustomGridTableView.SetFiltering(Value: TcxCustomGridTableFiltering);
begin
FFiltering.Assign(Value);
end;
procedure TcxCustomGridTableView.SetItem(Index: Integer; Value: TcxCustomGridTableItem);
begin
Items[Index].Assign(Value);
end;
procedure TcxCustomGridTableView.SetNavigatorButtons(Value: TcxNavigatorControlButtons);
begin
FNavigatorButtons.Assign(Value);
end;
procedure TcxCustomGridTableView.SetOnCanFocusRecord(Value: TcxGridAllowRecordOperationEvent);
begin
if @FOnCanFocusRecord <> @Value then
begin
FOnCanFocusRecord := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnCanSelectRecord(Value: TcxGridAllowRecordOperationEvent);
begin
if @FOnCanSelectRecord <> @Value then
begin
FOnCanSelectRecord := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnCellClick(Value: TcxGridCellClickEvent);
begin
if @FOnCellClick <> @Value then
begin
FOnCellClick := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnCellDblClick(Value: TcxGridCellClickEvent);
begin
if @FOnCellDblClick <> @Value then
begin
FOnCellDblClick := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnCustomDrawCell(Value: TcxGridTableDataCellCustomDrawEvent);
begin
if @FOnCustomDrawCell <> @Value then
begin
FOnCustomDrawCell := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnCustomDrawPartBackground(Value: TcxGridPartCustomDrawBackgroundEvent);
begin
if @FOnCustomDrawPartBackground <> @Value then
begin
FOnCustomDrawPartBackground := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnEditChanged(Value: TcxGridCustomTableItemEvent);
begin
if @FOnEditChanged <> @Value then
begin
FOnEditChanged := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnEditing(Value: TcxGridEditingEvent);
begin
if @FOnEditing <> @Value then
begin
FOnEditing := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnEditKeyDown(Value: TcxGridEditKeyEvent);
begin
if @FOnEditKeyDown <> @Value then
begin
FOnEditKeyDown := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnEditKeyPress(Value: TcxGridEditKeyPressEvent);
begin
if @FOnEditKeyPress <> @Value then
begin
FOnEditKeyPress := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnEditKeyUp(Value: TcxGridEditKeyEvent);
begin
if @FOnEditKeyUp <> @Value then
begin
FOnEditKeyUp := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnEditValueChanged(Value: TcxGridCustomTableItemEvent);
begin
if @FOnEditValueChanged <> @Value then
begin
FOnEditValueChanged := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnFilterControlDialogShow(Value: TNotifyEvent);
begin
if @FOnFilterControlDialogShow <> @Value then
begin
FOnFilterControlDialogShow := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnFilterCustomization(Value: TcxGridFilterCustomizationEvent);
begin
if @FOnFilterCustomization <> @Value then
begin
FOnFilterCustomization := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnFilterDialogShow(Value: TcxGridFilterDialogShowEvent);
begin
if @FOnFilterDialogShow <> @Value then
begin
FOnFilterDialogShow := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnFocusedItemChanged(Value: TcxGridFocusedItemChangedEvent);
begin
if @FOnFocusedItemChanged <> @Value then
begin
FOnFocusedItemChanged := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnFocusedRecordChanged(Value: TcxGridFocusedRecordChangedEvent);
begin
if @FOnFocusedRecordChanged <> @Value then
begin
FOnFocusedRecordChanged := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnGetCellHeight(Value: TcxGridGetCellHeightEvent);
begin
if @FOnGetCellHeight <> @Value then
begin
FOnGetCellHeight := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnGetDragDropText(Value: TcxGridGetDragDropTextEvent);
begin
if @FOnGetDragDropText <> @Value then
begin
FOnGetDragDropText := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnInitFilteringDateRanges(Value: TcxGridInitDateRangesEvent);
begin
if @FOnInitFilteringDateRanges <> @Value then
begin
FOnInitFilteringDateRanges := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnInitGroupingDateRanges(Value: TcxGridInitDateRangesEvent);
begin
if @FOnInitGroupingDateRanges <> @Value then
begin
FOnInitGroupingDateRanges := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnInitEdit(Value: TcxGridInitEditEvent);
begin
if @FOnInitEdit <> @Value then
begin
FOnInitEdit := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnInitEditValue(Value: TcxGridInitEditValueEvent);
begin
if @FOnInitEditValue <> @Value then
begin
FOnInitEditValue := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnSelectionChanged(Value: TcxGridCustomTableViewEvent);
begin
if @FOnSelectionChanged <> @Value then
begin
FOnSelectionChanged := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOnTopRecordIndexChanged(Value: TNotifyEvent);
begin
if @FOnTopRecordIndexChanged <> @Value then
begin
FOnTopRecordIndexChanged := Value;
Changed(vcProperty);
end;
end;
procedure TcxCustomGridTableView.SetOptionsBehavior(Value: TcxCustomGridTableOptionsBehavior);
begin
inherited OptionsBehavior := Value;
end;
procedure TcxCustomGridTableView.SetOptionsCustomize(Value: TcxCustomGridTableOptionsCustomize);
begin
FOptionsCustomize.Assign(Value);
end;
procedure TcxCustomGridTableView.SetOptionsData(Value: TcxCustomGridTableOptionsData);
begin
inherited OptionsData := Value;
end;
procedure TcxCustomGridTableView.SetOptionsSelection(Value: TcxCustomGridTableOptionsSelection);
begin
inherited OptionsSelection := Value;
end;
procedure TcxCustomGridTableView.SetOptionsView(Value: TcxCustomGridTableOptionsView);
begin
inherited OptionsView := Value;
end;
procedure TcxCustomGridTableView.SetStyles(Value: TcxCustomGridTableViewStyles);
begin
inherited Styles := Value;
end;
procedure TcxCustomGridTableView.CopyForEachRowProc(ARowIndex: Integer; ARowInfo: TcxRowInfo);
var
I, AIndex: Integer;
begin
if (Length(FCopyToClipboardStr) >= Length(EndOfLine)) and
(Copy(FCopyToClipboardStr, Length(FCopyToClipboardStr) - Length(EndOfLine) + 1, Length(EndOfLine)) <> EndOfLine) then
FCopyToClipboardStr := FCopyToClipboardStr + EndOfLine;
for I := 0 to FCopyToClipboardItems.Count - 1 do
begin
AIndex := TcxCustomGridTableItem(FCopyToClipboardItems[I]).Index;
FCopyToClipboardStr := FCopyToClipboardStr +
DataController.GetRowDisplayText(ARowInfo, AIndex) + ColumnSeparator;
if ARowInfo.Level < DataController.Groups.GroupingItemCount then // it's a group row
Break;
end;
if FCopyToClipboardItems.Count <> 0 then
FCopyToClipboardStr := Copy(FCopyToClipboardStr, 1,
Length(FCopyToClipboardStr) - Length(ColumnSeparator));
end;
procedure TcxCustomGridTableView.RefreshItemIndexes;
var
I: Integer;
begin
for I := 0 to ItemCount - 1 do
Items[I].FIndex := I;
end;
function TcxCustomGridTableView.GetFilterCaption(Index: Integer): string;
begin
Result := FilterableItems[Index].FilterCaption;
end;
function TcxCustomGridTableView.GetFilterCount: Integer;
begin
Result := FilterableItemCount;
end;
function TcxCustomGridTableView.GetFilterCriteria: TcxFilterCriteria;
begin
Result := DataController.Filter;
end;
function TcxCustomGridTableView.GetFilterFieldName(Index: Integer): string;
begin
Result := FilterableItems[Index].DataBinding.FilterFieldName;
end;
function TcxCustomGridTableView.GetFilterItemLink(Index: Integer): TObject;
begin
Result := FilterableItems[Index];
end;
function TcxCustomGridTableView.GetFilterItemLinkID(Index: Integer): Integer;
begin
Result := FilterableItems[Index].ID;
end;
function TcxCustomGridTableView.GetFilterItemLinkName(Index: Integer): string;
begin
Result := FilterableItems[Index].Name;
end;
function TcxCustomGridTableView.GetFilterProperties(Index: Integer): TcxCustomEditProperties;
begin
Result := FilterableItems[Index].GetProperties;
end;
function TcxCustomGridTableView.GetFilterValueType(Index: Integer): cxDataStorage.TcxValueTypeClass;
begin
Result := FilterableItems[Index].DataBinding.ValueTypeClass;
end;
function TcxCustomGridTableView.NavigatorIsActive: Boolean;
begin
Result := DataController.Active;
end;
function TcxCustomGridTableView.NavigatorIsBof: Boolean;
var
AIcxGridDataController: IcxGridDataController;
begin
if Supports(TObject(DataController), IcxGridDataController, AIcxGridDataController) then
Result := AIcxGridDataController.GetNavigatorIsBof
else
Result := False;
end;
function TcxCustomGridTableView.NavigatorIsEof: Boolean;
var
AIcxGridDataController: IcxGridDataController;
begin
if Supports(TObject(DataController), IcxGridDataController, AIcxGridDataController) then
Result := AIcxGridDataController.GetNavigatorIsEof
else
Result := False;
end;
function TcxCustomGridTableView.NavigatorCanAppend: Boolean;
begin
Result := Controller.CanAppend(True);
end;
function TcxCustomGridTableView.NavigatorCanEdit: Boolean;
begin
Result := Controller.CanEdit;
end;
function TcxCustomGridTableView.NavigatorCanDelete: Boolean;
begin
Result := Controller.CanDelete(True);
end;
function TcxCustomGridTableView.NavigatorCanInsert: Boolean;
begin
Result := Controller.CanInsert(True);
end;
function TcxCustomGridTableView.NavigatorIsEditing: Boolean;
begin
Result := DataController.IsEditing;
end;
procedure TcxCustomGridTableView.NavigatorClearBookmark;
begin
DataController.ClearBookmark;
end;
function TcxCustomGridTableView.NavigatorIsBookmarkAvailable: Boolean;
begin
Result := DataController.IsBookmarkAvailable;
end;
procedure TcxCustomGridTableView.NavigatorDoAction(AButtonIndex: Integer);
var
APrevAllowAppendRecord: Boolean;
begin
case AButtonIndex of
NBDI_FIRST:
Controller.GoToFirst;
NBDI_PRIORPAGE:
Controller.FocusPrevPage(True);
NBDI_PRIOR:
Controller.GoToPrev(False);
NBDI_NEXT:
begin
APrevAllowAppendRecord := Controller.AllowAppendRecord;
Controller.AllowAppendRecord := False;
try
Controller.GoToNext(False);
finally
Controller.AllowAppendRecord := APrevAllowAppendRecord;
end;
end;
NBDI_NEXTPAGE:
Controller.FocusNextPage(True);
NBDI_LAST:
Controller.GoToLast(False);
NBDI_INSERT, NBDI_APPEND:
Controller.CreateNewRecord(AButtonIndex = NBDI_APPEND);
NBDI_DELETE:
Controller.DeleteSelection;
NBDI_EDIT:
begin
DataController.Edit;
Controller.FocusedItem.Editing := True;
end;
NBDI_POST:
begin
Controller.EditingController.UpdateValue;
DataController.Post(True);
end;
NBDI_CANCEL:
DataController.Cancel;
NBDI_REFRESH:
DataController.RefreshExternalData;
NBDI_SAVEBOOKMARK:
DataController.SaveBookmark;
NBDI_GOTOBOOKMARK:
DataController.GotoBookmark;
NBDI_FILTER:
FFiltering.RunCustomizeDialog;
end;
end;
function TcxCustomGridTableView.NavigatorGetNotifier: TcxNavigatorControlNotifier;
begin
Result := FNavigatorNotifier;
end;
function TcxCustomGridTableView.NavigatorIsActionSupported(AButtonIndex: Integer): Boolean;
begin
Result := True;
end;
function TcxCustomGridTableView.GetProperties(AProperties: TStrings): Boolean;
procedure AddFilter;
var
I: Integer;
begin
with AProperties do
begin
Add('FilterActive');
Add('Filter');
if Filtering.MRUItemsList then
for I := Filtering.MRUItems.Count - 1 downto 0 do
Add(FilterMRUItemBaseName + IntToStr(I));
end;
end;
begin
if gsoUseFilter in StorageOptions then
AddFilter;
Result := inherited GetProperties(AProperties);
end;
procedure TcxCustomGridTableView.GetPropertyValue(const AName: string;
var AValue: Variant);
function GetFilter: Boolean;
var
AStream: TMemoryStream;
AIndex: Integer;
begin
Result := True;
if AName = 'FilterActive' then
AValue := DataController.Filter.Active
else
if AName = 'Filter' then
begin
AStream := TMemoryStream.Create;
try
DataController.Filter.WriteData(AStream);
AValue := StreamToString(AStream);
finally
AStream.Free;
end;
end
else
if Pos(FilterMRUItemBaseName, AName) = 1 then
begin
AIndex := StrToInt(Copy(AName, Length(FilterMRUItemBaseName) + 1, MaxInt));
AStream := Filtering.MRUItems[AIndex].GetStream;
try
AValue := StreamToString(AStream);
finally
AStream.Free;
end;
end
else
Result := False;
end;
begin
if (gsoUseFilter in StorageOptions) and GetFilter then Exit;
inherited;
end;
procedure TcxCustomGridTableView.SetPropertyValue(const AName: string;
const AValue: Variant);
function SetFilter: Boolean;
var
AStream: TMemoryStream;
AFilter: TcxDataFilterCriteria;
begin
Result := True;
if AName = 'FilterActive' then
DataController.Filter.Active := StringToBoolean(AValue)
else
if AName = 'Filter' then
begin
AStream := TMemoryStream.Create;
try
StringToStream(AValue, AStream);
AStream.Position := 0;
DataController.Filter.ReadData(AStream);
finally
AStream.Free;
end;
end
else
if Pos(FilterMRUItemBaseName, AName) = 1 then
begin
AFilter := DataController.CreateFilter;
try
AStream := TMemoryStream.Create;
try
StringToStream(AValue, AStream);
AStream.Position := 0;
AFilter.ReadData(AStream);
Filtering.MRUItems.Add(AFilter);
finally
AStream.Free;
end;
finally
AFilter.Free;
end;
end
else
Result := False;
end;
begin
if (gsoUseFilter in StorageOptions) and SetFilter then Exit;
inherited;
end;
function TcxCustomGridTableView.CreateStoredObject(const AObjectName, AClassName: string): TObject;
function GetSummaryGroupIndex: Integer;
var
I: Integer;
AIndex: string;
begin
AIndex := '';
I := Length('SummaryGroup') + 1;
while AObjectName[I] <> '_' do
begin
AIndex := AIndex + AObjectName[I];
if I = Length(AObjectName) then
Break;
Inc(I);
end;
{$IFDEF DELPHI6}
if not TryStrToInt(AIndex, Result) then
Result := -1;
{$ELSE}
try
Result := StrToInt(AIndex);
except
on EConvertError do
Result := -1;
end;
{$ENDIF}
end;
function CreateSummary: TObject;
var
ASummaryGroupIndex: Integer;
begin
Result := nil;
if Pos('FooterSummaryItem', AObjectName) = 1 then
Result := DataController.Summary.FooterSummaryItems.Add
else
if Pos('DefaultGroupSummaryItem', AObjectName) = 1 then
Result := DataController.Summary.DefaultGroupSummaryItems.Add
else
if Pos('SummaryGroup', AObjectName) = 1 then
begin
ASummaryGroupIndex := GetSummaryGroupIndex;
if ASummaryGroupIndex >= 0 then
if Pos('Item', AObjectName) <> 0 then
begin
if ASummaryGroupIndex < DataController.Summary.SummaryGroups.Count then
Result := DataController.Summary.SummaryGroups[ASummaryGroupIndex].SummaryItems.Add;
end
else
if Pos('Link', AObjectName) <> 0 then
begin
if ASummaryGroupIndex < DataController.Summary.SummaryGroups.Count then
Result := DataController.Summary.SummaryGroups[ASummaryGroupIndex].Links.Add;
end
else
Result := DataController.Summary.SummaryGroups.Add;
end;
end;
begin
Result := nil;
if AClassName = GetItemClass.ClassName then
Result := CreateItem
else
if gsoUseSummary in StorageOptions then
Result := CreateSummary;
if Result = nil then
Result := inherited CreateStoredObject(AObjectName, AClassName);
end;
procedure TcxCustomGridTableView.GetStoredChildren(AChildren: TStringList);
var
I: Integer;
procedure AddSummary;
var
I, J: Integer;
begin
with DataController.Summary.FooterSummaryItems do
for I := 0 to Count - 1 do
AChildren.AddObject('FooterSummaryItem' + IntToStr(I), Items[I]);
with DataController.Summary.DefaultGroupSummaryItems do
for I := 0 to Count - 1 do
AChildren.AddObject('DefaultGroupSummaryItem' + IntToStr(I), Items[I]);
with DataController.Summary.SummaryGroups do
for I := 0 to Count - 1 do
begin
AChildren.AddObject('SummaryGroup' + IntToStr(I), Items[I]);
with Items[I].SummaryItems do
for J := 0 to Count - 1 do
AChildren.AddObject('SummaryGroup' + IntToStr(I) + '_Item' + IntToStr(J), Items[J]);
with Items[I].Links do
for J := 0 to Count - 1 do
AChildren.AddObject('SummaryGroup' + IntToStr(I) + '_Link' + IntToStr(J), Items[J]);
end;
end;
begin
for I := 0 to ItemCount - 1 do
AChildren.AddObject('', Items[I]);
if gsoUseSummary in StorageOptions then
AddSummary;
end;
procedure TcxCustomGridTableView.AssignLayout(ALayoutView: TcxCustomGridView);
var
I, ATag: Integer;
ALayoutItem, AItem: TcxCustomGridTableItem;
begin
inherited;
with ALayoutView as TcxCustomGridTableView do
begin
Self.BeginAssignItems;
try
for I := 0 to ItemCount - 1 do
begin
ALayoutItem := Items[I];
AItem := TcxCustomGridTableItem(ALayoutItem.DataBinding.Data);
ATag := AItem.Tag;
AItem.Assign(ALayoutItem);
AItem.Tag := ATag;
AItem.Index := ALayoutItem.Index;
end;
finally
Self.EndAssignItems;
end;
{
Self.DataController.Filter.AssignItems(DataController.Filter);
Self.DataController.Filter.Active := DataController.Filter.Active;}
end;
end;
procedure TcxCustomGridTableView.BeforeEditLayout(ALayoutView: TcxCustomGridView);
var
I: Integer;
begin
inherited;
with ALayoutView as TcxCustomGridTableView do
begin
with OptionsData do
begin
Appending := True;
Deleting := True;
Editing := True;
Inserting := True;
end;
OptionsSelection.CellSelect := True;
OptionsView.Navigator := True;
for I := 0 to ItemCount - 1 do
Items[I].DataBinding.Data := Self.Items[I];
end;
end;
function TcxCustomGridTableView.HasLayoutCustomizationForm: Boolean;
begin
Result := True;
end;
procedure TcxCustomGridTableView.BeforeRestoring;
begin
inherited;
BeginAssignItems;
FRestoringItems := TcxGridOpenTableItemList.Create;
end;
procedure TcxCustomGridTableView.AfterRestoring;
var
I: Integer;
begin
try
for I := 0 to FRestoringItems.Count - 1 do
if FRestoringItems[I] <> nil then
FRestoringItems[I].Index := I;
EndAssignItems;
finally
FRestoringItems.Free;
inherited;
end;
end;
procedure TcxCustomGridTableView.ReadState(Reader: TReader);
begin
BeginAssignItems;
try
inherited;
finally
EndAssignItems;
end;
end;
procedure TcxCustomGridTableView.BeginAssignItems;
begin
DoBeforeAssignItems;
FIsAssigningItems := True;
end;
procedure TcxCustomGridTableView.DoBeforeAssignItems;
begin
FAssigningGroupedItems := TcxGridOpenTableItemList.Create;
FAssigningSortedItems := TcxGridOpenTableItemList.Create;
end;
procedure TcxCustomGridTableView.DoItemsAssigned;
var
I: Integer;
begin
try
for I := 0 to FAssigningGroupedItems.Count - 1 do
if FAssigningGroupedItems[I] <> nil then // because of inherited forms
FAssigningGroupedItems[I].GroupIndex := I;
for I := 0 to FAssigningSortedItems.Count - 1 do
if FAssigningSortedItems[I] <> nil then // because of inherited forms
FAssigningSortedItems[I].SortIndex := I;
finally
FAssigningSortedItems.Free;
FAssigningGroupedItems.Free;
end;
end;
procedure TcxCustomGridTableView.EndAssignItems;
begin
FIsAssigningItems := False;
FIsAfterAssigningItems := True;
try
DoItemsAssigned;
finally
FIsAfterAssigningItems := False;
end;
end;
function TcxCustomGridTableView.CanOffset(ARecordCountDelta: Integer): Boolean;
begin
Result := not TcxCustomGrid(Control).UpdateLocked and Visible and
ViewInfo.CanOffsetView(ARecordCountDelta);
end;
function TcxCustomGridTableView.CanSelectRecord(ARecordIndex: Integer): Boolean;
begin
Result := True;
if Assigned(FOnCanSelectRecord) then
FOnCanSelectRecord(Self, ViewData.GetRecordByIndex(ARecordIndex), Result);
end;
function TcxCustomGridTableView.CanTabStop: Boolean;
begin
Result := inherited CanTabStop and not Controller.IsEditing;
end;
procedure TcxCustomGridTableView.DetailVisibleChanged(ADetailLevel: TComponent;
APrevVisibleDetailCount, AVisibleDetailCount: Integer);
var
I: Integer;
begin
inherited;
if IsPattern then
begin
BeginUpdate;
try
for I := 0 to CloneCount - 1 do
TcxCustomGridViewAccess(Clones[I]).DetailVisibleChanged(ADetailLevel,
APrevVisibleDetailCount, AVisibleDetailCount);
finally
EndUpdate;
end;
end
else
if (APrevVisibleDetailCount = 0) or (AVisibleDetailCount = 0) then
DataChanged;
end;
procedure TcxCustomGridTableView.DoAssign(ASource: TcxCustomGridView);
procedure AssignItems;
var
I: Integer;
AItem: TcxCustomGridTableItem;
begin
with TcxCustomGridTableView(ASource) do
begin
Self.BeginAssignItems;
try
for I := 0 to ItemCount - 1 do
begin
AItem := Self.FindItemByID(Items[I].ID);
if AItem = nil then
begin
AItem := Self.CreateItem;
AItem.FID := Items[I].ID;
end;
AItem.Index := I;
AItem.Assign(Items[I]);
end;
for I := Self.ItemCount - 1 downto ItemCount do
Self.Items[I].Free;
finally
Self.EndAssignItems;
end;
Self.FNextID := FNextID;
end;
end;
begin
if ASource is TcxCustomGridTableView then
begin
BeginUpdate; //!!! is it needed?
try
if not AssigningSettings then
AssignItems;
with TcxCustomGridTableView(ASource) do
begin
Self.DateTimeHandling := DateTimeHandling;
Self.FilterBox := FilterBox;
Self.Filtering := Filtering;
Self.NavigatorButtons := NavigatorButtons;
Self.OptionsCustomize := OptionsCustomize;
Self.OnCanFocusRecord := OnCanFocusRecord;
Self.OnCanSelectRecord := OnCanSelectRecord;
Self.OnCellClick := OnCellClick;
Self.OnCellDblClick := OnCellDblClick;
Self.OnCustomDrawCell := OnCustomDrawCell;
Self.OnCustomDrawPartBackground := OnCustomDrawPartBackground;
Self.OnEditing := OnEditing;
Self.OnEditChanged := OnEditChanged;
Self.OnEditKeyDown := OnEditKeyDown;
Self.OnEditKeyPress := OnEditKeyPress;
Self.OnEditKeyUp := OnEditKeyUp;
Self.OnEditValueChanged := OnEditValueChanged;
Self.OnFilterControlDialogShow := OnFilterControlDialogShow;
Self.OnFilterCustomization := OnFilterCustomization;
Self.OnFilterDialogShow := OnFilterDialogShow;
Self.OnFocusedItemChanged := OnFocusedItemChanged;
Self.OnFocusedRecordChanged := OnFocusedRecordChanged;
Self.OnGetCellHeight := OnGetCellHeight;
Self.OnGetDragDropText := OnGetDragDropText;
Self.OnInitFilteringDateRanges := OnInitFilteringDateRanges;
Self.OnInitGroupingDateRanges := OnInitGroupingDateRanges;
Self.OnInitEdit := OnInitEdit;
Self.OnInitEditValue := OnInitEditValue;
//Self.OnRecordCreated := OnRecordCreated;
//Self.OnRecordDestroying := OnRecordDestroying;
Self.OnSelectionChanged := OnSelectionChanged;
Self.OnTopRecordIndexChanged := OnTopRecordIndexChanged;
end;
finally
EndUpdate;
end;
end;
inherited;
end;
function TcxCustomGridTableView.FindItemByObjectName(const AObjectName: string): TcxCustomGridTableItem;
begin
if IsStoringNameMode then
if AObjectName = '' then
Result := nil
else
Result := FindItemByID(StrToInt(AObjectName))
else
Result := FindItemByName(AObjectName);
end;
procedure TcxCustomGridTableView.FocusEdit(AItemIndex: Integer; var ADone: Boolean);
begin
Items[AItemIndex].Editing := True;
ADone := Items[AItemIndex].Editing;
end;
procedure TcxCustomGridTableView.GetChildren(Proc: TGetChildProc; Root: TComponent);
var
I: Integer;
begin
inherited;
for I := 0 to ItemCount - 1 do
if Items[I].Owner = Root then Proc(Items[I]);
end;
function TcxCustomGridTableView.GetDefaultActiveDetailIndex: Integer;
var
AAvailableLevel: TcxGridLevel;
begin
AAvailableLevel := TcxGridLevel(Level).GetAvailableItem;
if AAvailableLevel = nil then
Result := -1
else
Result := AAvailableLevel.Index;
end;
procedure TcxCustomGridTableView.GetFakeComponentLinks(AList: TList);
var
I: Integer;
begin
inherited;
for I := 0 to ItemCount - 1 do
Items[I].Styles.GetFakeComponentLinks(AList);
end;
function TcxCustomGridTableView.GetIsControlFocused: Boolean;
begin
Result := inherited GetIsControlFocused or
Controller.EditingController.IsEditing and Controller.EditingController.Edit.IsFocused or
Controller.HasFilterMRUItemsPopup and Controller.FilterMRUItemsPopup.Visible or
Controller.HasFilterPopup and Controller.FilterPopup.Visible or
Controller.HasItemsCustomizationPopup and Controller.ItemsCustomizationPopup.Visible;
end;
procedure TcxCustomGridTableView.GetItemsListForClipboard(AItems: TList; ACopyAll: Boolean);
begin
GetVisibleItemsList(AItems);
end;
function TcxCustomGridTableView.GetItemSortByDisplayText(AItemIndex: Integer;
ASortByDisplayText: Boolean): Boolean;
begin
Result := Items[AItemIndex].IsSortingByDisplayText(ASortByDisplayText);
end;
function TcxCustomGridTableView.GetItemValueSource(AItemIndex: Integer): TcxDataEditValueSource;
var
AProperties: TcxCustomEditProperties;
begin
AProperties := Items[AItemIndex].GetProperties;
if AProperties = nil then
Result := evsText //!!!
else
Result := AProperties.GetEditValueSource(True);
end;
procedure TcxCustomGridTableView.GetVisibleItemsList(AItems: TList);
begin
CopyList(FVisibleItems, AItems);
end;
function TcxCustomGridTableView.HasCustomDrawCell: Boolean;
begin
Result := Assigned(FOnCustomDrawCell);
end;
function TcxCustomGridTableView.HasCustomDrawPartBackground: Boolean;
begin
Result := Assigned(FOnCustomDrawPartBackground);
end;
procedure TcxCustomGridTableView.Init;
begin
inherited;
if Controller.FocusedItem = nil then
Controller.FocusFirstAvailableItem;
end;
function TcxCustomGridTableView.IsDetailVisible(AGridView: TcxCustomGridView): Boolean;
var
AViewInfo: TcxCustomGridRecordViewInfo;
begin
if AGridView.MasterGridRecordIndex = -1 then
Result := False
else
begin
Result := ViewData.IsRecordIndexValid(AGridView.MasterGridRecordIndex);
if Result then
begin
AViewInfo := ViewData.Records[AGridView.MasterGridRecordIndex].ViewInfo;
Result := (AViewInfo <> nil) and AViewInfo.IsDetailVisible(AGridView);
end;
end;
end;
function TcxCustomGridTableView.IsEqualHeightRecords: Boolean;
begin
Result := not ViewInfo.RecordsViewInfo.AutoDataRecordHeight;
end;
function TcxCustomGridTableView.IsRecordHeightDependsOnData: Boolean;
begin
Result := ViewInfo.RecordsViewInfo.AutoRecordHeight or
ViewInfo.RecordsViewInfo.AutoDataRecordHeight or HasCustomProperties;
end;
function TcxCustomGridTableView.IsRecordHeightDependsOnFocus: Boolean;
begin
Result := ViewInfo.RecordsViewInfo.AutoDataRecordHeight and
(OptionsView.ShowEditButtons = gsebForFocusedRecord);
end;
procedure TcxCustomGridTableView.LoadingComplete;
begin
BeginUpdate;
try
inherited;
DataChanged;
finally
EndUpdate;
end;
end;
procedure TcxCustomGridTableView.Offset(ARecordCountDelta, DX, DY: Integer);
begin
ViewInfo.DoOffset(ARecordCountDelta, DX, DY);
if ARecordCountDelta <> 0 then
Painter.DoOffset(ViewInfo.RecordsViewInfo.ItemsOffset, 0, 0)
else
Painter.DoOffset(0, DX, DY);
end;
procedure TcxCustomGridTableView.SetChildOrder(Child: TComponent; Order: Integer);
begin
inherited;
if Child is TcxCustomGridTableItem then
TcxCustomGridTableItem(Child).Index := Order;
end;
procedure TcxCustomGridTableView.SetName(const NewName: TComponentName);
var
AOldName: TComponentName;
begin
AOldName := Name;
inherited;
if Name <> AOldName then
RenameComponents(Self, Owner, Name, AOldName, ItemCount,
@cxCustomGridTableViewGetItem);
end;
procedure TcxCustomGridTableView.UpdateControl(AInfo: TcxUpdateControlInfo);
begin
if IsDestroying then Exit;
if AInfo is TcxDataChangedInfo then
DataChanged
else
if AInfo is TcxLayoutChangedInfo then
DataLayoutChanged
else
if AInfo is TcxFocusedRecordChangedInfo then
with TcxFocusedRecordChangedInfo(AInfo) do
Controller.FocusedRecordChanged(PrevFocusedRowIndex, FocusedRowIndex, NewItemRowFocusingChanged)
else
if AInfo is TcxSelectionChangedInfo then
SelectionChanged(TcxSelectionChangedInfo(AInfo))
else
if AInfo is TcxSearchChangedInfo then
SearchChanged
else
if AInfo is TcxUpdateRecordInfo then
RecordChanged(TcxUpdateRecordInfo(AInfo).RecordIndex)
else
if AInfo is TcxGroupingChangingInfo then
GroupingChanging;
RefreshNavigators;
inherited;
end;
procedure TcxCustomGridTableView.UpdateDataController(AChange: TcxGridDataControllerChange;
AItem: TcxCustomGridTableItem);
begin
if {not IsDestroying and }(DataController <> nil) then
with DataController do
case AChange of
dccItemAdded:
AddItem(AItem);
dccItemRemoved:
RemoveItem(AItem);
dccIndexesChanged:
UpdateItemIndexes;
end;
end;
procedure TcxCustomGridTableView.UpdateRecord;
begin
Controller.EditingController.UpdateValue;
end;
procedure TcxCustomGridTableView.CreateHandlers;
begin
FItems := TList.Create;
FVisibleItems := TList.Create;
FFilterableItems := TList.Create;
FNavigatorNotifier := TcxNavigatorControlNotifier.Create;
inherited;
FNavigatorButtons := GetNavigatorButtonsClass.Create(ViewInfo);
FNavigatorButtons.OnGetControl := GetNavigatorButtonsControl;
FNavigatorButtons.ConfirmDelete := False;
end;
procedure TcxCustomGridTableView.DestroyHandlers;
begin
ClearItems;
FreeAndNil(FNavigatorButtons);
inherited;
FreeAndNil(FNavigatorNotifier);
FreeAndNil(FFilterableItems);
FreeAndNil(FVisibleItems);
FreeAndNil(FItems);
end;
procedure TcxCustomGridTableView.CreateOptions;
begin
inherited;
FDateTimeHandling := GetDateTimeHandlingClass.Create(Self);
FFilterBox := GetFilterBoxClass.Create(Self);
FFiltering := GetFilteringClass.Create(Self);
FOptionsCustomize := GetOptionsCustomizeClass.Create(Self);
end;
procedure TcxCustomGridTableView.DestroyOptions;
begin
FreeAndNil(FOptionsCustomize);
FreeAndNil(FFiltering);
FreeAndNil(FFilterBox);
FreeAndNil(FDateTimeHandling);
inherited;
end;
procedure TcxCustomGridTableView.AddItem(AItem: TcxCustomGridTableItem);
begin
{$IFDEF DELPHI6}
if csTransient in ComponentStyle then
AItem.FComponentStyle := AItem.FComponentStyle + [csTransient];
{$ENDIF}
FItems.Add(AItem);
ItemIndexChanged(AItem, -1);
AItem.FID := GetNextID;
UpdateDataController(dccItemAdded, AItem);
AItem.SetGridView(Self); // needs Field
AItem.Visible := True;
RefreshFilterableItemsList;
end;
procedure TcxCustomGridTableView.RemoveItem(AItem: TcxCustomGridTableItem);
var
AOldItemIndex: Integer;
begin
BeginUpdate;
try
if AItem = OptionsBehavior.IncSearchItem then
OptionsBehavior.IncSearchItem := nil;
AItem.Visible := False;
AOldItemIndex := AItem.Index;
FItems.Remove(AItem);
AItem.FIndex := -1;
ItemIndexChanged(AItem, AOldItemIndex);
UpdateDataController(dccItemRemoved, AItem);
finally
EndUpdate;
end;
AItem.SetGridView(nil);
//UpdateDataController(dccItemRemoved, AItem);
FFiltering.MRUItems.DeleteEmptyItems;
ReleaseID(AItem.ID);
RefreshFilterableItemsList;
RefreshCustomizationForm;
Synchronize;
end;
procedure TcxCustomGridTableView.AssignVisibleItemsIndexes;
var
I: Integer;
begin
for I := 0 to VisibleItemCount - 1 do
with VisibleItems[I] do
FVisibleIndex := GetVisibleIndex;
end;
procedure TcxCustomGridTableView.ChangeItemIndex(AItem: TcxCustomGridTableItem;
Value: Integer);
var
AOldItemIndex: Integer;
begin
if Value < 0 then Value := 0;
if Value >= ItemCount then Value := ItemCount - 1;
if AItem.Index <> Value then
begin
AOldItemIndex := AItem.Index;
FItems.Move(AItem.Index, Value);
ItemIndexChanged(AItem, AOldItemIndex);
if AItem.Visible then RefreshVisibleItemsList;
UpdateDataController(dccIndexesChanged, AItem);
end;
end;
procedure TcxCustomGridTableView.CheckItemVisibles;
var
I: Integer;
begin
BeginUpdate;
try
for I := 0 to ItemCount - 1 do
Items[I].CheckVisible;
finally
EndUpdate;
end;
end;
procedure TcxCustomGridTableView.SaveItemVisibles;
var
I: Integer;
begin
for I := 0 to ItemCount - 1 do
Items[I].SaveVisible;
end;
procedure TcxCustomGridTableView.ItemIndexChanged(AItem: TcxCustomGridTableItem;
AOldIndex: Integer);
begin
RefreshItemIndexes;
end;
procedure TcxCustomGridTableView.ItemVisibilityChanged(AItem: TcxCustomGridTableItem;
Value: Boolean);
begin
if Value then
begin
RefreshVisibleItemsList;
AItem.Changed(ticSize);
if Controller.FocusedItem = nil then
AItem.Focused := True;
end
else
begin
if AItem.IncSearching then Controller.CancelIncSearching;
//AItem.Focused := False;
RefreshVisibleItemsList;
AItem.Changed(ticSize);
AItem.Focused := False;
end;
end;
procedure TcxCustomGridTableView.RefreshVisibleItemsList;
var
I: Integer;
begin
FVisibleItems.Clear;
for I := 0 to ItemCount - 1 do
if Items[I].ActuallyVisible then
Items[I].FVisibleIndex := FVisibleItems.Add(Items[I])
else
Items[I].FVisibleIndex := -1;
end;
function TcxCustomGridTableView.GetItemDataBindingClass: TcxGridItemDataBindingClass;
var
AIGridDataController: IcxGridDataController;
begin
if Supports(TObject(DataController), IcxGridDataController, AIGridDataController) then
Result := AIGridDataController.GetItemDataBindingClass
else
Result := nil;
end;
function TcxCustomGridTableView.GetNextID: Integer;
begin
Result := FNextID;
Inc(FNextID);
end;
procedure TcxCustomGridTableView.ReleaseID(AID: Integer);
begin
if AID = FNextID - 1 then Dec(FNextID);
end;
procedure TcxCustomGridTableView.DataChanged;
var
I: Integer;
begin
Controller.DragHighlightedRecord := nil;
for I := 0 to ItemCount - 1 do
Items[I].DataChanged;
Changed(TcxGridDataChange.Create(Self));
Controller.EditingController.UpdateEditValue;
//Controller.MakeFocusedRecordVisible; - because of expanding, but this code is needed for insert !!!
Synchronize;
end;
procedure TcxCustomGridTableView.DataLayoutChanged;
begin
ViewData.RefreshRecords;
SizeChanged;
Controller.EditingController.UpdateEditValue;
Synchronize;
end;
function TcxCustomGridTableView.DoCellClick(ACellViewInfo: TcxGridTableDataCellViewInfo;
AButton: TMouseButton; AShift: TShiftState): Boolean;
begin
Result := False;
if Assigned(FOnCellClick) then
FOnCellClick(Self, ACellViewInfo, AButton, AShift, Result);
end;
function TcxCustomGridTableView.DoCellDblClick(ACellViewInfo: TcxGridTableDataCellViewInfo;
AButton: TMouseButton; AShift: TShiftState): Boolean;
begin
Result := False;
if Assigned(FOnCellDblClick) then
FOnCellDblClick(Self, ACellViewInfo, AButton, AShift, Result);
end;
function TcxCustomGridTableView.DoEditing(AItem: TcxCustomGridTableItem): Boolean;
begin
Result := True;
if Assigned(FOnEditing) then FOnEditing(Self, AItem, Result);
end;
procedure TcxCustomGridTableView.DoTopRecordIndexChanged;
begin
if Assigned(FOnTopRecordIndexChanged) then FOnTopRecordIndexChanged(Self);
end;
procedure TcxCustomGridTableView.FilterChanged;
begin
FFiltering.FilterChanged;
end;
procedure TcxCustomGridTableView.FocusedItemChanged(APrevFocusedItem, AFocusedItem: TcxCustomGridTableItem);
begin
if Assigned(OnFocusedItemChanged) then
FOnFocusedItemChanged(Self, APrevFocusedItem, AFocusedItem);
end;
procedure TcxCustomGridTableView.FocusedRecordChanged(APrevFocusedRecordIndex,
AFocusedRecordIndex: Integer; ANewItemRecordFocusingChanged: Boolean);
begin
Changed(TcxGridFocusedRecordChange.Create(Self, APrevFocusedRecordIndex,
AFocusedRecordIndex, ANewItemRecordFocusingChanged));
end;
procedure TcxCustomGridTableView.GroupingChanging;
var
I: Integer;
begin
for I := 0 to ItemCount - 1 do
Items[I].GroupingChanging;
end;
procedure TcxCustomGridTableView.ItemCaptionChanged(AItem: TcxCustomGridTableItem);
begin
if (AItem = nil) or AItem.ActuallyVisible or (AItem.GroupIndex <> -1) or
AItem.DataBinding.Filtered then
Changed(vcSize)
else
Changed(vcProperty);
RefreshCustomizationForm;
end;
procedure TcxCustomGridTableView.ItemValueTypeClassChanged(AItemIndex: Integer);
begin
Items[AItemIndex].ValueTypeClassChanged;
end;
procedure TcxCustomGridTableView.RecalculateDefaultWidths;
var
I: Integer;
begin
BeginUpdate;
try
for I := 0 to ItemCount - 1 do
Items[I].RecalculateDefaultWidth;
finally
EndUpdate;
end;
end;
procedure TcxCustomGridTableView.RecordChanged(ARecordIndex: Integer);
var
ARecord: TcxCustomGridRecord;
begin
ViewData.AssignEditingRecord;
if IsRecordHeightDependsOnData then
SizeChanged
else
begin
ARecord := ViewData.GetRecordByRecordIndex(ARecordIndex);
if ARecord = nil then
LayoutChanged
else
ARecord.Invalidate;
end;
Controller.EditingController.UpdateEditValue;
end;
procedure TcxCustomGridTableView.RecordCountChanged;
begin
ViewInfoCache.Count := DataController.GetRowCount;
ViewData.Refresh(DataController.GetRowCount);
if Control <> nil then {7}
TcxCustomGrid(Control).SendNotifications(gnkRecordCountChanged);
end;
procedure TcxCustomGridTableView.RefreshFilterableItemsList;
var
I: Integer;
begin
if IsDestroying then Exit;
FFilterableItems.Clear;
for I := 0 to ItemCount - 1 do
if Items[I].Filterable then
FFilterableItems.Add(Items[I]);
end;
procedure TcxCustomGridTableView.RefreshNavigators;
begin
if ViewInfo.NavigatorSiteViewInfo.Visible then
ViewInfo.NavigatorButtonsStateChanged;
FNavigatorNotifier.RefreshNavigatorButtons;
if Focused then
TcxCustomGridAccess(Control).RefreshNavigators;
end;
procedure TcxCustomGridTableView.SearchChanged;
begin
if Controller.FocusedRecord <> nil then
Controller.FocusedRecord.Invalidate(Controller.IncSearchingItem);
end;
procedure TcxCustomGridTableView.SelectionChanged(AInfo: TcxSelectionChangedInfo);
var
I: Integer;
ARecord: TcxCustomGridRecord;
begin
if AInfo.Count = 0 then
LayoutChanged
else
for I := 0 to AInfo.Count - 1 do
begin
ARecord := ViewData.GetRecordByIndex(AInfo.RowIndexes[I]);
if ARecord <> nil then ARecord.Invalidate;
end;
if not IsLoading then DoSelectionChanged;
end;
function TcxCustomGridTableView.CalculateDataCellSelected(ARecord: TcxCustomGridRecord;
AItem: TcxCustomGridTableItem; AUseViewInfo: Boolean; ACellViewInfo: TcxGridTableCellViewInfo): Boolean;
function GetRecordFocused: Boolean;
begin
if AUseViewInfo then
Result := ARecord.ViewInfo.Focused
else
Result := DrawRecordFocused(ARecord);
end;
begin
if not (ARecord.HasCells and ARecord.CanFocusCells) then
Result := True
else
if OptionsSelection.InvertSelect then
Result := (AItem = nil) or not AItem.Focused or not GetRecordFocused
else
Result := (OptionsSelection.MultiSelect or
(AItem <> nil) and AItem.Focused and GetRecordFocused) and
(not (ACellViewInfo is TcxGridTableDataCellViewInfo) or
not TcxGridTableDataCellViewInfo(ACellViewInfo).Editing);
end;
function TcxCustomGridTableView.DrawDataCellSelected(ARecord: TcxCustomGridRecord;
AItem: TcxCustomGridTableItem; AUseViewInfo: Boolean = False;
ACellViewInfo: TcxGridTableCellViewInfo = nil): Boolean;
function GetRecordSelected: Boolean;
begin
if AUseViewInfo then
Result := ARecord.ViewInfo.Selected
else
Result := DrawRecordSelected(ARecord);
end;
function GetCellSelected: Boolean;
begin
if (ACellViewInfo <> nil) and ACellViewInfo.AlwaysSelected then
Result := True
else
Result := CalculateDataCellSelected(ARecord, AItem, AUseViewInfo, ACellViewInfo);
end;
begin
Result :=
((ACellViewInfo = nil) or ACellViewInfo.CanDrawSelected) and
(ARecord <> nil) and GetRecordSelected and GetCellSelected and
DrawSelection;
end;
function TcxCustomGridTableView.DrawRecordActive(ARecord: TcxCustomGridRecord): Boolean;
begin
Result := IsControlFocused or ARecord.DragHighlighted;
end;
function TcxCustomGridTableView.DrawRecordFocused(ARecord: TcxCustomGridRecord): Boolean;
begin
Result := ARecord.Focused and Focused;
end;
function TcxCustomGridTableView.DrawRecordSelected(ARecord: TcxCustomGridRecord): Boolean;
begin
Result :=
ARecord.Selected and (Focused or OptionsSelection.MultiSelect) or
ARecord.DragHighlighted;
end;
function TcxCustomGridTableView.DrawSelection: Boolean;
begin
Result := IsControlFocused or not OptionsSelection.HideSelection;
end;
function TcxCustomGridTableView.DoCanFocusRecord(ARecord: TcxCustomGridRecord): Boolean;
begin
Result := True;
if Assigned(FOnCanFocusRecord) then FOnCanFocusRecord(Self, ARecord, Result);
end;
procedure TcxCustomGridTableView.DoCustomDrawCell(ACanvas: TcxCanvas;
AViewInfo: TcxGridTableDataCellViewInfo; var ADone: Boolean);
begin
if HasCustomDrawCell then
FOnCustomDrawCell(Self, ACanvas, AViewInfo, ADone);
end;
procedure TcxCustomGridTableView.DoCustomDrawPartBackground(ACanvas: TcxCanvas;
AViewInfo: TcxCustomGridCellViewInfo; var ADone: Boolean);
begin
if HasCustomDrawPartBackground then
FOnCustomDrawPartBackground(Self, ACanvas, AViewInfo, ADone);
end;
procedure TcxCustomGridTableView.DoEditChanged(AItem: TcxCustomGridTableItem);
begin
if Assigned(FOnEditChanged) then FOnEditChanged(Self, AItem);
end;
procedure TcxCustomGridTableView.DoEditKeyDown(AItem: TcxCustomGridTableItem;
AEdit: TcxCustomEdit; var Key: Word; Shift: TShiftState);
begin
if Assigned(FOnEditKeyDown) then FOnEditKeyDown(Self, AItem, AEdit, Key, Shift);
end;
procedure TcxCustomGridTableView.DoEditKeyPress(AItem: TcxCustomGridTableItem;
AEdit: TcxCustomEdit; var Key: Char);
begin
if Assigned(FOnEditKeyPress) then FOnEditKeyPress(Self, AItem, AEdit, Key);
end;
procedure TcxCustomGridTableView.DoEditKeyUp(AItem: TcxCustomGridTableItem;
AEdit: TcxCustomEdit; var Key: Word; Shift: TShiftState);
begin
if Assigned(FOnEditKeyUp) then FOnEditKeyUp(Self, AItem, AEdit, Key, Shift);
end;
procedure TcxCustomGridTableView.DoEditValueChanged(AItem: TcxCustomGridTableItem);
begin
if Assigned(FOnEditValueChanged) then FOnEditValueChanged(Self, AItem);
end;
function TcxCustomGridTableView.DoFilterCustomization: Boolean;
begin
Result := False;
if Assigned(FOnFilterCustomization) then FOnFilterCustomization(Self, Result);
end;
function TcxCustomGridTableView.DoFilterDialogShow(AItem: TcxCustomGridTableItem): Boolean;
begin
Result := False;
if Assigned(FOnFilterDialogShow) then FOnFilterDialogShow(Self, AItem, Result);
end;
procedure TcxCustomGridTableView.DoFocusedRecordChanged(APrevFocusedRecordIndex,
AFocusedRecordIndex: Integer; ANewItemRecordFocusingChanged: Boolean);
begin
if Control <> nil then
TcxCustomGrid(Control).SendNotifications(gnkFocusedRecordChanged);
if Assigned(FOnFocusedRecordChanged) then
FOnFocusedRecordChanged(Self, ViewData.GetRecordByIndex(APrevFocusedRecordIndex),
ViewData.GetRecordByIndex(AFocusedRecordIndex), ANewItemRecordFocusingChanged);
end;
procedure TcxCustomGridTableView.DoGetCellHeight(ARecord: TcxCustomGridRecord;
AItem: TcxCustomGridTableItem; ACellViewInfo: TcxGridTableDataCellViewInfo;
var AHeight: Integer);
begin
if IsGetCellHeightAssigned then
FOnGetCellHeight(Self, ARecord, AItem, ACellViewInfo, AHeight);
end;
function TcxCustomGridTableView.DoGetDragDropText(ARecord: TcxCustomGridRecord;
AItem: TcxCustomGridTableItem): string;
begin
if (ARecord <> nil) and (AItem <> nil) then
Result := ARecord.DisplayTexts[AItem.Index]
else
Result := '';
if Assigned(FOnGetDragDropText) then
FOnGetDragDropText(Self, ARecord, AItem, Result); // for vic
end;
procedure TcxCustomGridTableView.DoInitEdit(AItem: TcxCustomGridTableItem; AEdit: TcxCustomEdit);
begin
if Assigned(FOnInitEdit) then FOnInitEdit(Self, AItem, AEdit);
end;
procedure TcxCustomGridTableView.DoInitEditValue(AItem: TcxCustomGridTableItem;
AEdit: TcxCustomEdit; var AValue: TcxEditValue);
begin
if Assigned(FOnInitEditValue) then FOnInitEditValue(Self, AItem, AEdit, AValue);
end;
procedure TcxCustomGridTableView.DoInitFilteringDateRanges(AItem: TcxCustomGridTableItem);
begin
if HasInitFilteringDateRangesHandler then
FOnInitFilteringDateRanges(AItem, AItem.FilteringDateRanges);
end;
procedure TcxCustomGridTableView.DoInitGroupingDateRanges(AItem: TcxCustomGridTableItem);
begin
if HasInitGroupingDateRangesHandler then
FOnInitGroupingDateRanges(AItem, AItem.GroupingDateRanges);
end;
{procedure TcxCustomGridTableView.DoRecordCreated(ARecord: TcxCustomGridRecord);
begin
if Assigned(FOnRecordCreated) then FOnRecordCreated(Self, ARecord);
end;
procedure TcxCustomGridTableView.DoRecordDestroying(ARecord: TcxCustomGridRecord);
begin
if Assigned(FOnRecordDestroying) then FOnRecordDestroying(Self, ARecord);
end;}
procedure TcxCustomGridTableView.DoSelectionChanged;
begin
if Assigned(FOnSelectionChanged) then FOnSelectionChanged(Self);
end;
function TcxCustomGridTableView.HasCustomProperties: Boolean;
var
I: Integer;
begin
for I := 0 to ItemCount - 1 do
begin
Result := Items[I].HasCustomPropertiesHandler;
if Result then Exit;
end;
Result := False;
end;
function TcxCustomGridTableView.HasInitFilteringDateRangesHandler: Boolean;
begin
Result := Assigned(FOnInitFilteringDateRanges);
end;
function TcxCustomGridTableView.HasInitGroupingDateRangesHandler: Boolean;
begin
Result := Assigned(FOnInitGroupingDateRanges);
end;
function TcxCustomGridTableView.IsGetCellHeightAssigned: Boolean;
begin
Result := Assigned(FOnGetCellHeight);
end;
function TcxCustomGridTableView.GetControllerClass: TcxCustomGridControllerClass;
begin
Result := TcxCustomGridTableController;
end;
function TcxCustomGridTableView.GetPainterClass: TcxCustomGridPainterClass;
begin
Result := TcxCustomGridTablePainter;
end;
function TcxCustomGridTableView.GetViewDataClass: TcxCustomGridViewDataClass;
begin
Result := TcxCustomGridTableViewData;
end;
function TcxCustomGridTableView.GetViewInfoCacheClass: TcxCustomGridViewInfoCacheClass;
begin
Result := TcxCustomGridTableViewInfoCache;
end;
function TcxCustomGridTableView.GetViewInfoClass: TcxCustomGridViewInfoClass;
begin
Result := TcxCustomGridTableViewInfo;
end;
function TcxCustomGridTableView.GetBackgroundBitmapsClass: TcxCustomGridBackgroundBitmapsClass;
begin
Result := TcxCustomGridTableBackgroundBitmaps;
end;
function TcxCustomGridTableView.GetDateTimeHandlingClass: TcxCustomGridTableDateTimeHandlingClass;
begin
Result := TcxCustomGridTableDateTimeHandling;
end;
function TcxCustomGridTableView.GetFilterBoxClass: TcxGridFilterBoxClass;
begin
Result := TcxGridFilterBox;
end;
function TcxCustomGridTableView.GetFilteringClass: TcxCustomGridTableFilteringClass;
begin
Result := TcxCustomGridTableFiltering;
end;
function TcxCustomGridTableView.GetNavigatorButtonsClass: TcxNavigatorControlButtonsClass;
begin
Result := TcxNavigatorControlButtons;
end;
function TcxCustomGridTableView.GetOptionsBehaviorClass: TcxCustomGridOptionsBehaviorClass;
begin
Result := TcxCustomGridTableOptionsBehavior;
end;
function TcxCustomGridTableView.GetOptionsCustomizeClass: TcxCustomGridTableOptionsCustomizeClass;
begin
Result := TcxCustomGridTableOptionsCustomize;
end;
function TcxCustomGridTableView.GetOptionsDataClass: TcxCustomGridOptionsDataClass;
begin
Result := TcxCustomGridTableOptionsData;
end;
function TcxCustomGridTableView.GetOptionsSelectionClass: TcxCustomGridOptionsSelectionClass;
begin
Result := TcxCustomGridTableOptionsSelection;
end;
function TcxCustomGridTableView.GetOptionsViewClass: TcxCustomGridOptionsViewClass;
begin
Result := TcxCustomGridTableOptionsView;
end;
function TcxCustomGridTableView.GetStylesClass: TcxCustomGridViewStylesClass;
begin
Result := TcxCustomGridTableViewStyles;
end;
procedure TcxCustomGridTableView.ApplyBestFit(AItem: TcxCustomGridTableItem = nil;
ACheckSizingAbility: Boolean = False; AFireEvents: Boolean = False);
var
I: Integer;
begin
if AItem = nil then
for I := 0 to VisibleItemCount - 1 do
VisibleItems[I].ApplyBestFit(ACheckSizingAbility, AFireEvents)
else
AItem.ApplyBestFit(ACheckSizingAbility, AFireEvents);
end;
procedure TcxCustomGridTableView.ClearItems;
var
I: Integer;
begin
BeginUpdate;
try
for I := ItemCount - 1 downto 0 do Items[I].Free;
FNextID := 0;
finally
EndUpdate;
end;
end;
procedure TcxCustomGridTableView.CopyToClipboard(ACopyAll: Boolean);
procedure AddHeaders;
var
I: Integer;
begin
for I := 0 to FCopyToClipboardItems.Count - 1 do
FCopyToClipboardStr := FCopyToClipboardStr +
TcxCustomGridTableItem(FCopyToClipboardItems[I]).GetAlternateCaption + ColumnSeparator;
if FCopyToClipboardItems.Count <> 0 then
FCopyToClipboardStr := Copy(FCopyToClipboardStr, 1,
Length(FCopyToClipboardStr) - Length(ColumnSeparator));
FCopyToClipboardStr := FCopyToClipboardStr + EndOfLine;
end;
begin
FCopyToClipboardItems := TList.Create;
try
GetItemsListForClipboard(FCopyToClipboardItems, ACopyAll);
FCopyToClipboardStr := '';
if OptionsBehavior.CopyCaptionsToClipboard then
AddHeaders;
DataController.ForEachRow(not ACopyAll, CopyForEachRowProc);
Clipboard.AsText := FCopyToClipboardStr;
finally
FCopyToClipboardItems.Free;
end;
end;
function TcxCustomGridTableView.CreateItem: TcxCustomGridTableItem;
begin
Result := GetItemClass.Create(Owner);
AddItem(Result);
end;
function TcxCustomGridTableView.FindItemByID(AID: Integer): TcxCustomGridTableItem;
var
I: Integer;
begin
for I := 0 to ItemCount - 1 do
begin
Result := Items[I];
if Result.ID = AID then Exit;
end;
Result := nil;
end;
function TcxCustomGridTableView.FindItemByName(const AName: string): TcxCustomGridTableItem;
var
I: Integer;
begin
for I := 0 to ItemCount - 1 do
begin
Result := Items[I];
if Result.Name = AName then Exit;
end;
Result := nil;
end;
function TcxCustomGridTableView.FindItemByTag(ATag: TcxTag): TcxCustomGridTableItem;
var
I: Integer;
begin
for I := 0 to ItemCount - 1 do
begin
Result := Items[I];
if Result.Tag = ATag then Exit;
end;
Result := nil;
end;
function TcxCustomGridTableView.IndexOfItem(AItem: TcxCustomGridTableItem): Integer;
begin
Result := FItems.IndexOf(AItem);
end;
procedure TcxCustomGridTableView.MakeMasterGridRecordVisible;
begin
if IsDetail and (MasterGridRecord <> nil) and not DontMakeMasterRecordVisible and
not MasterGridView.DataController.IsDetailExpanding then
MasterGridRecord.MakeVisible;
end;
procedure TcxCustomGridTableView.RestoreDefaults;
var
I: Integer;
begin
inherited;
BeginUpdate;
try
for I := 0 to ItemCount - 1 do
Items[I].RestoreDefaults;
finally
EndUpdate;
end;
end;
class function TcxCustomGridTableView.CanBeLookupList: Boolean;
begin
Result := False;
end;
function TcxCustomGridTableView.GetSummaryGroupItemLinkClass: TcxDataSummaryGroupItemLinkClass;
begin
Result := nil;
end;
function TcxCustomGridTableView.GetSummaryItemClass: TcxDataSummaryItemClass;
begin
Result := nil;
end;
{ TcxCustomGridTableControllerAccess }
class procedure TcxCustomGridTableControllerAccess.FocusNextPage(AInstance: TcxCustomGridTableController;
ASyncSelection: Boolean);
begin
AInstance.FocusNextPage(ASyncSelection);
end;
class procedure TcxCustomGridTableControllerAccess.FocusPrevPage(AInstance: TcxCustomGridTableController;
ASyncSelection: Boolean);
begin
AInstance.FocusPrevPage(ASyncSelection);
end;
{ TcxCustomGridTableItemAccess }
class function TcxCustomGridTableItemAccess.CanGroup(AInstance: TcxCustomGridTableItem): Boolean;
begin
Result := AInstance.CanGroup;
end;
class function TcxCustomGridTableItemAccess.CanHide(AInstance: TcxCustomGridTableItem): Boolean;
begin
Result := AInstance.CanHide;
end;
class function TcxCustomGridTableItemAccess.CanHorzSize(AInstance: TcxCustomGridTableItem): Boolean;
begin
Result := AInstance.CanHorzSize;
end;
class function TcxCustomGridTableItemAccess.CanSort(AInstance: TcxCustomGridTableItem): Boolean;
begin
Result := AInstance.CanSort;
end;
class procedure TcxCustomGridTableItemAccess.CheckWidthValue(
AInstance: TcxCustomGridTableItem; var Value: Integer);
begin
AInstance.CheckWidthValue(Value);
end;
class procedure TcxCustomGridTableItemAccess.DoGetDataText(
AInstance: TcxCustomGridTableItem; ARecordIndex: Integer; var AText: string);
begin
AInstance.DoGetDataText(ARecordIndex, AText);
end;
class procedure TcxCustomGridTableItemAccess.DoGetDisplayText(
AInstance: TcxCustomGridTableItem; ARecord: TcxCustomGridRecord;
var AText: string);
begin
AInstance.DoGetDisplayText(ARecord, AText);
end;
class function TcxCustomGridTableItemAccess.GetGroupIndex(
AInstance: TcxCustomGridTableItem): Integer;
begin
Result := AInstance.GroupIndex;
end;
class function TcxCustomGridTableItemAccess.GetFilterCaption(
AInstance: TcxCustomGridTableItem): string;
begin
Result := AInstance.FilterCaption;
end;
{ TcxCustomGridTableOptionsBehaviorAccess }
class function TcxCustomGridTableOptionsBehaviorAccess.GetPullFocusing(
AInstance: TcxCustomGridTableOptionsBehavior): Boolean;
begin
Result := AInstance.PullFocusing;
end;
class procedure TcxCustomGridTableOptionsBehaviorAccess.SetPullFocusing(
AInstance: TcxCustomGridTableOptionsBehavior; Value: Boolean);
begin
AInstance.PullFocusing := Value;
end;
{ TcxCustomGridTableOptionsViewAccess }
class function TcxCustomGridTableOptionsViewAccess.GetCellAutoHeight(
AInstance: TcxCustomGridTableOptionsView): Boolean;
begin
Result := AInstance.CellAutoHeight;
end;
{ TcxCustomGridTableViewAccess }
class function TcxCustomGridTableViewAccess.CanSelectRecord(
AInstance: TcxCustomGridTableView; ARecordIndex: Integer): Boolean;
begin
Result := AInstance.CanSelectRecord(ARecordIndex);
end;
class procedure TcxCustomGridTableViewAccess.FilterChanged(
AInstance: TcxCustomGridTableView);
begin
AInstance.FilterChanged;
end;
class function TcxCustomGridTableViewAccess.FindItemByObjectName(AInstance: TcxCustomGridTableView;
const AObjectName: string): TcxCustomGridTableItem;
begin
Result := AInstance.FindItemByObjectName(AObjectName);
end;
class procedure TcxCustomGridTableViewAccess.FocusEdit(
AInstance: TcxCustomGridTableView; AItemIndex: Integer; var ADone: Boolean);
begin
AInstance.FocusEdit(AItemIndex, ADone);
end;
class function TcxCustomGridTableViewAccess.GetDefaultActiveDetailIndex(
AInstance: TcxCustomGridTableView): Integer;
begin
Result := AInstance.GetDefaultActiveDetailIndex;
end;
class function TcxCustomGridTableViewAccess.GetItemClass(AInstance: TcxCustomGridTableView): TcxCustomGridTableItemClass;
begin
Result := AInstance.GetItemClass;
end;
class function TcxCustomGridTableViewAccess.GetItemSortByDisplayText(
AInstance: TcxCustomGridTableView; AItemIndex: Integer;
ASortByDisplayText: Boolean): Boolean;
begin
Result := AInstance.GetItemSortByDisplayText(AItemIndex, ASortByDisplayText);
end;
class function TcxCustomGridTableViewAccess.GetItemValueSource(
AInstance: TcxCustomGridTableView; AItemIndex: Integer): TcxDataEditValueSource;
begin
Result := AInstance.GetItemValueSource(AItemIndex);
end;
class function TcxCustomGridTableViewAccess.GetSummaryGroupItemLinkClass(
AInstance: TcxCustomGridTableView): TcxDataSummaryGroupItemLinkClass;
begin
Result := AInstance.GetSummaryGroupItemLinkClass;
end;
class function TcxCustomGridTableViewAccess.GetSummaryItemClass(
AInstance: TcxCustomGridTableView): TcxDataSummaryItemClass;
begin
Result := AInstance.GetSummaryItemClass;
end;
class function TcxCustomGridTableViewAccess.IsEqualHeightRecords(
AInstance: TcxCustomGridTableView): Boolean;
begin
Result := AInstance.IsEqualHeightRecords;
end;
class function TcxCustomGridTableViewAccess.IsGetCellHeightAssigned(
AInstance: TcxCustomGridTableView): Boolean;
begin
Result := AInstance.IsGetCellHeightAssigned;
end;
class procedure TcxCustomGridTableViewAccess.ItemValueTypeClassChanged(
AInstance: TcxCustomGridTableView; AItemIndex: Integer);
begin
AInstance.ItemValueTypeClassChanged(AItemIndex);
end;
class procedure TcxCustomGridTableViewAccess.RefreshNavigators(
AInstance: TcxCustomGridTableView);
begin
AInstance.RefreshNavigators;
end;
class procedure TcxCustomGridTableViewAccess.UpdateRecord(
AInstance: TcxCustomGridTableView);
begin
AInstance.UpdateRecord;
end;
{ TcxCustomGridTableViewInfoAccess }
class function TcxCustomGridTableViewInfoAccess.GetDefaultGridModeBufferCount(AInstance: TcxCustomGridTableViewInfo): Integer;
begin
Result := AInstance.GetDefaultGridModeBufferCount;
end;
initialization
RegisterClasses([TcxGridItemDataBinding]);
end.
Reference in New Issue View Git Blame Copy Permalink