david
111d889bc6
git-svn-id: https://192.168.0.254/svn/Componentes.Terceros.DevExpressVCL@32 05c56307-c608-d34a-929d-697000501d7a
1104 lines
34 KiB
ObjectPascal
1104 lines
34 KiB
ObjectPascal
{********************************************************************}
|
|
{ }
|
|
{ Developer Express Visual Component Library }
|
|
{ ExpressVerticalGrid }
|
|
{ }
|
|
{ Copyright (c) 1998-2009 Developer Express Inc. }
|
|
{ ALL RIGHTS RESERVED }
|
|
{ }
|
|
{ The entire contents of this file is protected by U.S. and }
|
|
{ International Copyright Laws. Unauthorized reproduction, }
|
|
{ reverse-engineering, and distribution of all or any portion of }
|
|
{ the code contained in this file is strictly prohibited and may }
|
|
{ result in severe civil and criminal penalties and will be }
|
|
{ prosecuted to the maximum extent possible under the law. }
|
|
{ }
|
|
{ RESTRICTIONS }
|
|
{ }
|
|
{ THIS SOURCE CODE AND ALL RESULTING INTERMEDIATE FILES }
|
|
{ (DCU, OBJ, DLL, ETC.) ARE CONFIDENTIAL AND PROPRIETARY TRADE }
|
|
{ SECRETS OF DEVELOPER EXPRESS INC. THE REGISTERED DEVELOPER IS }
|
|
{ LICENSED TO DISTRIBUTE THE EXPRESSVERTICALGRID 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 cxVGridViewInfo;
|
|
|
|
{$I cxVer.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
Classes, Graphics,
|
|
Windows, Controls,
|
|
cxGraphics, cxVGrid, cxVGridUtils, cxEdit, cxInplaceContainer, cxStyles;
|
|
|
|
type
|
|
{ TcxCategoryRowHeaderInfo }
|
|
|
|
TcxCategoryRowHeaderInfo = class(TcxCustomRowHeaderInfo)
|
|
private
|
|
function GetRow: TcxCategoryRow;
|
|
protected
|
|
procedure AddBottomHorzLine(const R: TRect); override;
|
|
procedure AddRightVertLine(const R: TRect); override;
|
|
procedure CalcRowCaptionsInfo; override;
|
|
procedure CalcViewParams(AAllowFocus: Boolean); override;
|
|
procedure DoCalcExpandButton; override;
|
|
function GetCaptionViewParams: TcxViewParams; override;
|
|
function GetButtonColor: TColor; override;
|
|
function GetFocusRect: TRect; override;
|
|
function IncreaseBoundsByLastVertLine: Boolean; override;
|
|
function LeftViewPoint: Integer; override;
|
|
public
|
|
property Row: TcxCategoryRow read GetRow;
|
|
end;
|
|
|
|
{ TcxCategoryRowViewInfo }
|
|
|
|
TcxCategoryRowViewInfo = class(TcxCustomRowViewInfo)
|
|
private
|
|
function GetRow: TcxCategoryRow;
|
|
protected
|
|
procedure CalcRowHeaderInfo(ANextRow: TcxCustomRow); override;
|
|
procedure CalcValuesInfo; override;
|
|
public
|
|
property Row: TcxCategoryRow read GetRow;
|
|
end;
|
|
|
|
{ TcxEditorRowHeaderInfo }
|
|
|
|
TcxEditorRowHeaderInfo = class(TcxCustomRowHeaderInfo)
|
|
private
|
|
function GetRow: TcxEditorRow;
|
|
public
|
|
property Row: TcxEditorRow read GetRow;
|
|
end;
|
|
|
|
{ TcxEditorRowViewInfo }
|
|
|
|
TcxEditorRowViewInfo = class(TcxCustomRowViewInfo)
|
|
private
|
|
function GetRow: TcxEditorRow;
|
|
protected
|
|
procedure CalcValuesInfo; override;
|
|
function GetValueHeight(ARecordIndex: Integer; AWidth: Integer;
|
|
AViewInfo: TcxvgCustomViewInfo): Integer; override;
|
|
public
|
|
property Row: TcxEditorRow read GetRow;
|
|
end;
|
|
|
|
{ TcxMultiEditorRowHeaderInfo }
|
|
|
|
TcxMultiEditorRowHeaderInfo = class(TcxCustomRowHeaderInfo)
|
|
private
|
|
FSeparatorRects: TcxRectList;
|
|
FSeparatorInfo: TSeparatorInfo;
|
|
function GetRow: TcxMultiEditorRow;
|
|
protected
|
|
procedure CalcRowCaptionsInfo; override;
|
|
procedure CalcSeparatorRects(AHeaderCells: TcxRectList); virtual;
|
|
procedure CalcSeparatorWidth(ASeparatorWidth: Integer); virtual;
|
|
procedure CalcSeparatorStyle; virtual;
|
|
procedure Clear; override;
|
|
public
|
|
constructor Create(ARow: TcxCustomRow); override;
|
|
destructor Destroy; override;
|
|
property Row: TcxMultiEditorRow read GetRow;
|
|
property SeparatorInfo: TSeparatorInfo read FSeparatorInfo;
|
|
property SeparatorRects: TcxRectList read FSeparatorRects;
|
|
end;
|
|
|
|
{ TcxMultiEditorRowViewInfo }
|
|
|
|
TcxMultiEditorRowViewInfo = class(TcxCustomRowViewInfo)
|
|
private
|
|
FSeparatorRects: TcxRectList;
|
|
function GetHeaderInfo: TcxMultiEditorRowHeaderInfo;
|
|
function GetRow: TcxMultiEditorRow;
|
|
function GetSeparatorRects: TcxRectList;
|
|
protected
|
|
procedure AddSeparatorRects(AHeader: Boolean; ASepRects: TcxRectList;
|
|
ASeparatorKind: TSeparatorKind; AValueCells: TcxRectList;
|
|
const ABounds: TRect);
|
|
procedure CalcValuesInfo; override;
|
|
procedure CheckEmptyValuesInfo; virtual;
|
|
function GetValueHeight(ARecordIndex: Integer; AWidth: Integer;
|
|
AViewInfo: TcxvgCustomViewInfo): Integer; override;
|
|
public
|
|
constructor Create(ARow: TcxCustomRow); override;
|
|
destructor Destroy; override;
|
|
class function GetCellRects(ARow: TcxMultiEditorRow; const R: TRect;
|
|
ASepWidth: Integer): TcxRectList;
|
|
property HeaderInfo: TcxMultiEditorRowHeaderInfo read GetHeaderInfo;
|
|
property Row: TcxMultiEditorRow read GetRow;
|
|
property SeparatorRects: TcxRectList read GetSeparatorRects;
|
|
end;
|
|
|
|
{ TcxInspectorViewInfo }
|
|
|
|
TcxInspectorViewInfo = class(TcxvgCustomViewInfo)
|
|
protected
|
|
procedure AddEmptyRects; override;
|
|
procedure CheckMaxRowHeaderWidth(var Value: Integer; AValueMinWidth: Integer); override;
|
|
function GetViewValueWidth: Integer; override;
|
|
function GetVisibleValueCount: Integer; override;
|
|
end;
|
|
|
|
{ TcxBandsViewInfo }
|
|
|
|
TcxBandsViewInfo = class(TcxvgCustomViewInfo)
|
|
private
|
|
FBandsIndent: Integer;
|
|
FAutoScaleBands: Boolean;
|
|
FLock: Boolean;
|
|
procedure UpdateBandsWidth;
|
|
protected
|
|
procedure AddEmptyRects; override;
|
|
procedure CalcBandRects; override;
|
|
procedure CalcBandWidth; override;
|
|
procedure CalcLayoutGeneral; override;
|
|
function CanAddRowToBand(const ARowRect, ABandRect: TRect; ABandRowIndex: Integer): Boolean; override;
|
|
procedure CreateBand(ABandHeight, ABandWidth: Integer); override;
|
|
function GetBandSizeableRect(const ABandRect: TRect): TRect; override;
|
|
function GetMinViewBandWidth: Integer;
|
|
function GetRowAutoHeight(ARow: TcxCustomRow): Boolean; override;
|
|
function GetViewBandWidth: Integer; override;
|
|
function GetViewValueWidth: Integer; override;
|
|
function GetVisibleValueCount: Integer; override;
|
|
procedure LayoutStyleChanged; override;
|
|
procedure SetDividerPos(APos: Integer); override;
|
|
property BandsIndent: Integer read FBandsIndent;
|
|
property AutoScaleBands: Boolean read FAutoScaleBands;
|
|
end;
|
|
|
|
{ TcxMultiRecordViewInfo }
|
|
|
|
TcxMultiRecordViewInfo = class(TcxvgCustomViewInfo)
|
|
private
|
|
FCommonWidth: Integer;
|
|
FRecordsInterval: Integer;
|
|
FVisibleValueCount: Integer;
|
|
function CalcVisibleValueCount: Integer;
|
|
function GetRecordCount: Integer;
|
|
protected
|
|
procedure AddBandRowsLines(const R: TRect); override;
|
|
procedure AddEmptyRects; override;
|
|
procedure AddRightValueSide(const R: TRect; ALast: Boolean); override;
|
|
procedure CalcBandWidth; override;
|
|
procedure CalcLayoutGeneral; override;
|
|
procedure Clear; override;
|
|
function GetBandSizeableRect(const ABandRect: TRect): TRect; override;
|
|
function GetRowHeight(ARowViewInfo: TcxCustomRowViewInfo; ABandWidth: Integer): Integer; override;
|
|
function GetVisibleValueCount: Integer; override;
|
|
procedure Reset; override;
|
|
procedure SetDividerPos(APos: Integer); override;
|
|
property RecordCount: Integer read GetRecordCount;
|
|
public
|
|
constructor Create(AOwner: TcxEditingControl); override;
|
|
function GetDefaultGridModeBufferCount: Integer; override;
|
|
function GetValueRect(AValueIndex: Integer; ARowViewInfo: TcxCustomRowViewInfo): TRect; override;
|
|
procedure UpdateRecord(ARecordIndex: Integer); override;
|
|
property RecordsInterval: Integer read FRecordsInterval;
|
|
end;
|
|
|
|
implementation
|
|
|
|
uses
|
|
{$IFNDEF DELPHI5}
|
|
cxClasses,
|
|
{$ENDIF}
|
|
SysUtils, cxControls, cxGeometry, cxEditUtils;
|
|
|
|
type
|
|
TcxCustomEditorRowPropertiesAccess = class(TcxCustomEditorRowProperties);
|
|
TcxCustomRowAccess = class(TcxCustomRow);
|
|
TcxCustomRowViewInfoAccess = class(TcxCustomRowViewInfo);
|
|
TcxCustomVerticalGridAccess = class(TcxCustomVerticalGrid);
|
|
TcxCollectionItemEditorRowPropertiesAccess = class(TcxCollectionItemEditorRowProperties);
|
|
TcxRowValueInfoAccess = class(TcxRowValueInfo);
|
|
TcxVerticalGridRowsAccess = class(TcxVerticalGridRows);
|
|
|
|
{ TcxCategoryRowHeaderInfo }
|
|
|
|
procedure TcxCategoryRowHeaderInfo.AddBottomHorzLine(const R: TRect);
|
|
begin
|
|
with ViewInfo, R do
|
|
if HorzLineWidth > 0 then
|
|
Self.LinesInfo.Add(Left - VertLineWidth, Bottom,
|
|
Right - Left + 2 * VertLineWidth, HorzLineWidth, HorzLineBrush);
|
|
end;
|
|
|
|
procedure TcxCategoryRowHeaderInfo.AddRightVertLine(const R: TRect);
|
|
begin
|
|
with ViewInfo, Row.ViewInfo.RowRect do
|
|
if VertLineWidth > 0 then
|
|
Self.LinesInfo.Add(Right, Top, VertLineWidth,
|
|
Bottom - Top + HorzLineWidth, BandBorderColor);
|
|
end;
|
|
|
|
procedure TcxCategoryRowHeaderInfo.CalcRowCaptionsInfo;
|
|
begin
|
|
if ViewInfo.UseCategoryExplorerStyle and not cxRectIsEmpty(ButtonRect) then
|
|
FHeaderCellsRect.Right := FButtonRect.Left;
|
|
inherited CalcRowCaptionsInfo;
|
|
end;
|
|
|
|
procedure TcxCategoryRowHeaderInfo.CalcViewParams(AAllowFocus: Boolean);
|
|
begin
|
|
FIndentViewParams := VerticalGrid.Styles.GetCategoryParams(Row);
|
|
ViewParams := IndentViewParams;
|
|
end;
|
|
|
|
procedure TcxCategoryRowHeaderInfo.DoCalcExpandButton;
|
|
begin
|
|
if Row.HasVisibleChildren then
|
|
if ViewInfo.UseCategoryExplorerStyle then
|
|
with HeaderRect, ViewInfo.ExplorerButtonSize do
|
|
FButtonRect := cxRectCenter(cxRect(Right - cx - 2, Top, Right, Bottom), cx, cy)
|
|
else
|
|
inherited DoCalcExpandButton;
|
|
end;
|
|
|
|
function TcxCategoryRowHeaderInfo.GetCaptionViewParams: TcxViewParams;
|
|
begin
|
|
Result := ViewParams;
|
|
end;
|
|
|
|
function TcxCategoryRowHeaderInfo.GetButtonColor: TColor;
|
|
begin
|
|
if PaintStyle = psDotNet then
|
|
Result := ViewParams.Color
|
|
else
|
|
Result := inherited GetButtonColor;
|
|
end;
|
|
|
|
function TcxCategoryRowHeaderInfo.GetFocusRect: TRect;
|
|
begin
|
|
Result := ViewInfo.CalcHelper.GetCategoryFocusRect(Self);
|
|
end;
|
|
|
|
function TcxCategoryRowHeaderInfo.IncreaseBoundsByLastVertLine: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TcxCategoryRowHeaderInfo.LeftViewPoint: Integer;
|
|
begin
|
|
if PaintStyle = psDotNet then
|
|
Result := IndentBounds.Right
|
|
else
|
|
Result := inherited LeftViewPoint;
|
|
end;
|
|
|
|
function TcxCategoryRowHeaderInfo.GetRow: TcxCategoryRow;
|
|
begin
|
|
Result := TcxCategoryRow(FRow);
|
|
end;
|
|
|
|
{ TcxCategoryRowViewInfo }
|
|
|
|
procedure TcxCategoryRowViewInfo.CalcRowHeaderInfo(ANextRow: TcxCustomRow);
|
|
begin
|
|
HeaderInfo.HeaderRect := RowRect;
|
|
with ValuesRect do
|
|
ValuesRect := cxNullRect;
|
|
inherited CalcRowHeaderInfo(ANextRow);
|
|
end;
|
|
|
|
procedure TcxCategoryRowViewInfo.CalcValuesInfo;
|
|
begin
|
|
end;
|
|
|
|
function TcxCategoryRowViewInfo.GetRow: TcxCategoryRow;
|
|
begin
|
|
Result := TcxCategoryRow(inherited Row);
|
|
end;
|
|
|
|
{ TcxEditorRowHeaderInfo }
|
|
|
|
function TcxEditorRowHeaderInfo.GetRow: TcxEditorRow;
|
|
begin
|
|
Result := TcxEditorRow(FRow);
|
|
end;
|
|
|
|
{ TcxEditorRowViewInfo }
|
|
|
|
procedure TcxEditorRowViewInfo.CalcValuesInfo;
|
|
var
|
|
ABottomLineNeeded: Boolean;
|
|
ANextRow: TcxCustomRow;
|
|
ARowValueInfo: TcxRowValueInfo;
|
|
I, ACount: Integer;
|
|
R: TRect;
|
|
begin
|
|
with ViewInfo do
|
|
begin
|
|
ACount := VisibleValueCount;
|
|
for I := 0 to ACount - 1 do
|
|
begin
|
|
R := GetValueRect(I, Self);
|
|
ANextRow := VerticalGrid.NextVisibleRow(Row);
|
|
ABottomLineNeeded := (ANextRow = nil) or (ANextRow <> nil) and not
|
|
(ANextRow.ViewInfo is TcxCategoryRowViewInfo) or
|
|
(VerticalGrid.LookAndFeel.SkinPainter = nil);
|
|
AddRectValueLines(R, (I = ACount - 1) or (R.Right >= ClipRect.Right),
|
|
ABottomLineNeeded);
|
|
ARowValueInfo := CalcRowValueInfo(Row.Properties, ViewInfo, FirstVisibleRecordIndex + I, 0);
|
|
CalcEditCell(R, ARowValueInfo);
|
|
end;
|
|
end;
|
|
ValuesInfo.Trunc(ACount);
|
|
end;
|
|
|
|
function TcxEditorRowViewInfo.GetValueHeight(ARecordIndex: Integer;
|
|
AWidth: Integer; AViewInfo: TcxvgCustomViewInfo): Integer;
|
|
var
|
|
ARowValueInfo: TcxRowValueInfoAccess;
|
|
begin
|
|
with AViewInfo do
|
|
begin
|
|
ARowValueInfo := TcxRowValueInfoAccess(
|
|
CalcRowValueInfo(Row.Properties, AViewInfo, ARecordIndex, 0));
|
|
ARowValueInfo.CellContentRect := cxRectBounds(0, 0, AWidth, 0);
|
|
Result := ARowValueInfo.CalculateEditHeight;
|
|
ValuesInfo.Trunc(VisibleValueCount);
|
|
end;
|
|
end;
|
|
|
|
function TcxEditorRowViewInfo.GetRow: TcxEditorRow;
|
|
begin
|
|
Result := TcxEditorRow(inherited Row);
|
|
end;
|
|
|
|
{ TcxMultiEditorRowHeaderInfo }
|
|
|
|
constructor TcxMultiEditorRowHeaderInfo.Create(ARow: TcxCustomRow);
|
|
begin
|
|
inherited Create(ARow);
|
|
FSeparatorRects := TcxRectList.Create;
|
|
end;
|
|
|
|
destructor TcxMultiEditorRowHeaderInfo.Destroy;
|
|
begin
|
|
FSeparatorRects.Free;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TcxMultiEditorRowHeaderInfo.CalcRowCaptionsInfo;
|
|
var
|
|
I: Integer;
|
|
R: TRect;
|
|
ARects: TcxRectList;
|
|
ACaptionInfo: TcxRowCaptionInfo;
|
|
begin
|
|
CalcSeparatorWidth(ViewInfo.DividerWidth);
|
|
CalcSeparatorStyle;
|
|
ARects := TcxMultiEditorRowViewInfo.GetCellRects(Row, HeaderCellsRect, FSeparatorInfo.Width);
|
|
if ARects <> nil then
|
|
try
|
|
for I := 0 to ARects.Count - 1 do
|
|
begin
|
|
R := ARects[I];
|
|
if R.Left < HeaderCellsRect.Right then
|
|
begin
|
|
ACaptionInfo := CalcCaptionInfo(Row.Properties.Editors[I], R);
|
|
ACaptionInfo.RowCellIndex := I;
|
|
CaptionsInfo.Add(ACaptionInfo);
|
|
end;
|
|
end;
|
|
CalcSeparatorRects(ARects);
|
|
finally
|
|
ARects.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxMultiEditorRowHeaderInfo.CalcSeparatorRects(
|
|
AHeaderCells: TcxRectList);
|
|
begin
|
|
TcxMultiEditorRowViewInfo(Row.ViewInfo).AddSeparatorRects(
|
|
True, SeparatorRects, SeparatorInfo.Kind, AHeaderCells, HeaderCellsRect);
|
|
end;
|
|
|
|
procedure TcxMultiEditorRowHeaderInfo.CalcSeparatorWidth(
|
|
ASeparatorWidth: Integer);
|
|
begin
|
|
with FSeparatorInfo do
|
|
begin
|
|
Kind := Row.Properties.SeparatorKind;
|
|
Caption := Row.Properties.SeparatorString;
|
|
if Kind = skVertLine then
|
|
Width := ASeparatorWidth
|
|
else
|
|
Width := cxTextWidth(Self.ViewParams.Font, SeparatorInfo.Caption + '0');
|
|
end;
|
|
end;
|
|
|
|
procedure TcxMultiEditorRowHeaderInfo.CalcSeparatorStyle;
|
|
begin
|
|
FSeparatorInfo.ViewParams := ViewParams;
|
|
with Row.Properties do
|
|
FSeparatorInfo.TextFlags := GetTextAligmentFlags(taCenter, SeparatorAlignmentVert);
|
|
end;
|
|
|
|
procedure TcxMultiEditorRowHeaderInfo.Clear;
|
|
begin
|
|
inherited Clear;
|
|
FSeparatorRects.Clear;
|
|
end;
|
|
|
|
function TcxMultiEditorRowHeaderInfo.GetRow: TcxMultiEditorRow;
|
|
begin
|
|
Result := TcxMultiEditorRow(FRow);
|
|
end;
|
|
|
|
{ TcxMultiEditorRowViewInfo }
|
|
|
|
constructor TcxMultiEditorRowViewInfo.Create(ARow: TcxCustomRow);
|
|
begin
|
|
inherited Create(ARow);
|
|
FSeparatorRects := TcxRectList.Create;
|
|
end;
|
|
|
|
destructor TcxMultiEditorRowViewInfo.Destroy;
|
|
begin
|
|
FreeAndNil(FSeparatorRects);
|
|
inherited Destroy;
|
|
end;
|
|
|
|
class function TcxMultiEditorRowViewInfo.GetCellRects(ARow: TcxMultiEditorRow;
|
|
const R: TRect; ASepWidth: Integer): TcxRectList;
|
|
var
|
|
I, ACount, AMinWidth: Integer;
|
|
begin
|
|
Result := nil;
|
|
AMinWidth := ARow.VerticalGrid.OptionsView.RowHeaderMinWidth;
|
|
ACount := ARow.Properties.Editors.Count;
|
|
with TRectScaler.Create do
|
|
try
|
|
for I := 0 to ACount - 1 do
|
|
Add(ARow.Properties.Editors[I].Width, AMinWidth,
|
|
cxSetValue(I = ACount - 1, 0, ASepWidth));
|
|
if ARow.Properties.Fixed then CalcRect(R) else ScaleRect(R);
|
|
if ScaledRects.Count > 0 then
|
|
begin
|
|
Result := TcxRectList.Create;
|
|
Result.Assign(ScaledRects);
|
|
end;
|
|
finally
|
|
Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxMultiEditorRowViewInfo.AddSeparatorRects(
|
|
AHeader: Boolean;
|
|
ASepRects: TcxRectList;
|
|
ASeparatorKind: TSeparatorKind;
|
|
AValueCells: TcxRectList;
|
|
const ABounds: TRect);
|
|
var
|
|
I: Integer;
|
|
R: TRect;
|
|
begin
|
|
for I := 0 to AValueCells.Count - 2 do
|
|
with AValueCells[I] do
|
|
if ASeparatorKind = skString then
|
|
begin
|
|
R := cxRect(Right, Top, AValueCells[I + 1].Left, Bottom);
|
|
if cxRectIntersect(R, R, ABounds) then ASepRects.Add(R)
|
|
end
|
|
else
|
|
begin
|
|
R := cxRect(Right - ViewInfo.DividerWidth, Top, Right, Bottom);
|
|
if cxRectIntersect(R, R, ABounds) then
|
|
if AHeader then
|
|
ViewInfo.CalcHelper.AddDivider(HeaderInfo.LinesInfo, R,
|
|
HeaderInfo.ViewParams.Color, True)
|
|
else
|
|
ViewInfo.CalcHelper.AddDivider(ViewInfo.LinesInfo, R,
|
|
HeaderInfo.ViewParams.Color, True);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxMultiEditorRowViewInfo.CalcValuesInfo;
|
|
var
|
|
I, J, ASepWidth, ACount, AValuesCount: Integer;
|
|
ABottomLineNeeded: Boolean;
|
|
ANextRow: TcxCustomRow;
|
|
ARects: TcxRectList;
|
|
ARowValueInfo: TcxRowValueInfo;
|
|
ASepKind: TSeparatorKind;
|
|
AValueRect, R: TRect;
|
|
begin
|
|
ACount := 0;
|
|
SeparatorRects.Clear;
|
|
with HeaderInfo.SeparatorInfo do
|
|
begin
|
|
ASepWidth := Width;
|
|
ASepKind := Kind;
|
|
end;
|
|
with ViewInfo do
|
|
begin
|
|
AValuesCount := VisibleValueCount;
|
|
for I := 0 to AValuesCount - 1 do
|
|
begin
|
|
AValueRect := GetValueRect(I, Self);
|
|
ARects := GetCellRects(Row, AValueRect, ASepWidth);
|
|
ANextRow := VerticalGrid.NextVisibleRow(Row);
|
|
ABottomLineNeeded := (ANextRow = nil) or not (ANextRow.ViewInfo is TcxCategoryRowViewInfo)
|
|
or (VerticalGrid.LookAndFeel.SkinPainter = nil);
|
|
if ARects <> nil then
|
|
begin
|
|
ACount := Min(ARects.Count, TcxCustomRowAccess(Row).GetEditContainerCount);
|
|
try
|
|
for J := 0 to ACount - 1 do
|
|
begin
|
|
R := ARects[J];
|
|
if not cxRectIsEmpty(R) then
|
|
begin
|
|
ARowValueInfo := CalcRowValueInfo(Row.Properties.Editors[J],
|
|
ViewInfo, FirstVisibleRecordIndex + I, J);
|
|
CalcEditCell(R, ARowValueInfo);
|
|
end;
|
|
end;
|
|
AddSeparatorRects(False, SeparatorRects, ASepKind, ARects, AValueRect);
|
|
finally
|
|
ARects.Free;
|
|
end;
|
|
end;
|
|
AddRectValueLines(AValueRect, I = AValuesCount - 1, ABottomLineNeeded);
|
|
end;
|
|
ValuesInfo.Trunc(AValuesCount * ACount);
|
|
end;
|
|
CheckEmptyValuesInfo;
|
|
end;
|
|
|
|
procedure TcxMultiEditorRowViewInfo.CheckEmptyValuesInfo;
|
|
begin
|
|
if (Row.Properties.Editors.Count = 0) and (cxRectWidth(ValuesRect) > 0) then
|
|
begin
|
|
HeaderInfo.LinesInfo.Add(RowRect, HeaderInfo.ViewParams.Color);
|
|
AddRectValueLines(ValuesRect, True, True);
|
|
end;
|
|
end;
|
|
|
|
function TcxMultiEditorRowViewInfo.GetValueHeight(ARecordIndex: Integer;
|
|
AWidth: Integer; AViewInfo: TcxvgCustomViewInfo): Integer;
|
|
var
|
|
I, J, ASepWidth, ACount, AValuesCount: Integer;
|
|
AValueRect, R: TRect;
|
|
ARects: TcxRectList;
|
|
ARowValueInfo: TcxRowValueInfoAccess;
|
|
begin
|
|
Result := -1;
|
|
ACount := 0;
|
|
ASepWidth := HeaderInfo.SeparatorInfo.Width;
|
|
with AViewInfo do
|
|
begin
|
|
AValuesCount := VisibleValueCount;
|
|
for I := 0 to AValuesCount - 1 do
|
|
begin
|
|
AValueRect := GetValueRect(I, Self);
|
|
ARects := GetCellRects(Row, AValueRect, ASepWidth);
|
|
if ARects <> nil then
|
|
begin
|
|
ACount := Min(ARects.Count, TcxCustomRowAccess(Row).GetEditContainerCount);
|
|
try
|
|
for J := 0 to ACount - 1 do
|
|
begin
|
|
R := ARects[J];
|
|
if not cxRectIsEmpty(R) then
|
|
begin
|
|
ARowValueInfo := TcxRowValueInfoAccess(CalcRowValueInfo(
|
|
Row.Properties.Editors[J], AViewInfo, FirstVisibleRecordIndex + I, J));
|
|
ARowValueInfo.CellContentRect := cxRectBounds(0, 0, R.Right - R.Left, 0);
|
|
Result := Max(Result, ARowValueInfo.CalculateEditHeight);
|
|
end;
|
|
end;
|
|
finally
|
|
ARects.Free;
|
|
end;
|
|
end;
|
|
end;
|
|
ValuesInfo.Trunc(AValuesCount * ACount);
|
|
end;
|
|
end;
|
|
|
|
function TcxMultiEditorRowViewInfo.GetHeaderInfo: TcxMultiEditorRowHeaderInfo;
|
|
begin
|
|
Result := TcxMultiEditorRowHeaderInfo(inherited HeaderInfo);
|
|
end;
|
|
|
|
function TcxMultiEditorRowViewInfo.GetRow: TcxMultiEditorRow;
|
|
begin
|
|
Result := TcxMultiEditorRow(inherited Row);
|
|
end;
|
|
|
|
function TcxMultiEditorRowViewInfo.GetSeparatorRects: TcxRectList;
|
|
begin
|
|
Result := FSeparatorRects;
|
|
end;
|
|
|
|
{ TcxInspectorViewInfo }
|
|
|
|
procedure TcxInspectorViewInfo.AddEmptyRects;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxInspectorViewInfo.CheckMaxRowHeaderWidth(var Value: Integer;
|
|
AValueMinWidth: Integer);
|
|
begin
|
|
if ViewBandWidth > 0 then
|
|
Value := Min(Value, ViewBandWidth - Max(AValueMinWidth, 4));
|
|
end;
|
|
|
|
function TcxInspectorViewInfo.GetViewValueWidth: Integer;
|
|
begin
|
|
Result := ViewBandWidth - ViewHeaderWidth - DividerWidth - 2 * VertLineWidth;
|
|
end;
|
|
|
|
function TcxInspectorViewInfo.GetVisibleValueCount: Integer;
|
|
begin
|
|
Result := 1;
|
|
end;
|
|
|
|
{ TcxBandsViewInfo }
|
|
|
|
procedure TcxBandsViewInfo.AddEmptyRects;
|
|
var
|
|
I, AHeight: Integer;
|
|
ABand: TRect;
|
|
begin
|
|
AHeight := ClientRect.Bottom - ClientRect.Top;
|
|
with ABand, ViewRects do
|
|
begin
|
|
if BandsIndent > 0 then
|
|
for I := 0 to BandRects.Count - 2 do
|
|
begin
|
|
ABand := BandRects[I];
|
|
EmptyRects.Add(cxRectBounds(Right, Top, BandsIndent, AHeight));
|
|
end;
|
|
// check last band
|
|
ABand := BandRects[BandRects.Count - 1];
|
|
if Right < ClientRect.Right then
|
|
//suppose non-autoWidth mode
|
|
EmptyRects.Add(cxRectBounds(Right, Top, ClientRect.Right - Right, AHeight));
|
|
end;
|
|
end;
|
|
|
|
procedure TcxBandsViewInfo.CalcBandRects;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
with Scroller do
|
|
for I := LeftVisibleBand to BandsInfo.Count - 1 do
|
|
CreateBand(BandsInfo[I].BandHeight, 40);
|
|
UpdateBandsWidth;
|
|
end;
|
|
|
|
procedure TcxBandsViewInfo.CalcBandWidth;
|
|
var
|
|
ABandIndentWidth, ASaveWidth, ABandCount: Integer;
|
|
APos: Double;
|
|
begin
|
|
ViewHeaderWidth := GetViewHeaderWidth;
|
|
if not AutoScaleBands then
|
|
begin
|
|
ViewValueWidth := GetViewValueWidth;
|
|
ViewBandWidth := GetViewBandWidth;
|
|
end
|
|
else
|
|
begin
|
|
if LockDividerPos then Exit;
|
|
ASaveWidth := GetViewBandWidth;
|
|
if ShowHeaders and (ASaveWidth > 0) then
|
|
APos := Max(GetViewBandWidth, VerticalGrid.OptionsView.ValueMinWidth ) / Max(ViewHeaderWidth, 1)
|
|
else
|
|
APos := 1;
|
|
ABandCount := Scroller.BandsInfo.Count;
|
|
ABandIndentWidth := cxSetValue(ABandCount > 1, (ABandCount - 1) * BandsIndent, 0);
|
|
ViewBandWidth := Max(GetMinViewBandWidth,
|
|
(cxRectWidth(ClientRect) - ABandIndentWidth) div Max(ABandCount, 1));
|
|
if ViewBandWidth < BandMinWidth then
|
|
ViewBandWidth := BandMinWidth;
|
|
if ShowHeaders and not FLock and (ASaveWidth > ViewHeaderWidth) and
|
|
(ASaveWidth <> ViewBandWidth) then
|
|
SetDividerPos(Round(ViewBandWidth / APos));
|
|
ViewHeaderWidth := GetViewHeaderWidth;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxBandsViewInfo.CalcLayoutGeneral;
|
|
begin
|
|
FAutoScaleBands := VerticalGrid.OptionsView.AutoScaleBands;
|
|
inherited CalcLayoutGeneral;
|
|
FBandsIndent := VerticalGrid.OptionsView.BandsInterval;
|
|
end;
|
|
|
|
function TcxBandsViewInfo.CanAddRowToBand(const ARowRect, ABandRect: TRect;
|
|
ABandRowIndex: Integer): Boolean;
|
|
begin
|
|
Result := (ARowRect.Bottom <= ABandRect.Bottom) or (ABandRowIndex = 0);
|
|
end;
|
|
|
|
procedure TcxBandsViewInfo.CreateBand(ABandHeight, ABandWidth: Integer);
|
|
var
|
|
ABandIndex, ALeft: Integer;
|
|
R: TRect;
|
|
begin
|
|
ABandIndex := ViewRects.BandRects.Count;
|
|
if ABandIndex = 0 then
|
|
ALeft := ClientRect.Left
|
|
else
|
|
ALeft := ViewRects.BandRects[ABandIndex - 1].Right;
|
|
R := cxRectBounds(ALeft, ClientRect.Top, ABandWidth,
|
|
Min(ABandHeight, cxRectHeight(ClientRect)));
|
|
ViewRects.BandRects.Add(R);
|
|
if R.Bottom < ClientRect.Bottom then
|
|
ViewRects.EmptyRects.Add(cxRectBounds(R.Left, R.Bottom, ABandIndex,
|
|
cxRectHeight(ClientRect) - cxRectHeight(R)));
|
|
end;
|
|
|
|
function TcxBandsViewInfo.GetBandSizeableRect(const ABandRect: TRect): TRect;
|
|
begin
|
|
if VerticalGrid.OptionsView.AutoScaleBands then
|
|
Result := cxNullRect
|
|
else
|
|
Result := inherited GetBandSizeableRect(ABandRect);
|
|
end;
|
|
|
|
function TcxBandsViewInfo.GetMinViewBandWidth: Integer;
|
|
begin
|
|
Result := GetViewMinHeaderWidth + VerticalGrid.OptionsView.ValueMinWidth
|
|
end;
|
|
|
|
function TcxBandsViewInfo.GetRowAutoHeight(ARow: TcxCustomRow): Boolean;
|
|
begin
|
|
with VerticalGrid.OptionsView do
|
|
Result := CellAutoHeight and not FAutoScaleBands and
|
|
ARow.Options.CanAutoHeight;
|
|
end;
|
|
|
|
function TcxBandsViewInfo.GetViewBandWidth: Integer;
|
|
begin
|
|
if not AutoScaleBands then
|
|
Result := ViewHeaderWidth + DividerWidth + ViewValueWidth + 2
|
|
else
|
|
Result := Max(ViewBandWidth, GetMinViewBandWidth);
|
|
end;
|
|
|
|
function TcxBandsViewInfo.GetViewValueWidth: Integer;
|
|
begin
|
|
Result := VerticalGrid.OptionsView.ValueWidth
|
|
end;
|
|
|
|
function TcxBandsViewInfo.GetVisibleValueCount: Integer;
|
|
begin
|
|
Result := 1;
|
|
end;
|
|
|
|
procedure TcxBandsViewInfo.LayoutStyleChanged;
|
|
begin
|
|
if AutoScaleBands then
|
|
begin
|
|
ViewHeaderWidth := Max(VerticalGrid.OptionsView.RowHeaderWidth, GetViewMinHeaderWidth);
|
|
SetDividerPos(ViewHeaderWidth);
|
|
ViewBandWidth := GetMinViewBandWidth;
|
|
end;
|
|
inherited LayoutStyleChanged;
|
|
end;
|
|
|
|
procedure TcxBandsViewInfo.SetDividerPos(APos: Integer);
|
|
begin
|
|
FLock := True;
|
|
try
|
|
if AutoScaleBands then
|
|
inherited SetDividerPos(APos)
|
|
else
|
|
begin
|
|
if APos > ClipRect.Right - 4 then APos := ClipRect.Right - 4;
|
|
VerticalGrid.OptionsView.RowHeaderWidth := APos;
|
|
end;
|
|
finally
|
|
FLock := False;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxBandsViewInfo.UpdateBandsWidth;
|
|
var
|
|
I, ACurLeft: Integer;
|
|
R, B: TRect;
|
|
begin
|
|
ACurLeft := ClientRect.Left;
|
|
with ViewRects do
|
|
begin
|
|
for I := 0 to BandRects.Count - 1 do
|
|
begin
|
|
R := BandRects[I];
|
|
R.Left := ACurLeft;
|
|
R.Right := R.Left + ViewBandWidth;
|
|
Inc(ACurLeft, ViewBandWidth + BandsIndent);
|
|
if AutoScaleBands then
|
|
begin
|
|
if I = BandRects.Count - 1 then
|
|
begin
|
|
Dec(ACurLeft, BandsIndent);
|
|
Inc(R.Right, ClientRect.Right - ACurLeft);
|
|
end;
|
|
end;
|
|
BandRects[I] := R;
|
|
end;
|
|
for I := 0 to EmptyRects.Count - 1 do
|
|
begin
|
|
R := EmptyRects[I];
|
|
B := BandRects[R.Right - R.Left];
|
|
R.Left := B.Left;
|
|
R.Right := B.Right;
|
|
EmptyRects[I] := R;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TcxMultiRecordViewInfo }
|
|
|
|
constructor TcxMultiRecordViewInfo.Create(AOwner: TcxEditingControl);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FVisibleValueCount := -1;
|
|
end;
|
|
|
|
function TcxMultiRecordViewInfo.GetDefaultGridModeBufferCount: Integer;
|
|
var
|
|
W: Integer;
|
|
begin
|
|
W := cxRectWidth(ClientRect) - ViewHeaderWidth - DividerWidth - VertLineWidth;
|
|
if W <= 0 then
|
|
begin
|
|
Result := 1;
|
|
Exit;
|
|
end;
|
|
Result := W div (ViewValueWidth + RecordsInterval);
|
|
if Result * (ViewValueWidth + RecordsInterval) < W then Inc(Result);
|
|
end;
|
|
|
|
function TcxMultiRecordViewInfo.GetValueRect(AValueIndex: Integer;
|
|
ARowViewInfo: TcxCustomRowViewInfo): TRect;
|
|
var
|
|
ALeft: Integer;
|
|
begin
|
|
with ARowViewInfo.RowRect do
|
|
begin
|
|
ALeft := Left + ViewHeaderWidth + DividerWidth +
|
|
AValueIndex * (ViewValueWidth + cxSetValue(RecordsInterval = 0, VertLineWidth,
|
|
RecordsInterval + 2 * VertLineWidth));
|
|
Result := cxRectBounds(ALeft, Top, ViewValueWidth, Bottom - Top);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxMultiRecordViewInfo.UpdateRecord(ARecordIndex: Integer);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
if ARecordIndex < 0 then Exit;
|
|
for I := 0 to RowsViewInfo.Count - 1 do
|
|
RowsViewInfo[I].UpdateRecord(ARecordIndex);
|
|
end;
|
|
|
|
procedure TcxMultiRecordViewInfo.AddBandRowsLines(const R: TRect);
|
|
var
|
|
ASize: TSize;
|
|
ABandRect: TRect;
|
|
I, ALeft, ATop, AHeight: Integer;
|
|
ARowInfo: TcxCustomRowViewInfo;
|
|
|
|
procedure AddRecordInterval(ALast: Boolean);
|
|
var
|
|
I: Integer;
|
|
R: TRect;
|
|
begin
|
|
if AHeight > 0 then
|
|
for I := 0 to VisibleValueCount - 2 do
|
|
begin
|
|
if (HorzLineWidth > 0) and not ALast then
|
|
LinesInfo.Add(ALeft, ATop + AHeight, RecordsInterval, HorzLineWidth,
|
|
BandBorderColor);
|
|
R := cxRectBounds(ALeft, ATop, RecordsInterval, AHeight);
|
|
if ALast then Inc(R.Bottom, HorzLineWidth);
|
|
ViewRects.EmptyRects.Add(R);
|
|
if VertLineWidth > 0 then
|
|
LinesInfo.Add(R.Right, R.Top, VertLineWidth, AHeight + HorzLineWidth,
|
|
BandBorderColor);
|
|
Inc(ALeft, ViewValueWidth + RecordsInterval + 2 * VertLineWidth);
|
|
end;
|
|
end;
|
|
|
|
begin
|
|
if RecordsInterval = 0 then
|
|
begin
|
|
inherited AddBandRowsLines(R);
|
|
Exit;
|
|
end;
|
|
ABandRect := R;
|
|
if RecordsInterval > 0 then
|
|
begin
|
|
ALeft := ABandRect.Left + FCommonWidth;
|
|
ATop := ClientRect.Top;
|
|
AHeight := 0;
|
|
for I := 0 to RowsViewInfo.Count - 1 do
|
|
begin
|
|
ARowInfo := RowsViewInfo[I];
|
|
if not (ARowInfo is TcxCategoryRowViewInfo) then
|
|
Inc(AHeight, cxRectHeight(ARowInfo.RowRect) + HorzLineWidth)
|
|
else
|
|
begin
|
|
AddRecordInterval(False);
|
|
AHeight := 0;
|
|
ATop := ARowInfo.RowRect.Bottom;
|
|
ALeft := ABandRect.Left + 2 * VertLineWidth + DividerWidth +
|
|
ViewHeaderWidth + ViewValueWidth;
|
|
end;
|
|
end;
|
|
AddRecordInterval(True);
|
|
end;
|
|
if (VertLineWidth > 0) then
|
|
with R do
|
|
LinesInfo.Add(Left, Top - HorzLineWidth, VertLineWidth, Bottom - Top,
|
|
BandBorderColor);
|
|
ALeft := R.Left;
|
|
ATop := R.Top;
|
|
ASize := cxSize(FCommonWidth, R.Bottom - R.Top);
|
|
while ALeft < R.Right do
|
|
begin
|
|
if ALeft + ASize.cx > R.Right then ASize.cx := R.Right - ALeft;
|
|
with cxRectBounds(ALeft, ATop, ASize.cx, ASize.cy) do
|
|
begin
|
|
if HorzLineWidth > 0 then
|
|
begin
|
|
LinesInfo.Add(Left, Top, Right - Left, HorzLineWidth, BandBorderColor);
|
|
LinesInfo.Add(Left, Bottom - HorzLineWidth, Right - Left, HorzLineWidth, BandBorderColor);
|
|
end;
|
|
end;
|
|
Inc(ALeft, RecordsInterval + ASize.cx);
|
|
ASize.cx := 2 * VertLineWidth + ViewValueWidth;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxMultiRecordViewInfo.AddEmptyRects;
|
|
var
|
|
ABandRect: TRect;
|
|
begin
|
|
ABandRect := ViewRects.BandRects[0];
|
|
// Inc(ABandRect.Bottom, HorzLineWidth * 2); ?
|
|
if ABandRect.Right < ClientRect.Right then
|
|
ViewRects.EmptyRects.Add(cxRect(ABandRect.Right, ABandRect.Top,
|
|
ClientRect.Right, ClientRect.Bottom));
|
|
end;
|
|
|
|
procedure TcxMultiRecordViewInfo.AddRightValueSide(const R: TRect;
|
|
ALast: Boolean);
|
|
begin
|
|
inherited AddRightValueSide(R, ALast or (FRecordsInterval > 0));
|
|
end;
|
|
|
|
procedure TcxMultiRecordViewInfo.CalcBandWidth;
|
|
var
|
|
AWidth: Integer;
|
|
begin
|
|
ViewHeaderWidth := GetViewHeaderWidth;
|
|
ViewValueWidth := VerticalGrid.OptionsView.ValueWidth;
|
|
AWidth := ViewHeaderWidth + 2 * VertLineWidth + DividerWidth + ViewValueWidth;
|
|
FCommonWidth := AWidth;
|
|
if RecordCount > 1 then
|
|
Inc(AWidth, (RecordCount - Scroller.LeftVisibleRecord - 1) *
|
|
(ViewValueWidth + cxSetValue(RecordsInterval = 0, VertLineWidth,
|
|
RecordsInterval + 2 * VertLineWidth)));
|
|
ViewBandWidth := Min(AWidth, cxRectWidth(ClientRect));
|
|
end;
|
|
|
|
procedure TcxMultiRecordViewInfo.CalcLayoutGeneral;
|
|
begin
|
|
FRecordsInterval :=
|
|
TcxvgMultiRecordsOptionsView(VerticalGrid.OptionsView).RecordsInterval;
|
|
inherited CalcLayoutGeneral;
|
|
end;
|
|
|
|
procedure TcxMultiRecordViewInfo.Clear;
|
|
begin
|
|
inherited Clear;
|
|
FVisibleValueCount := -1;
|
|
FCommonWidth := 0
|
|
end;
|
|
|
|
function TcxMultiRecordViewInfo.GetBandSizeableRect(
|
|
const ABandRect: TRect): TRect;
|
|
var
|
|
ALeft: Integer;
|
|
begin
|
|
if TcxVirtualVerticalGrid(VerticalGrid).LayoutStyle <> lsMultiRecordView then
|
|
Result := inherited GetBandSizeableRect(ABandRect)
|
|
else
|
|
with ClientRect do
|
|
begin
|
|
ALeft := ABandRect.Left + ViewHeaderWidth + DividerWidth + ViewValueWidth + VertLineWidth;
|
|
Result := cxRect(ALeft - 1, Top, ALeft + 2, Bottom);
|
|
end;
|
|
end;
|
|
|
|
function TcxMultiRecordViewInfo.GetRowHeight(
|
|
ARowViewInfo: TcxCustomRowViewInfo; ABandWidth: Integer): Integer;
|
|
var
|
|
I, ACount: Integer;
|
|
begin
|
|
Result := TcxCustomRowAccess(ARowViewInfo.Row).GetRealHeight;
|
|
if GetRowAutoHeight(ARowViewInfo.Row) and (ARowViewInfo.Row.Height < 0) then
|
|
begin
|
|
ACount := VisibleValueCount;
|
|
for I := 0 to ACount - 1 do
|
|
Result := Max(TcxCustomRowViewInfoAccess(ARowViewInfo).GetValueHeight(
|
|
FirstVisibleRecordIndex + I, ViewValueWidth, Self), Result);
|
|
end;
|
|
end;
|
|
|
|
function TcxMultiRecordViewInfo.GetVisibleValueCount: Integer;
|
|
begin
|
|
if FVisibleValueCount = -1 then
|
|
FVisibleValueCount := CalcVisibleValueCount;
|
|
Result := FVisibleValueCount;
|
|
end;
|
|
|
|
procedure TcxMultiRecordViewInfo.Reset;
|
|
begin
|
|
inherited Reset;
|
|
FVisibleValueCount := -1;
|
|
end;
|
|
|
|
procedure TcxMultiRecordViewInfo.SetDividerPos(APos: Integer);
|
|
begin
|
|
if APos > ClipRect.Right - 4 then APos := ClipRect.Right - 4;
|
|
VerticalGrid.OptionsView.RowHeaderWidth := APos;
|
|
end;
|
|
|
|
function TcxMultiRecordViewInfo.CalcVisibleValueCount: Integer;
|
|
begin
|
|
Result := 0;
|
|
if cxRectIsEmpty(ClientRect) then Exit;
|
|
Result := Max(1, Min(GetDefaultGridModeBufferCount,
|
|
RecordCount - Scroller.LeftVisibleRecord));
|
|
end;
|
|
|
|
function TcxMultiRecordViewInfo.GetRecordCount: Integer;
|
|
begin
|
|
Result := TcxCustomVerticalGridAccess(VerticalGrid).RecordCount;
|
|
end;
|
|
|
|
end.
|