david
47aaf11578
git-svn-id: https://192.168.0.254/svn/Componentes.Terceros.DevExpressVCL@38 05c56307-c608-d34a-929d-697000501d7a
3928 lines
121 KiB
ObjectPascal
3928 lines
121 KiB
ObjectPascal
|
|
{*******************************************************************}
|
|
{ }
|
|
{ Developer Express Visual Component Library }
|
|
{ ExpressInspector extended text rows }
|
|
{ }
|
|
{ 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 }
|
|
{ }
|
|
{ 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 dxInspRw;
|
|
|
|
interface
|
|
|
|
{$I dxInsVer.inc}
|
|
|
|
{$DEFINE FLATCHECKBOX}
|
|
|
|
uses
|
|
Windows, Messages, SysUtils, Classes, Graphics, Controls, StdCtrls, Menus,
|
|
dxCntner, dxEditor, dxExEdtr, dxInspct, dxGrDate, dxEdStr, dxCalc
|
|
{$IFDEF DELPHI4}, ImgList{$ENDIF}{$IFDEF DELPHI6}, Variants{$ENDIF};
|
|
|
|
type
|
|
{ TdxInspectorMaskRow }
|
|
|
|
TdxInspectorMaskEdit = class(TdxInplaceMaskEdit)
|
|
end;
|
|
|
|
TdxInspectorMaskRow = class(TdxInspectorRow)
|
|
private
|
|
FAssignedEditMask: Boolean;
|
|
FEditMask: string;
|
|
FIgnoreMaskBlank: Boolean;
|
|
function GetEditMask: string;
|
|
function IsEditMaskStored: Boolean;
|
|
procedure SetEditMask(const Value: string);
|
|
protected
|
|
function AssignEditValue(AInplaceEdit: TdxInplaceEdit): Variant; override;
|
|
function GetdxInplaceEditClass: TdxInplaceEditClass; override;
|
|
procedure InitEditProperties(AInplaceEdit: TdxInplaceEdit); override;
|
|
function InitEditValue(AInplaceEdit: TdxInplaceEdit): Variant; override;
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
function DefaultEditMask: string; virtual;
|
|
procedure RestoreDefaults; override;
|
|
published
|
|
property EditMask: string read GetEditMask write SetEditMask stored IsEditMaskStored;
|
|
property IgnoreMaskBlank: Boolean read FIgnoreMaskBlank write FIgnoreMaskBlank default False;
|
|
end;
|
|
|
|
{ TdxInspectorTextMaskRow }
|
|
|
|
TdxInspectorTextMaskRow = class(TdxInspectorMaskRow)
|
|
private
|
|
FText: string;
|
|
procedure SetText(const Value: String);
|
|
protected
|
|
function GetDisplayText: string; override;
|
|
function GetEditText: string; override;
|
|
procedure SetEditText(const Value: string); override;
|
|
published
|
|
property Text: string read FText write SetText;
|
|
end;
|
|
|
|
{ TdxInspectorDropDownRow }
|
|
|
|
TdxInspectorDropDownEdit = class(TdxInplaceDropDownEdit)
|
|
end;
|
|
|
|
TdxInspectorDropDownRow = class(TdxInspectorRow)
|
|
private
|
|
FButtonGlyph: TBitmap;
|
|
FDropDownRows: Integer;
|
|
FDropDownWidth: Integer;
|
|
FImmediateDropDown: Boolean;
|
|
FImmediatePopup: Boolean;
|
|
FPopupAlignment: TAlignment;
|
|
FPopupBorder: TdxPopupBorder;
|
|
FOnEditButtonClick: TNotifyEvent;
|
|
function GetButtonGlyph: TBitmap;
|
|
procedure SetButtonGlyph(Value: TBitmap);
|
|
protected
|
|
procedure DoCloseUp(Sender: TObject; var Value: string; var Accept: Boolean); virtual;
|
|
procedure EditButtonClick(Sender: TObject); virtual;
|
|
function GetdxInplaceEditClass : TdxInplaceEditClass; override;
|
|
procedure InitEditProperties(AInplaceEdit: TdxInplaceEdit); override;
|
|
procedure PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData); override;
|
|
property ButtonGlyph: TBitmap read GetButtonGlyph write SetButtonGlyph;
|
|
property DropDownRows: Integer read FDropDownRows write FDropDownRows default 7;
|
|
property DropDownWidth: Integer read FDropDownWidth write FDropDownWidth default 0;
|
|
property ImmediateDropDown: Boolean read FImmediateDropDown write FImmediateDropDown default False;
|
|
property ImmediatePopup: Boolean read FImmediatePopup write FImmediatePopup default False;
|
|
property PopupAlignment: TAlignment read FPopupAlignment write FPopupAlignment default taLeftJustify;
|
|
property PopupBorder: TdxPopupBorder read FPopupBorder write FPopupBorder default pbDefault;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
published
|
|
property OnEditButtonClick: TNotifyEvent read FOnEditButtonClick write FOnEditButtonClick;
|
|
end;
|
|
|
|
{ TdxInspectorDateRow }
|
|
|
|
TdxInspectorDateEdit = class(TdxInplaceDateEdit)
|
|
public
|
|
property Date;
|
|
end;
|
|
|
|
TdxInspectorDateRow = class(TdxInspectorDropDownRow)
|
|
private
|
|
FDateButtons: TDateButtons;
|
|
FDateOnError: TDateOnError;
|
|
FDateValidation: Boolean;
|
|
FSaveTime: Boolean;
|
|
FUseEditMask: Boolean;
|
|
FOnDateValidateInput: TdxDateValidateInput;
|
|
procedure DoValidateInput(Sender: TObject; const AText: string;
|
|
var ADate: TDateTime; var AMessage: string; var AError: Boolean);
|
|
protected
|
|
function GetdxInplaceEditClass: TdxInplaceEditClass; override;
|
|
procedure InitEditProperties(AInplaceEdit: TdxInplaceEdit); override;
|
|
function IsRequired: Boolean; virtual;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
published
|
|
property DateButtons: TDateButtons read FDateButtons write FDateButtons default [btnToday, btnClear];
|
|
property DateOnError: TDateOnError read FDateOnError write FDateOnError default deToday;
|
|
property DateValidation: Boolean read FDateValidation write FDateValidation default False;
|
|
property SaveTime: Boolean read FSaveTime write FSaveTime default True;
|
|
property UseEditMask: Boolean read FUseEditMask write FUseEditMask default False;
|
|
property OnDateValidateInput: TdxDateValidateInput read FOnDateValidateInput write FOnDateValidateInput;
|
|
property ButtonGlyph;
|
|
property PopupAlignment;
|
|
property PopupBorder;
|
|
end;
|
|
|
|
{ TdxInspectorTextDateRow }
|
|
|
|
TdxInspectorTextDateRow = class(TdxInspectorDateRow)
|
|
private
|
|
FText: string;
|
|
procedure SetText(const Value: string);
|
|
protected
|
|
function GetDisplayText: string; override;
|
|
function GetEditText: string; override;
|
|
procedure SetEditText(const Value: string); override;
|
|
published
|
|
property Text: string read FText write SetText;
|
|
end;
|
|
|
|
{ TdxInspectorCheckRow }
|
|
|
|
TdxInspectorCheckEdit = class(TdxInplaceCheckEdit)
|
|
public
|
|
property Checked;
|
|
property State;
|
|
end;
|
|
|
|
TdxInspectorCheckRow = class(TdxInspectorRow)
|
|
private
|
|
FAllowGrayed: Boolean;
|
|
FBorder3D: Boolean;
|
|
FGlyph: TBitmap;
|
|
FGlyphCount: Integer;
|
|
FShowNullFieldStyle: TdxShowNullFieldStyle;
|
|
FValueChecked: string;
|
|
FValueGrayed: string;
|
|
FValueUnchecked: string;
|
|
FOnToggleClick: TdxToggleEvent;
|
|
function GetGlyph: TBitmap;
|
|
procedure SetBorder3D(Value : Boolean);
|
|
procedure SetGlyph(Value: TBitmap);
|
|
procedure SetGlyphCount(Value: Integer);
|
|
procedure SetShowNullFieldStyle(Value: TdxShowNullFieldStyle);
|
|
procedure SetValueChecked(const Value: string);
|
|
procedure SetValueGrayed(const Value: string);
|
|
procedure SetValueUnchecked(const Value: string);
|
|
protected
|
|
function AssignEditValue(AInplaceEdit: TdxInplaceEdit): Variant; override;
|
|
procedure DoChange(Sender: TObject); override;
|
|
function GetdxInplaceEditClass: TdxInplaceEditClass; override;
|
|
function GetMinRowHeight(ACanvas: TCanvas): Integer; override;
|
|
procedure InitEditProperties(AInplaceEdit: TdxInplaceEdit); override;
|
|
function InitEditValue(AInplaceEdit: TdxInplaceEdit): Variant; override;
|
|
function IsShowHint(IsValue: Boolean; const R: TRect; var AText: string): Boolean; override;
|
|
procedure PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData); override;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
function GetCheckBoxState(const AText: string): TdxCheckBoxState;
|
|
function GetCheckBoxValue(AState: TdxCheckBoxState): string;
|
|
published
|
|
property AllowGrayed: Boolean read FAllowGrayed write FAllowGrayed default False;
|
|
property Border3D: Boolean read FBorder3D write SetBorder3D default False;
|
|
property Glyph: TBitmap read GetGlyph write SetGlyph;
|
|
property GlyphCount: Integer read FGlyphCount write SetGlyphCount default 6;
|
|
property ShowNullFieldStyle: TdxShowNullFieldStyle read FShowNullFieldStyle write SetShowNullFieldStyle default nsUnchecked;
|
|
property ValueChecked: string read FValueChecked write SetValueChecked;
|
|
property ValueGrayed: string read FValueGrayed write SetValueGrayed;
|
|
property ValueUnchecked: string read FValueUnchecked write SetValueUnchecked;
|
|
property OnToggleClick: TdxToggleEvent read FOnToggleClick write FOnToggleClick;
|
|
end;
|
|
|
|
{ TdxInspectorTextCheckRow }
|
|
|
|
TdxInspectorTextCheckRow = class(TdxInspectorCheckRow)
|
|
private
|
|
FText: string;
|
|
procedure SetText(const Value: string);
|
|
protected
|
|
function GetDisplayText: string; override;
|
|
function GetEditText: string; override;
|
|
procedure SetEditText(const Value: string); override;
|
|
published
|
|
property Text: string read FText write SetText;
|
|
end;
|
|
|
|
{ TdxInspectorCalcRow }
|
|
|
|
TdxInspectorCalcEdit = class(TdxInplaceCalcEdit)
|
|
end;
|
|
|
|
TdxInspectorCalcRow = class(TdxInspectorDropDownRow)
|
|
private
|
|
FBeepOnError: Boolean;
|
|
FButtonStyle : TdxButtonStyle;
|
|
FPrecision: Byte;
|
|
FShowButtonFrame: Boolean;
|
|
FQuickClose: Boolean;
|
|
protected
|
|
function GetdxInplaceEditClass : TdxInplaceEditClass; override;
|
|
procedure InitEditProperties(AInplaceEdit: TdxInplaceEdit); override;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
published
|
|
property BeepOnError: Boolean read FBeepOnError write FBeepOnError default True;
|
|
property ButtonGlyph;
|
|
property ButtonStyle: TdxButtonStyle read FButtonStyle write FButtonStyle default bsStandard;
|
|
property PopupAlignment;
|
|
property PopupBorder;
|
|
property Precision: Byte read FPrecision write FPrecision default dxDefCalcPrecision;
|
|
property QuickClose: Boolean read FQuickClose write FQuickClose default False;
|
|
property ShowButtonFrame: Boolean read FShowButtonFrame write FShowButtonFrame default False;
|
|
end;
|
|
|
|
{ TdxInspectorTextCalcRow }
|
|
|
|
TdxInspectorTextCalcRow = class(TdxInspectorCalcRow)
|
|
private
|
|
FText: string;
|
|
procedure SetText(const Value: string);
|
|
protected
|
|
function GetDisplayText: string; override;
|
|
function GetEditText: string; override;
|
|
procedure SetEditText(const Value: string); override;
|
|
published
|
|
property Text: string read FText write SetText;
|
|
end;
|
|
|
|
{ TdxInspectorButtonRow }
|
|
|
|
TdxInspectorButtonEdit = class(TdxInplaceButtonEdit)
|
|
end;
|
|
|
|
TdxInspectorButtonRow = class(TdxInspectorDropDownRow)
|
|
private
|
|
FButtonOnly: Boolean;
|
|
FButtons: TdxEditButtons;
|
|
FEditButtonStyle: TdxEditButtonStyle;
|
|
FClickKey: TShortCut;
|
|
FGlyph: TBitmap;
|
|
FHideEditCursor: Boolean;
|
|
FOnButtonClick: TdxEditButtonClickEvent;
|
|
procedure SetButtonOnly(Value: Boolean);
|
|
procedure SetButtons(Value: TdxEditButtons);
|
|
procedure SetEditButtonStyle(Value: TdxEditButtonStyle);
|
|
procedure SetGlyph(Value: TBitmap);
|
|
procedure SetHideEditCursor(Value: Boolean);
|
|
protected
|
|
procedure DoButtonClick(Sender: TObject; AbsoluteIndex: Integer); virtual;
|
|
function GetdxInplaceEditClass: TdxInplaceEditClass; override;
|
|
procedure InitEditProperties(AInplaceEdit: TdxInplaceEdit); override;
|
|
procedure PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData); override;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
published
|
|
property ButtonOnly: Boolean read FButtonOnly write SetButtonOnly default False;
|
|
property Buttons: TdxEditButtons read FButtons write SetButtons;
|
|
property EditButtonStyle: TdxEditButtonStyle read FEditButtonStyle write SetEditButtonStyle default ebsEllipsis;
|
|
property ClickKey: TShortCut read FClickKey write FClickKey default VK_RETURN + scCtrl;
|
|
property Glyph: TBitmap read FGlyph write SetGlyph;
|
|
property HideEditCursor: Boolean read FHideEditCursor write SetHideEditCursor default False;
|
|
property OnButtonClick: TdxEditButtonClickEvent read FOnButtonClick write FOnButtonClick;
|
|
end;
|
|
|
|
{ TdxInspectorTextButtonRow }
|
|
|
|
TdxInspectorTextButtonRow = class(TdxInspectorButtonRow)
|
|
private
|
|
FText: string;
|
|
procedure SetText(const Value: string);
|
|
protected
|
|
function GetDisplayText: string; override;
|
|
function GetEditText: string; override;
|
|
procedure SetEditText(const Value: string); override;
|
|
published
|
|
property Text: string read FText write SetText;
|
|
end;
|
|
|
|
{ TdxInspectorSpinRow }
|
|
|
|
TdxInspectorSpinEdit = class(TdxInplaceSpinEdit)
|
|
public
|
|
property IntValue;
|
|
property Value;
|
|
end;
|
|
|
|
TdxSpinRowValue = (srMinValue, srMaxValue);
|
|
TdxSpinRowValues = set of TdxSpinRowValue;
|
|
|
|
TdxInspectorSpinRow = class(TdxInspectorRow)
|
|
private
|
|
FAssignedValues: TdxSpinRowValues;
|
|
FEditorEnabled: Boolean;
|
|
FIncrement: Double;
|
|
FMinValue: Double;
|
|
FMaxValue: Double;
|
|
FUseCtrlIncrement: Boolean;
|
|
function IsIncrementStored: Boolean;
|
|
function IsMaxStored: Boolean;
|
|
function IsMinStored: Boolean;
|
|
function GetMinValue: Double;
|
|
function GetMaxValue: Double;
|
|
procedure SetMinValue(Value: Double);
|
|
procedure SetMaxValue(Value: Double);
|
|
protected
|
|
function AssignEditValue(AInplaceEdit: TdxInplaceEdit): Variant; override;
|
|
function GetdxInplaceEditClass: TdxInplaceEditClass; override;
|
|
procedure InitEditProperties(AInplaceEdit: TdxInplaceEdit); override;
|
|
function InitEditValue(AInplaceEdit: TdxInplaceEdit): Variant; override;
|
|
procedure PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData); override;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
function DefaultMinValue: Double; virtual;
|
|
function DefaultMaxValue: Double; virtual;
|
|
function GetValueType: TdxValueType; virtual;
|
|
procedure RestoreDefaults; override;
|
|
property AssignedSpinValues: TdxSpinRowValues read FAssignedValues;
|
|
property ValueType: TdxValueType read GetValueType;
|
|
published
|
|
property EditorEnabled: Boolean read FEditorEnabled write FEditorEnabled default True;
|
|
property Increment: Double read FIncrement write FIncrement stored IsIncrementStored;
|
|
property MinValue: Double read GetMinValue write SetMinValue stored IsMinStored;
|
|
property MaxValue: Double read GetMaxValue write SetMaxValue stored IsMaxStored;
|
|
property UseCtrlIncrement: Boolean read FUseCtrlIncrement write FUseCtrlIncrement default True;
|
|
end;
|
|
|
|
{ TdxInspectorTextSpinRow }
|
|
|
|
TdxInspectorTextSpinRow = class(TdxInspectorSpinRow)
|
|
private
|
|
FText: string;
|
|
FValueType: TdxValueType;
|
|
procedure SetText(const Value: string);
|
|
protected
|
|
function GetDisplayText: string; override;
|
|
function GetEditText: string; override;
|
|
procedure SetEditText(const Value: string); override;
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
function GetValueType: TdxValueType; override;
|
|
published
|
|
property Text: string read FText write SetText;
|
|
property ValueType: TdxValueType read GetValueType write FValueType default vtInt;
|
|
end;
|
|
|
|
{ TdxInspectorPickRow }
|
|
|
|
TdxInspectorPickEdit = class(TdxInplacePickEdit)
|
|
public
|
|
property ItemIndex;
|
|
end;
|
|
|
|
TdxInspectorPickColumnCloseUp = procedure(Sender: TObject; var Value: Variant; var Accept: Boolean) of object;
|
|
|
|
TdxInspectorPickRow = class(TdxInspectorDropDownRow)
|
|
private
|
|
FDropDownListStyle: Boolean;
|
|
FItems: TStrings;
|
|
FCanDeleteText: Boolean;
|
|
FRevertable: Boolean;
|
|
FSorted: Boolean;
|
|
FOnCloseUp: TdxInspectorPickColumnCloseUp;
|
|
procedure SetItems(Value : TStrings);
|
|
protected
|
|
procedure DoCloseUp(Sender: TObject; var Value: string; var Accept: Boolean); override;
|
|
function GetdxInplaceEditClass: TdxInplaceEditClass; override;
|
|
procedure InitEditProperties(AInplaceEdit: TdxInplaceEdit); override;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
published
|
|
property ButtonGlyph;
|
|
property DropDownListStyle: Boolean read FDropDownListStyle write FDropDownListStyle default False;
|
|
property Items: TStrings read FItems write SetItems;
|
|
property DropDownRows;
|
|
property DropDownWidth;
|
|
property ImmediateDropDown default True;
|
|
property CanDeleteText: Boolean read FCanDeleteText write FCanDeleteText default False;
|
|
property PopupAlignment;
|
|
property PopupBorder;
|
|
property Revertable: Boolean read FRevertable write FRevertable default True;
|
|
property Sorted: Boolean read FSorted write FSorted default False;
|
|
property OnCloseUp: TdxInspectorPickColumnCloseUp read FOnCloseUp write FOnCloseUp;
|
|
end;
|
|
|
|
{ TdxInspectorTextPickRow }
|
|
|
|
TdxInspectorTextPickRow = class(TdxInspectorPickRow)
|
|
private
|
|
FText: string;
|
|
procedure SetText(const Value: string);
|
|
protected
|
|
function GetDisplayText: string; override;
|
|
function GetEditText: string; override;
|
|
procedure SetEditText(const Value: string); override;
|
|
published
|
|
property Text: string read FText write SetText;
|
|
end;
|
|
|
|
{ TdxInspectorImageRow }
|
|
|
|
TdxInspectorImageEdit = class(TdxInplaceImageEdit)
|
|
end;
|
|
|
|
TdxInspectorImageColumnCloseUp = procedure(Sender: TObject; var Value: string; var Accept: Boolean) of object;
|
|
|
|
TdxInspectorImageRow = class(TdxInspectorDropDownRow)
|
|
private
|
|
FDefaultImages: Boolean;
|
|
FDescriptions: TStrings;
|
|
FImageChangeLink: TChangeLink;
|
|
FImageIndexes: TStrings;
|
|
FImages: TImageList;
|
|
FLargeImageChangeLink: TChangeLink;
|
|
FLargeImages: TImageList;
|
|
FMultiLineText: Boolean;
|
|
FShowDescription: Boolean;
|
|
FValues: TStrings;
|
|
FOnCloseUp: TdxInspectorImageColumnCloseUp;
|
|
function GetListWidth: Integer;
|
|
procedure ImageListChange(Sender: TObject);
|
|
procedure SetDefaultImages(Value: Boolean);
|
|
procedure SetDescriptions(Value: TStrings);
|
|
procedure SetImageIndexes(Value: TStrings);
|
|
procedure SetImages(Value: TImageList);
|
|
procedure SetLargeImages(Value: TImageList);
|
|
procedure SetListWidth(Value: Integer);
|
|
procedure SetMultiLineText(Value: Boolean);
|
|
procedure SetShowDescription(Value : Boolean);
|
|
procedure SetValues(Value : TStrings);
|
|
protected
|
|
procedure Notification(AComponent: TComponent; Operation: TOperation); override;
|
|
procedure DoCloseUp(Sender: TObject; var Value: string; var Accept: Boolean); override;
|
|
function GetMinRowHeight(ACanvas: TCanvas): Integer; override;
|
|
function GetdxInplaceEditClass: TdxInplaceEditClass; override;
|
|
procedure InitEditProperties(AInplaceEdit: TdxInplaceEdit); override;
|
|
function IsShowHint(IsValue: Boolean; const R: TRect; var AText: string): Boolean; override;
|
|
procedure PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData); override;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
function GetImageIndex(const AText: string): Integer;
|
|
procedure GetIndexes(const AText: string; var AImageIndex, ADescIndex: Integer);
|
|
procedure RestoreDefaults; override;
|
|
published
|
|
property Alignment stored True;
|
|
property ButtonGlyph;
|
|
property DefaultImages: Boolean read FDefaultImages write SetDefaultImages default True;
|
|
property Descriptions: TStrings read FDescriptions write SetDescriptions;
|
|
property DropDownRows;
|
|
property DropDownWidth;
|
|
property Images: TImageList read FImages write SetImages;
|
|
property ImageIndexes: TStrings read FImageIndexes write SetImageIndexes;
|
|
property LargeImages: TImageList read FLargeImages write SetLargeImages;
|
|
property ListWidth: Integer read GetListWidth write SetListWidth stored False; // obsolete (use DropDownWidth)
|
|
property MultiLineText: Boolean read FMultiLineText write SetMultiLineText default False;
|
|
property PopupAlignment;
|
|
property PopupBorder;
|
|
property ShowDescription: Boolean read FShowDescription write SetShowDescription default False;
|
|
property Values: TStrings read FValues write SetValues;
|
|
property OnCloseUp: TdxInspectorImageColumnCloseUp read FOnCloseUp write FOnCloseUp;
|
|
end;
|
|
|
|
{ TdxInspectorTextImageRow }
|
|
|
|
TdxInspectorTextImageRow = class(TdxInspectorImageRow)
|
|
private
|
|
FText: string;
|
|
procedure SetText(const Value: string);
|
|
protected
|
|
function GetDisplayText: string; override;
|
|
function GetEditText: string; override;
|
|
procedure SetEditText(const Value: string); override;
|
|
published
|
|
property Text: string read FText write SetText;
|
|
end;
|
|
|
|
{ TdxInspectorTimeRow }
|
|
|
|
TdxInspectorTimeEdit = class(TdxInplaceTimeEdit)
|
|
public
|
|
property Time;
|
|
end;
|
|
|
|
TdxInspectorTimeRow = class(TdxInspectorRow)
|
|
private
|
|
FTimeEditFormat: TdxTimeEditFormat;
|
|
FUseCtrlIncrement: Boolean;
|
|
protected
|
|
function AssignEditValue(AInplaceEdit: TdxInplaceEdit): Variant; override;
|
|
function GetdxInplaceEditClass: TdxInplaceEditClass; override;
|
|
procedure InitEditProperties(AInplaceEdit: TdxInplaceEdit); override;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
published
|
|
property TimeEditFormat: TdxTimeEditFormat read FTimeEditFormat write FTimeEditFormat default tfHourMinSec;
|
|
property UseCtrlIncrement: Boolean read FUseCtrlIncrement write FUseCtrlIncrement default True;
|
|
end;
|
|
|
|
{ TdxInspectorTextTimeRow }
|
|
|
|
TdxInspectorTextTimeRow = class(TdxInspectorTimeRow)
|
|
private
|
|
FText: string;
|
|
procedure SetText(const Value: string);
|
|
protected
|
|
function GetDisplayText: string; override;
|
|
function GetEditText: string; override;
|
|
procedure SetEditText(const Value: string); override;
|
|
published
|
|
property Text: string read FText write SetText;
|
|
end;
|
|
|
|
{ TdxInspectorCurrencyRow }
|
|
|
|
TdxInspectorCurrencyEdit = class(TdxInplaceCurrencyEdit)
|
|
public
|
|
property Value;
|
|
end;
|
|
|
|
TdxInspectorCurrencyRow = class(TdxInspectorRow)
|
|
private
|
|
FAssignedValues: TdxSpinRowValues;
|
|
FDecimalPlaces: Cardinal;
|
|
FDisplayFormat: string;
|
|
FDisplayFormatStored: Boolean;
|
|
FMaxValue: Double;
|
|
FMinValue: Double;
|
|
FNullable: Boolean;
|
|
FNullString: string;
|
|
FUseThousandSeparator: Boolean;
|
|
function IsMaxStored: Boolean;
|
|
function IsMinStored: Boolean;
|
|
function GetMinValue: Double;
|
|
function GetMaxValue: Double;
|
|
procedure SetDisplayFormat(const Value: string);
|
|
procedure SetMinValue(Value : Double);
|
|
procedure SetMaxValue(Value : Double);
|
|
procedure SetNullable(Value: Boolean);
|
|
procedure SetNullString(const Value: string);
|
|
procedure CMWinIniChange(var Message: TWMWinIniChange); message CM_WININICHANGE;
|
|
protected
|
|
function AssignEditValue(AInplaceEdit: TdxInplaceEdit): Variant; override;
|
|
function GetDataValue: Variant; virtual;
|
|
function GetdxInplaceEditClass: TdxInplaceEditClass; override;
|
|
procedure InitEditProperties(AInplaceEdit: TdxInplaceEdit); override;
|
|
function InitEditValue(AInplaceEdit: TdxInplaceEdit): Variant; override;
|
|
procedure PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData); override;
|
|
property Nullable: Boolean read FNullable write SetNullable default False;
|
|
property NullString: string read FNullString write SetNullString;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
function DefaultMinValue: Double; virtual;
|
|
function DefaultMaxValue: Double; virtual;
|
|
procedure RestoreDefaults; override;
|
|
property AssignedValues: TdxSpinRowValues read FAssignedValues;
|
|
published
|
|
property DecimalPlaces: Cardinal read FDecimalPlaces write FDecimalPlaces default 2;
|
|
property DisplayFormat: string read FDisplayFormat write SetDisplayFormat stored FDisplayFormatStored;
|
|
property MinValue: Double read GetMinValue write SetMinValue stored IsMinStored;
|
|
property MaxValue: Double read GetMaxValue write SetMaxValue stored IsMaxStored;
|
|
property UseThousandSeparator: Boolean read FUseThousandSeparator write FUseThousandSeparator default False;
|
|
end;
|
|
|
|
{ TdxInspectorTextCurrencyRow }
|
|
|
|
TdxInspectorTextCurrencyRow = class(TdxInspectorCurrencyRow)
|
|
private
|
|
FText: string;
|
|
procedure SetText(const Value: string);
|
|
protected
|
|
function GetDisplayText: string; override;
|
|
function GetEditText: string; override;
|
|
procedure SetEditText(const Value: string); override;
|
|
published
|
|
property Text: string read FText write SetText;
|
|
end;
|
|
|
|
{ TdxInspectorHyperLinkRow }
|
|
|
|
TdxInspectorHyperLinkEdit = class(TdxInplaceHyperLinkEdit)
|
|
end;
|
|
|
|
TdxInspectorHyperLinkRow = class(TdxInspectorRow)
|
|
private
|
|
FEditBackgroundColor: TColor;
|
|
FEditFontColor: TColor;
|
|
FLinkFont: TFont;
|
|
FSingleClick: Boolean;
|
|
FStartKey: TShortCut;
|
|
FOnStartClick: TNotifyEvent;
|
|
procedure PrepareLinkFont;
|
|
procedure SetEditBackgroundColor(Value: TColor);
|
|
procedure SetEditFontColor(Value: TColor);
|
|
procedure SetSingleClick(Value: Boolean);
|
|
protected
|
|
procedure DoStartClick(Sender: TObject); virtual;
|
|
function GetdxInplaceEditClass: TdxInplaceEditClass; override;
|
|
procedure InitEditProperties(AInplaceEdit: TdxInplaceEdit); override;
|
|
procedure PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData); override;
|
|
property LinkFont: TFont read FLinkFont;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
published
|
|
property EditBackgroundColor: TColor read FEditBackgroundColor write SetEditBackgroundColor default clWhite;
|
|
property EditFontColor: TColor read FEditFontColor write SetEditFontColor default clBlue;
|
|
property SingleClick: Boolean read FSingleClick write SetSingleClick default False;
|
|
property StartKey: TShortCut read FStartKey write FStartKey default VK_RETURN + scCtrl;
|
|
property OnStartClick: TNotifyEvent read FOnStartClick write FOnStartClick;
|
|
end;
|
|
|
|
{ TdxInspectorTextHyperLinkRow }
|
|
|
|
TdxInspectorTextHyperLinkRow = class(TdxInspectorHyperLinkRow)
|
|
private
|
|
FText: string;
|
|
procedure SetText(const Value: string);
|
|
protected
|
|
function GetDisplayText: string; override;
|
|
function GetEditText: string; override;
|
|
procedure SetEditText(const Value: string); override;
|
|
published
|
|
property Text: string read FText write SetText;
|
|
end;
|
|
|
|
{ TdxInspectorCustomBlobRow }
|
|
|
|
TdxInspectorBlobEdit = class(TdxInplaceBlobEdit)
|
|
public
|
|
property Text;
|
|
end;
|
|
|
|
TdxInspectorBlobRowGetGraphicClassEvent = procedure(Sender: TObject; var GraphicClass: TGraphicClass) of object;
|
|
TdxInspectorBlobRowAssignPictureEvent = procedure(Sender: TObject; var Picture: TPicture) of object;
|
|
|
|
TdxInspectorCustomBlobRow = class(TdxInspectorDropDownRow)
|
|
private
|
|
FAlwaysSaveText: Boolean;
|
|
FBlobEditKind: TdxBlobEditKind;
|
|
FBlobKind: TdxBlobKind;
|
|
FBlobPaintStyle: TdxBlobPaintStyle;
|
|
FMaxDisplayLength: Integer;
|
|
FMemoCharCase: TEditCharCase;
|
|
FMemoHideScrollBars: Boolean;
|
|
FMemoMaxLength: Integer;
|
|
FMemoOEMConvert: Boolean;
|
|
FMemoScrollBars: TScrollStyle;
|
|
FMemoSelectionBar: Boolean;
|
|
FMemoWantReturns: Boolean;
|
|
FMemoWantTabs: Boolean;
|
|
FMemoWordWrap: Boolean;
|
|
FPictureAutoSize: Boolean;
|
|
FPictureClipboardFormat: Word;
|
|
FPictureGraphicClass: TGraphicClass;
|
|
FPictureFilter: string;
|
|
FPictureTransparency: TdxGraphicEditTransparency;
|
|
FPopupHeight: Integer;
|
|
FPopupWidth: Integer;
|
|
FShowExPopupItems: Boolean;
|
|
FShowPicturePopup: Boolean;
|
|
FSizeablePopup: Boolean;
|
|
FOnAssignPicture: TdxInspectorBlobRowAssignPictureEvent;
|
|
FOnGetGraphicClass: TdxInspectorBlobRowGetGraphicClassEvent;
|
|
procedure SetBlobEditKind(Value: TdxBlobEditKind);
|
|
procedure SetBlobKind(Value: TdxBlobKind);
|
|
procedure SetBlobPaintStyle(Value: TdxBlobPaintStyle);
|
|
protected
|
|
function AssignEditValue(AInplaceEdit: TdxInplaceEdit): Variant; override;
|
|
procedure DoAssignPicture(Sender: TObject; var Picture: TPicture); virtual;
|
|
procedure DoGetGraphicClass(Sender: TObject; var GraphicClass: TGraphicClass); virtual;
|
|
procedure DoSavePopupSize(Sender: TObject); virtual;
|
|
function GetBlobData: Variant; virtual;
|
|
function GetBlobEditKind: TdxBlobEditKind; virtual;
|
|
function GetBlobText: string; virtual;
|
|
function GetdxInplaceEditClass: TdxInplaceEditClass; override;
|
|
function GetGraphicClass: TGraphicClass; virtual;
|
|
procedure InitEditProperties(AInplaceEdit: TdxInplaceEdit); override;
|
|
function InitEditValue(AInplaceEdit: TdxInplaceEdit): Variant; override;
|
|
procedure PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData); override;
|
|
property BlobEditKind: TdxBlobEditKind read FBlobEditKind write SetBlobEditKind default bekMemo;
|
|
property BlobKind: TdxBlobKind read FBlobKind write SetBlobKind default bkAuto;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
property PictureClipboardFormat: Word read FPictureClipboardFormat write FPictureClipboardFormat;
|
|
property PictureGraphicClass: TGraphicClass read FPictureGraphicClass write FPictureGraphicClass;
|
|
published
|
|
property AlwaysSaveText: Boolean read FAlwaysSaveText write FAlwaysSaveText default False;
|
|
property BlobPaintStyle: TdxBlobPaintStyle read FBlobPaintStyle write SetBlobPaintStyle default bpsIcon;
|
|
property ImmediatePopup;
|
|
property MaxDisplayLength: Integer read FMaxDisplayLength write FMaxDisplayLength default 255;
|
|
property MemoCharCase: TEditCharCase read FMemoCharCase write FMemoCharCase default ecNormal;
|
|
property MemoHideScrollBars: Boolean read FMemoHideScrollBars write FMemoHideScrollBars default True;
|
|
property MemoMaxLength: Integer read FMemoMaxLength write FMemoMaxLength default 0;
|
|
property MemoOEMConvert: Boolean read FMemoOEMConvert write FMemoOEMConvert default False;
|
|
property MemoScrollBars: TScrollStyle read FMemoScrollBars write FMemoScrollBars default ssBoth;
|
|
property MemoSelectionBar: Boolean read FMemoSelectionBar write FMemoSelectionBar default False;
|
|
property MemoWantReturns: Boolean read FMemoWantReturns write FMemoWantReturns default True;
|
|
property MemoWantTabs: Boolean read FMemoWantTabs write FMemoWantTabs default True;
|
|
property MemoWordWrap: Boolean read FMemoWordWrap write FMemoWordWrap default True;
|
|
property PictureAutoSize: Boolean read FPictureAutoSize write FPictureAutoSize default True;
|
|
property PictureFilter: string read FPictureFilter write FPictureFilter;
|
|
property PictureTransparency: TdxGraphicEditTransparency read FPictureTransparency write FPictureTransparency default gtDefault;
|
|
property PopupAlignment;
|
|
property PopupBorder;
|
|
property PopupHeight: Integer read FPopupHeight write FPopupHeight default 140;
|
|
property PopupWidth: Integer read FPopupWidth write FPopupWidth default 200;
|
|
property ShowExPopupItems: Boolean read FShowExPopupItems write FShowExPopupItems default False;
|
|
property ShowPicturePopup: Boolean read FShowPicturePopup write FShowPicturePopup default False;
|
|
property SizeablePopup: Boolean read FSizeablePopup write FSizeablePopup default True;
|
|
property OnAssignPicture: TdxInspectorBlobRowAssignPictureEvent read FOnAssignPicture write FOnAssignPicture;
|
|
property OnGetGraphicClass: TdxInspectorBlobRowGetGraphicClassEvent read FOnGetGraphicClass write FOnGetGraphicClass;
|
|
end;
|
|
|
|
{ TdxInspectorTextBlobRow }
|
|
|
|
TdxInspectorTextBlobRow = class(TdxInspectorCustomBlobRow)
|
|
private
|
|
FText: string;
|
|
procedure SetText(const Value: string);
|
|
protected
|
|
function GetDisplayText: string; override;
|
|
function GetEditText: string; override;
|
|
procedure SetEditText(const Value: string); override;
|
|
published
|
|
property BlobEditKind;
|
|
property Text: string read FText write SetText;
|
|
end;
|
|
|
|
{ TdxInspectorMRURow }
|
|
|
|
TdxInspectorMRUEdit = class(TdxInplaceMRUEdit)
|
|
public
|
|
property Text;
|
|
end;
|
|
|
|
TdxInspectorMRURow = class(TdxInspectorPickRow)
|
|
private
|
|
FMaxItemCount: Integer;
|
|
FShowEllipsis: Boolean;
|
|
FOnButtonClick: TNotifyEvent;
|
|
procedure SetShowEllipsis(Value: Boolean);
|
|
protected
|
|
function AssignEditValue(AInplaceEdit: TdxInplaceEdit): Variant; override;
|
|
procedure DoButtonClick(Sender: TObject); virtual;
|
|
function GetdxInplaceEditClass: TdxInplaceEditClass; override;
|
|
procedure InitEditProperties(AInplaceEdit: TdxInplaceEdit); override;
|
|
procedure PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData); override;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
published
|
|
property ImmediateDropDown default False;
|
|
property MaxItemCount: Integer read FMaxItemCount write FMaxItemCount default 7;
|
|
property ShowEllipsis: Boolean read FShowEllipsis write SetShowEllipsis default True;
|
|
property OnButtonClick: TNotifyEvent read FOnButtonClick write FOnButtonClick;
|
|
end;
|
|
|
|
{ TdxInspectorTextMRURow }
|
|
|
|
TdxInspectorTextMRURow = class(TdxInspectorMRURow)
|
|
private
|
|
FText: string;
|
|
procedure SetText(const Value: string);
|
|
protected
|
|
function GetDisplayText: string; override;
|
|
function GetEditText: string; override;
|
|
procedure SetEditText(const Value: string); override;
|
|
published
|
|
property Text: string read FText write SetText;
|
|
end;
|
|
|
|
{ TdxInspectorPopupRow }
|
|
|
|
TdxInspectorPopupEdit = class(TdxInplacePopupEdit)
|
|
public
|
|
property Text;
|
|
// original
|
|
property HideEditCursor;
|
|
property PopupAutoSize;
|
|
property PopupControl;
|
|
property PopupFormBorderStyle;
|
|
property PopupFormCaption;
|
|
property PopupClientEdge;
|
|
property PopupFlatBorder;
|
|
property PopupHeight;
|
|
property PopupMinHeight;
|
|
property PopupMinWidth;
|
|
property PopupSizeable;
|
|
property PopupWidth;
|
|
end;
|
|
|
|
TdxInspectorPopupRow = class(TdxInspectorDropDownRow)
|
|
private
|
|
FHideEditCursor: Boolean;
|
|
FPopupAutoSize: Boolean;
|
|
FPopupControl: TControl;
|
|
FPopupFormBorderStyle: TdxPopupEditFormBorderStyle;
|
|
FPopupFormCaption: string;
|
|
FPopupFormClientEdge: Boolean;
|
|
FPopupFormFlatBorder: Boolean;
|
|
FPopupFormSizeable: Boolean;
|
|
FPopupHeight: Integer;
|
|
FPopupMinHeight: Integer;
|
|
FPopupMinWidth: Integer;
|
|
FPopupWidth: Integer;
|
|
FOnCloseQuery: TdxPopupEditCloseQueryEvent;
|
|
FOnCloseUp: TdxPopupEditCloseUpEvent;
|
|
FOnInitPopup: TNotifyEvent;
|
|
FOnPopup: TdxPopupEditPopupEvent;
|
|
procedure SetPopupControl(Value: TControl);
|
|
procedure SetPopupHeight(Value: Integer);
|
|
procedure SetPopupMinHeight(Value: Integer);
|
|
procedure SetPopupMinWidth(Value: Integer);
|
|
procedure SetPopupWidth(Value: Integer);
|
|
protected
|
|
procedure Notification(AComponent: TComponent; Operation: TOperation); override;
|
|
procedure DoCloseQuery(Sender: TObject; var CanClose: Boolean); virtual;
|
|
procedure DoCloseUp(Sender: TObject; var Text: string; var Accept: Boolean);
|
|
{$IFDEF DELPHI4} reintroduce; {$ENDIF} virtual;
|
|
procedure DoInitPopup(Sender: TObject); virtual;
|
|
procedure DoPopup(Sender: TObject; const EditText: string); virtual;
|
|
function GetdxInplaceEditClass: TdxInplaceEditClass; override;
|
|
procedure InitEditProperties(AInplaceEdit: TdxInplaceEdit); override;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
published
|
|
property HideEditCursor: Boolean read FHideEditCursor write FHideEditCursor default False;
|
|
property PopupAutoSize: Boolean read FPopupAutoSize write FPopupAutoSize default True;
|
|
property PopupControl: TControl read FPopupControl write SetPopupControl;
|
|
property PopupFormBorderStyle: TdxPopupEditFormBorderStyle read FPopupFormBorderStyle write FPopupFormBorderStyle default pbsDialog;
|
|
property PopupFormCaption: string read FPopupFormCaption write FPopupFormCaption;
|
|
property PopupFormClientEdge: Boolean read FPopupFormClientEdge write FPopupFormClientEdge default False;
|
|
property PopupFormFlatBorder: Boolean read FPopupFormFlatBorder write FPopupFormFlatBorder default True;
|
|
property PopupFormSizeable: Boolean read FPopupFormSizeable write FPopupFormSizeable default True;
|
|
property PopupHeight: Integer read FPopupHeight write SetPopupHeight default 200;
|
|
property PopupMinHeight: Integer read FPopupMinHeight write SetPopupMinHeight default 100;
|
|
property PopupMinWidth: Integer read FPopupMinWidth write SetPopupMinWidth default 100;
|
|
property PopupWidth: Integer read FPopupWidth write SetPopupWidth default 250;
|
|
property OnCloseQuery: TdxPopupEditCloseQueryEvent read FOnCloseQuery write FOnCloseQuery;
|
|
property OnCloseUp: TdxPopupEditCloseUpEvent read FOnCloseUp write FOnCloseUp;
|
|
property OnInitPopup: TNotifyEvent read FOnInitPopup write FOnInitPopup;
|
|
property OnPopup: TdxPopupEditPopupEvent read FOnPopup write FOnPopup;
|
|
end;
|
|
|
|
{ TdxInspectorTextPopupRow }
|
|
|
|
TdxInspectorTextPopupRow = class(TdxInspectorPopupRow)
|
|
private
|
|
FText: string;
|
|
procedure SetText(const Value: string);
|
|
protected
|
|
function GetDisplayText: string; override;
|
|
function GetEditText: string; override;
|
|
procedure SetEditText(const Value: string); override;
|
|
published
|
|
property Text: string read FText write SetText;
|
|
end;
|
|
|
|
{ TdxInspectorMemoRow }
|
|
|
|
TdxInspectorMemoEdit = class(TdxInplaceMemoEdit)
|
|
end;
|
|
|
|
TdxInspectorMemoRow = class(TdxInspectorRow)
|
|
private
|
|
FHideScrollBars: Boolean;
|
|
FScrollBars: TScrollStyle;
|
|
FSelectionBar: Boolean;
|
|
FWantReturns: Boolean;
|
|
FWantTabs: Boolean;
|
|
FWordWrap: Boolean;
|
|
procedure SetSelectionBar(Value: Boolean);
|
|
protected
|
|
function GetdxInplaceEditClass: TdxInplaceEditClass; override;
|
|
function GetMemoText: string; virtual;
|
|
procedure InitEditProperties(AInplaceEdit: TdxInplaceEdit); override;
|
|
procedure PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData); override;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
published
|
|
property HideScrollBars: Boolean read FHideScrollBars write FHideScrollBars default True;
|
|
property ScrollBars: TScrollStyle read FScrollBars write FScrollBars default ssNone;
|
|
property SelectionBar: Boolean read FSelectionBar write SetSelectionBar default False;
|
|
property WantReturns: Boolean read FWantReturns write FWantReturns default True;
|
|
property WantTabs: Boolean read FWantTabs write FWantTabs default False;
|
|
property WordWrap: Boolean read FWordWrap write FWordWrap default True;
|
|
end;
|
|
|
|
{ TdxInspectorTextMemoRow }
|
|
|
|
TdxInspectorTextMemoRow = class(TdxInspectorMemoRow)
|
|
private
|
|
FText: string;
|
|
procedure SetText(const Value: String);
|
|
protected
|
|
function GetDisplayText: string; override;
|
|
function GetEditText: string; override;
|
|
procedure SetEditText(const Value: string); override;
|
|
published
|
|
property Text: string read FText write SetText;
|
|
end;
|
|
|
|
{ TdxInspectorGraphicRow }
|
|
|
|
TdxInspectorGraphicEdit = class(TdxInplaceGraphicEdit)
|
|
public
|
|
property ClipboardFormat;
|
|
property Picture;
|
|
property ToolbarPos;
|
|
end;
|
|
|
|
TdxGraphicEditGetGraphicClassEvent = procedure(Sender: TObject; var GraphicClass: TGraphicClass) of object;
|
|
|
|
TdxInspectorGraphicRow = class(TdxInspectorRow)
|
|
private
|
|
FCenter: Boolean;
|
|
FClipboardFormat: Word;
|
|
FCustomFilter: string;
|
|
FCustomGraphic: Boolean;
|
|
FDblClickActivate: Boolean;
|
|
FGraphicTransparency: TdxGraphicEditTransparency;
|
|
FPicture: TPicture;
|
|
FPopupToolBar: TdxPopupToolBarWindow;
|
|
FPopupToolbarPos: TPoint;
|
|
FPopupToolbarPosStored: Boolean;
|
|
FQuickDraw: Boolean;
|
|
FStretch: Boolean;
|
|
FOnAssignPicture: TdxGraphicEditAssignPictureEvent;
|
|
FOnCustomClick: TNotifyEvent;
|
|
FOnGetGraphicClass: TdxGraphicEditGetGraphicClassEvent;
|
|
procedure LoadPictureFromText(APicture: TPicture);
|
|
procedure SetCenter(Value: Boolean);
|
|
procedure SetCustomGraphic(Value: Boolean);
|
|
procedure SetGraphicTransparency(Value: TdxGraphicEditTransparency);
|
|
procedure SetPopupToolBar(Value: TdxPopupToolBarWindow);
|
|
procedure SetPopupToolbarPosStored(Value: Boolean);
|
|
procedure SetQuickDraw(Value: Boolean);
|
|
procedure SetStretch(Value: Boolean);
|
|
protected
|
|
function AssignEditValue(AInplaceEdit: TdxInplaceEdit): Variant; override;
|
|
procedure DoAssignPicture(Sender: TObject; var Picture: TPicture); virtual;
|
|
procedure DoCustomClick(Sender: TObject); virtual;
|
|
procedure DoGetGraphicClass(Sender: TObject; var GraphicClass: TGraphicClass); virtual;
|
|
function GetdxInplaceEditClass: TdxInplaceEditClass; override;
|
|
function GetGraphicClass: TGraphicClass; virtual;
|
|
function GetGraphicValue: Variant; virtual;
|
|
procedure InitEditProperties(AInplaceEdit: TdxInplaceEdit); override;
|
|
function InitEditValue(AInplaceEdit: TdxInplaceEdit): Variant; override;
|
|
procedure PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData); override;
|
|
property Picture: TPicture read FPicture;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
property ClipboardFormat: Word read FClipboardFormat write FClipboardFormat;
|
|
property PopupToolbarPos: TPoint read FPopupToolbarPos write FPopupToolbarPos;
|
|
published
|
|
property Center: Boolean read FCenter write SetCenter default True;
|
|
property CustomFilter: string read FCustomFilter write FCustomFilter;
|
|
property CustomGraphic: Boolean read FCustomGraphic write SetCustomGraphic default False;
|
|
property DblClickActivate: Boolean read FDblClickActivate write FDblClickActivate default True;
|
|
property GraphicTransparency: TdxGraphicEditTransparency read FGraphicTransparency write SetGraphicTransparency default gtDefault;
|
|
property PopupToolBar: TdxPopupToolBarWindow read FPopupToolBar write SetPopupToolBar;
|
|
property PopupToolbarPosStored: Boolean read FPopupToolbarPosStored write SetPopupToolbarPosStored default True;
|
|
property QuickDraw: Boolean read FQuickDraw write SetQuickDraw default False;
|
|
property Stretch: Boolean read FStretch write SetStretch default True;
|
|
property OnAssignPicture: TdxGraphicEditAssignPictureEvent read FOnAssignPicture write FOnAssignPicture;
|
|
property OnCustomClick: TNotifyEvent read FOnCustomClick write FOnCustomClick;
|
|
property OnGetGraphicClass: TdxGraphicEditGetGraphicClassEvent read FOnGetGraphicClass write FOnGetGraphicClass;
|
|
end;
|
|
|
|
{ TdxInspectorTextGraphicRow }
|
|
|
|
TdxInspectorTextGraphicRow = class(TdxInspectorGraphicRow)
|
|
private
|
|
FText: string;
|
|
procedure SetText(const Value: String);
|
|
protected
|
|
function GetDisplayText: string; override;
|
|
function GetEditText: string; override;
|
|
procedure SetEditText(const Value: string); override;
|
|
published
|
|
property Text: string read FText write SetText;
|
|
end;
|
|
|
|
const
|
|
sdxInspCheckTextTrue: string = 'True';
|
|
sdxInspCheckTextFalse: string = 'False';
|
|
|
|
implementation
|
|
|
|
uses
|
|
Forms, Clipbrd;
|
|
|
|
{ TdxInspectorMaskRow }
|
|
|
|
procedure TdxInspectorMaskRow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorMaskRow then
|
|
begin
|
|
if Assigned(Inspector) then Inspector.BeginUpdate;
|
|
try
|
|
inherited Assign(Source);
|
|
EditMask := TdxInspectorMaskRow(Source).EditMask;
|
|
IgnoreMaskBlank := TdxInspectorMaskRow(Source).IgnoreMaskBlank;
|
|
finally
|
|
if Assigned(Inspector) then Inspector.EndUpdate;
|
|
end;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
function TdxInspectorMaskRow.DefaultEditMask: string;
|
|
begin
|
|
Result := '';
|
|
end;
|
|
|
|
procedure TdxInspectorMaskRow.RestoreDefaults;
|
|
begin
|
|
inherited RestoreDefaults;
|
|
EditMask := DefaultEditMask;
|
|
FIgnoreMaskBlank := False;
|
|
FAssignedEditMask := False;
|
|
end;
|
|
|
|
function TdxInspectorMaskRow.AssignEditValue(AInplaceEdit: TdxInplaceEdit): Variant;
|
|
begin
|
|
if AInplaceEdit is TdxInplaceMaskEdit then
|
|
begin
|
|
EditText := TdxInspectorMaskEdit(AInplaceEdit).Text;
|
|
Result := EditText;
|
|
end
|
|
else
|
|
Result := inherited AssignEditValue(AInplaceEdit);
|
|
end;
|
|
|
|
function TdxInspectorMaskRow.GetdxInplaceEditClass: TdxInplaceEditClass;
|
|
begin
|
|
Result := TdxInspectorMaskEdit;
|
|
end;
|
|
|
|
procedure TdxInspectorMaskRow.InitEditProperties(AInplaceEdit: TdxInplaceEdit);
|
|
begin
|
|
inherited InitEditProperties(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceMaskEdit then
|
|
with TdxInspectorMaskEdit(AInplaceEdit) do
|
|
begin
|
|
EditMask := Self.EditMask;
|
|
IgnoreMaskBlank := Self.IgnoreMaskBlank;
|
|
end;
|
|
end;
|
|
|
|
function TdxInspectorMaskRow.InitEditValue(AInplaceEdit: TdxInplaceEdit): Variant;
|
|
begin
|
|
TdxInspectorMaskEdit(AInplaceEdit).Text := EditText;
|
|
Result := TdxInspectorMaskEdit(AInplaceEdit).Text;
|
|
end;
|
|
|
|
function TdxInspectorMaskRow.GetEditMask: string;
|
|
begin
|
|
if FAssignedEditMask then
|
|
Result := FEditMask
|
|
else
|
|
Result := DefaultEditMask;
|
|
end;
|
|
|
|
function TdxInspectorMaskRow.IsEditMaskStored: Boolean;
|
|
begin
|
|
Result := FAssignedEditMask and (FEditMask <> DefaultEditMask);
|
|
end;
|
|
|
|
procedure TdxInspectorMaskRow.SetEditMask(const Value: string);
|
|
begin
|
|
if FEditMask <> Value then
|
|
begin
|
|
FEditMask := Value;
|
|
FAssignedEditMask := True;
|
|
end;
|
|
end;
|
|
|
|
{ TdxInspectorTextMaskRow }
|
|
|
|
function TdxInspectorTextMaskRow.GetDisplayText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
function TdxInspectorTextMaskRow.GetEditText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
procedure TdxInspectorTextMaskRow.SetEditText(const Value: string);
|
|
begin
|
|
if FText <> Value then
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorTextMaskRow.SetText(const Value: string);
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
|
|
{ TdxInspectorDropDownRow }
|
|
|
|
constructor TdxInspectorDropDownRow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FDropDownRows := 7;
|
|
end;
|
|
|
|
destructor TdxInspectorDropDownRow.Destroy;
|
|
begin
|
|
FButtonGlyph.Free;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TdxInspectorDropDownRow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorDropDownRow then
|
|
begin
|
|
if Assigned(Inspector) then Inspector.BeginUpdate;
|
|
try
|
|
inherited Assign(Source);
|
|
DropDownRows := TdxInspectorDropDownRow(Source).DropDownRows;
|
|
DropDownWidth := TdxInspectorDropDownRow(Source).DropDownWidth;
|
|
ImmediateDropDown := TdxInspectorDropDownRow(Source).ImmediateDropDown;
|
|
ImmediatePopup := TdxInspectorDropDownRow(Source).ImmediatePopup;
|
|
PopupAlignment := TdxInspectorDropDownRow(Source).PopupAlignment;
|
|
PopupBorder := TdxInspectorDropDownRow(Source).PopupBorder;
|
|
finally
|
|
if Assigned(Inspector) then Inspector.EndUpdate;
|
|
end;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
procedure TdxInspectorDropDownRow.RestoreDefaults;
|
|
begin
|
|
inherited RestoreDefaults;
|
|
FDropDownRows := 7;
|
|
FDropDownWidth := 0;
|
|
FImmediateDropDown := False;
|
|
FImmediatePopup := False;
|
|
FPopupAlignment := taLeftJustify;
|
|
FPopupBorder := pbDefault;
|
|
end;
|
|
|
|
procedure TdxInspectorDropDownRow.DoCloseUp(Sender: TObject; var Value: string; var Accept: Boolean);
|
|
begin
|
|
end;
|
|
|
|
procedure TdxInspectorDropDownRow.EditButtonClick(Sender: TObject);
|
|
begin
|
|
if Assigned(FOnEditButtonClick) then FOnEditButtonClick(Self);
|
|
end;
|
|
|
|
function TdxInspectorDropDownRow.GetdxInplaceEditClass: TdxInplaceEditClass;
|
|
begin
|
|
Result := TdxInspectorDropDownEdit;
|
|
end;
|
|
|
|
procedure TdxInspectorDropDownRow.InitEditProperties(AInplaceEdit: TdxInplaceEdit);
|
|
begin
|
|
inherited InitEditProperties(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceDropDownEdit then
|
|
with TdxInspectorDropDownEdit(AInplaceEdit) do
|
|
begin
|
|
ButtonGlyph := Self.FButtonGlyph;
|
|
ImmediateDropDown := Self.ImmediateDropDown;
|
|
DropDownRows := Self.DropDownRows;
|
|
DropDownWidth := Self.DropDownWidth;
|
|
ImmediateDropDown := Self.ImmediateDropDown;
|
|
ImmediatePopup := Self.ImmediatePopup;
|
|
PopupAlignment := Self.PopupAlignment;
|
|
PopupBorder := Self.PopupBorder;
|
|
OnCloseUp := Self.DoCloseUp;
|
|
OnEditButtonClick := Self.EditButtonClick;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorDropDownRow.PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData);
|
|
begin
|
|
inherited PrepareViewData(AViewData, ACellViewData);
|
|
if AViewData is TdxDropDownEditViewData then
|
|
with TdxDropDownEditViewData(AViewData) do
|
|
begin
|
|
ButtonGlyph := Self.FButtonGlyph;
|
|
HideButtons := True;
|
|
ActiveButtonIndex := -1;
|
|
PressedButtonIndex := -1;
|
|
end;
|
|
end;
|
|
|
|
function TdxInspectorDropDownRow.GetButtonGlyph: TBitmap;
|
|
begin
|
|
if FButtonGlyph = nil then FButtonGlyph := TBitmap.Create;
|
|
Result := FButtonGlyph;
|
|
end;
|
|
|
|
procedure TdxInspectorDropDownRow.SetButtonGlyph(Value: TBitmap);
|
|
begin
|
|
if (Value = nil) or Value.Empty then
|
|
begin
|
|
FButtonGlyph.Free;
|
|
FButtonGlyph := nil;
|
|
end
|
|
else
|
|
ButtonGlyph.Assign(Value);
|
|
Changed;
|
|
end;
|
|
|
|
{ TdxInspectorDateRow }
|
|
|
|
constructor TdxInspectorDateRow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FDateButtons := [btnToday, btnClear];
|
|
FSaveTime := True;
|
|
end;
|
|
|
|
procedure TdxInspectorDateRow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorDateRow then
|
|
begin
|
|
if Assigned(Inspector) then Inspector.BeginUpdate;
|
|
try
|
|
inherited Assign(Source);
|
|
DateButtons := TdxInspectorDateRow(Source).DateButtons;
|
|
SaveTime := TdxInspectorDateRow(Source).SaveTime;
|
|
DateOnError := TdxInspectorDateRow(Source).DateOnError;
|
|
DateValidation := TdxInspectorDateRow(Source).DateValidation;
|
|
UseEditMask := TdxInspectorDateRow(Source).UseEditMask;
|
|
finally
|
|
if Assigned(Inspector) then Inspector.EndUpdate;
|
|
end;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
procedure TdxInspectorDateRow.RestoreDefaults;
|
|
begin
|
|
inherited RestoreDefaults;
|
|
FDateButtons := [btnToday, btnClear];
|
|
FDateOnError := deToday;
|
|
FSaveTime := True;
|
|
FDateValidation := False;
|
|
FUseEditMask := False;
|
|
end;
|
|
|
|
function TdxInspectorDateRow.GetdxInplaceEditClass: TdxInplaceEditClass;
|
|
begin
|
|
Result := TdxInspectorDateEdit;
|
|
end;
|
|
|
|
procedure TdxInspectorDateRow.DoValidateInput(Sender: TObject; const AText: string;
|
|
var ADate: TDateTime; var AMessage: string; var AError: Boolean);
|
|
begin
|
|
if Assigned(FOnDateValidateInput) then
|
|
FOnDateValidateInput(Self, AText, ADate, AMessage, AError);
|
|
end;
|
|
|
|
procedure TdxInspectorDateRow.InitEditProperties(AInplaceEdit: TdxInplaceEdit);
|
|
begin
|
|
inherited InitEditProperties(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceDateEdit then
|
|
with TdxInspectorDateEdit(AInplaceEdit) do
|
|
begin
|
|
DateButtons := Self.DateButtons;
|
|
if Self.IsRequired then
|
|
DateButtons := DateButtons - [btnClear];
|
|
DateOnError := Self.DateOnError;
|
|
DateValidation := Self.DateValidation;
|
|
SaveTime := Self.SaveTime;
|
|
UseEditMask := Self.UseEditMask;
|
|
OnDateValidateInput := Self.DoValidateInput;
|
|
end;
|
|
end;
|
|
|
|
function TdxInspectorDateRow.IsRequired: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
{ TdxInspectorTextDateRow }
|
|
function TdxInspectorTextDateRow.GetDisplayText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
function TdxInspectorTextDateRow.GetEditText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
procedure TdxInspectorTextDateRow.SetEditText(const Value: string);
|
|
begin
|
|
if FText <> Value then
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorTextDateRow.SetText(const Value: string);
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
|
|
{ TdxInspectorCheckRow }
|
|
|
|
constructor TdxInspectorCheckRow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FGlyphCount := 6;
|
|
FValueChecked := sdxInspCheckTextTrue;
|
|
FValueUnchecked := sdxInspCheckTextFalse;
|
|
end;
|
|
|
|
destructor TdxInspectorCheckRow.Destroy;
|
|
begin
|
|
FGlyph.Free;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TdxInspectorCheckRow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorCheckRow then
|
|
begin
|
|
if Assigned(Inspector) then Inspector.BeginUpdate;
|
|
try
|
|
inherited Assign(Source);
|
|
AllowGrayed := TdxInspectorCheckRow(Source).AllowGrayed;
|
|
Border3D := TdxInspectorCheckRow(Source).Border3D;
|
|
if TdxInspectorCheckRow(Source).FGlyph <> nil then
|
|
Glyph := TdxInspectorCheckRow(Source).Glyph;
|
|
GlyphCount := TdxInspectorCheckRow(Source).GlyphCount;
|
|
ShowNullFieldStyle := TdxInspectorCheckRow(Source).ShowNullFieldStyle;
|
|
ValueChecked := TdxInspectorCheckRow(Source).ValueChecked;
|
|
ValueGrayed := TdxInspectorCheckRow(Source).ValueGrayed;
|
|
ValueUnChecked := TdxInspectorCheckRow(Source).ValueUnChecked;
|
|
finally
|
|
if Assigned(Inspector) then Inspector.EndUpdate;
|
|
end;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
procedure TdxInspectorCheckRow.RestoreDefaults;
|
|
begin
|
|
inherited RestoreDefaults;
|
|
FAllowGrayed := False;
|
|
FBorder3D := False;
|
|
FGlyph.Free;
|
|
FGlyph := nil;
|
|
FGlyphCount := 6;
|
|
FShowNullFieldStyle := nsUnchecked;
|
|
FValueChecked := sdxInspCheckTextTrue;
|
|
FValueGrayed := '';
|
|
FValueUnchecked := sdxInspCheckTextFalse;
|
|
end;
|
|
|
|
function TdxInspectorCheckRow.GetCheckBoxState(const AText: string): TdxCheckBoxState;
|
|
begin
|
|
Result := cbsGrayed;
|
|
if AnsiCompareText(AText, FValueChecked) = 0 then
|
|
Result := cbsChecked
|
|
else
|
|
if AnsiCompareText(AText, FValueUnChecked) = 0 then
|
|
Result := cbsUnchecked;
|
|
end;
|
|
|
|
function TdxInspectorCheckRow.GetCheckBoxValue(AState: TdxCheckBoxState): string;
|
|
begin
|
|
case AState of
|
|
cbsChecked: Result := FValueChecked;
|
|
cbsUnchecked: Result := FValueUnChecked;
|
|
else
|
|
Result := FValueGrayed;
|
|
end;
|
|
end;
|
|
|
|
function TdxInspectorCheckRow.AssignEditValue(AInplaceEdit: TdxInplaceEdit): Variant;
|
|
begin
|
|
if AInplaceEdit is TdxInplaceCheckEdit then
|
|
EditText := GetCheckBoxValue(TdxInspectorCheckEdit(AInplaceEdit).State);
|
|
Result := EditText;
|
|
end;
|
|
|
|
procedure TdxInspectorCheckRow.DoChange(Sender: TObject);
|
|
var
|
|
AState: TdxCheckBoxState;
|
|
begin
|
|
inherited DoChange(Sender);
|
|
if (Inspector <> nil) and not Inspector.IsInitEdit then
|
|
if (Sender is TdxInplaceCheckEdit) and Assigned(FOnToggleClick) then
|
|
begin
|
|
AState := TdxInspectorCheckEdit(Sender).State;
|
|
FOnToggleClick(Self, GetCheckBoxValue(AState), AState);
|
|
end;
|
|
end;
|
|
|
|
function TdxInspectorCheckRow.GetdxInplaceEditClass: TdxInplaceEditClass;
|
|
begin
|
|
Result := TdxInspectorCheckEdit;
|
|
end;
|
|
|
|
function TdxInspectorCheckRow.GetMinRowHeight(ACanvas: TCanvas): Integer;
|
|
var
|
|
ACheckWidth, ACheckHeight: Integer;
|
|
begin
|
|
if (FGlyph <> nil) and TdxInplaceCheckEdit.CalcCheckSize(Glyph, GlyphCount, ACheckWidth, ACheckHeight) then
|
|
Result := ACheckHeight
|
|
else
|
|
Result := FCheckHeight + 2;
|
|
end;
|
|
|
|
procedure TdxInspectorCheckRow.InitEditProperties(AInplaceEdit: TdxInplaceEdit);
|
|
begin
|
|
inherited InitEditProperties(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceCheckEdit then
|
|
with TdxInspectorCheckEdit(AInplaceEdit) do
|
|
begin
|
|
Alignment := taCenter;
|
|
AllowGrayed := Self.AllowGrayed;
|
|
if Border3D then
|
|
Style.ButtonStyle := bts3D
|
|
else
|
|
Style.ButtonStyle := btsSimple;
|
|
Glyph := Self.Glyph;
|
|
GlyphCount := Self.GlyphCount;
|
|
NullStyle := Self.ShowNullFieldStyle;
|
|
end;
|
|
end;
|
|
|
|
function TdxInspectorCheckRow.InitEditValue(AInplaceEdit: TdxInplaceEdit): Variant;
|
|
begin
|
|
Result := inherited InitEditValue(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceCheckEdit then
|
|
with TdxInspectorCheckEdit(AInplaceEdit) do
|
|
State := GetCheckBoxState(Result);
|
|
end;
|
|
|
|
function TdxInspectorCheckRow.IsShowHint(IsValue: Boolean; const R: TRect; var AText: string): Boolean;
|
|
begin
|
|
if not IsValue then
|
|
Result := inherited IsShowHint(IsValue, R, AText)
|
|
else
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TdxInspectorCheckRow.PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData);
|
|
begin
|
|
inherited PrepareViewData(AViewData, ACellViewData);
|
|
if AViewData is TdxCheckEditViewData then
|
|
with TdxCheckEditViewData(AViewData) do
|
|
begin
|
|
Caption := '';
|
|
Data := GetCheckBoxState(Data);
|
|
Alignment := taCenter;
|
|
if Border3D then
|
|
ButtonStyle := bts3D
|
|
else
|
|
ButtonStyle := btsSimple;
|
|
Glyph := Self.Glyph;
|
|
GlyphCount := Self.GlyphCount;
|
|
NullStyle := Self.ShowNullFieldStyle;
|
|
end;
|
|
end;
|
|
|
|
function TdxInspectorCheckRow.GetGlyph: TBitmap;
|
|
begin
|
|
if FGlyph = nil then
|
|
FGlyph := TBitmap.Create;
|
|
Result := FGlyph;
|
|
end;
|
|
|
|
procedure TdxInspectorCheckRow.SetBorder3D(Value: Boolean);
|
|
begin
|
|
if Border3D <> Value then
|
|
begin
|
|
FBorder3D := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorCheckRow.SetGlyph(Value: TBitmap);
|
|
begin
|
|
if Value = nil then
|
|
begin
|
|
FGlyph.Free;
|
|
FGlyph := nil;
|
|
end
|
|
else
|
|
Glyph.Assign(Value);
|
|
Changed;
|
|
end;
|
|
|
|
procedure TdxInspectorCheckRow.SetGlyphCount(Value: Integer);
|
|
begin
|
|
if FGlyphCount <> Value then
|
|
begin
|
|
FGlyphCount := Value;
|
|
if FGlyph <> nil then
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorCheckRow.SetShowNullFieldStyle(Value: TdxShowNullFieldStyle);
|
|
begin
|
|
if ShowNullFieldStyle <> Value then
|
|
begin
|
|
FShowNullFieldStyle := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorCheckRow.SetValueChecked(const Value: String);
|
|
begin
|
|
if FValueChecked <> Value then
|
|
begin
|
|
FValueChecked := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorCheckRow.SetValueGrayed(const Value: string);
|
|
begin
|
|
if FValueGrayed <> Value then
|
|
begin
|
|
FValueGrayed := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorCheckRow.SetValueUnchecked(const Value: string);
|
|
begin
|
|
if FValueUnchecked <> Value then
|
|
begin
|
|
FValueUnchecked := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
{ TdxInspectorTextCheckRow }
|
|
function TdxInspectorTextCheckRow.GetDisplayText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
function TdxInspectorTextCheckRow.GetEditText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
procedure TdxInspectorTextCheckRow.SetEditText(const Value: string);
|
|
begin
|
|
if FText <> Value then
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorTextCheckRow.SetText(const Value: string);
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
|
|
{ TdxInspectorCalcRow }
|
|
|
|
constructor TdxInspectorCalcRow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FBeepOnError := True;
|
|
FButtonStyle := bsStandard;
|
|
FPrecision := dxDefCalcPrecision;
|
|
end;
|
|
|
|
procedure TdxInspectorCalcRow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorCalcRow then
|
|
begin
|
|
inherited Assign(Source);
|
|
BeepOnError := TdxInspectorCalcRow(Source).BeepOnError;
|
|
ButtonStyle := TdxInspectorCalcRow(Source).ButtonStyle;
|
|
Precision := TdxInspectorCalcRow(Source).Precision;
|
|
QuickClose := TdxInspectorCalcRow(Source).QuickClose;
|
|
ShowButtonFrame := TdxInspectorCalcRow(Source).ShowButtonFrame;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
procedure TdxInspectorCalcRow.RestoreDefaults;
|
|
begin
|
|
inherited RestoreDefaults;
|
|
FBeepOnError := True;
|
|
FButtonStyle := bsStandard;
|
|
FPrecision := dxDefCalcPrecision;
|
|
FQuickClose := False;
|
|
FShowButtonFrame := False;
|
|
end;
|
|
|
|
function TdxInspectorCalcRow.GetdxInplaceEditClass: TdxInplaceEditClass;
|
|
begin
|
|
Result := TdxInspectorCalcEdit;
|
|
end;
|
|
|
|
procedure TdxInspectorCalcRow.InitEditProperties(AInplaceEdit: TdxInplaceEdit);
|
|
begin
|
|
inherited InitEditProperties(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceCalcEdit then
|
|
with TdxInspectorCalcEdit(AInplaceEdit) do
|
|
begin
|
|
BeepOnError := Self.BeepOnError;
|
|
ButtonStyle := Self.ButtonStyle;
|
|
Precision := Self.Precision;
|
|
QuickClose := Self.QuickClose;
|
|
ShowButtonFrame := Self.ShowButtonFrame;
|
|
end;
|
|
end;
|
|
|
|
{ TdxInspectorTextCalcRow }
|
|
function TdxInspectorTextCalcRow.GetDisplayText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
function TdxInspectorTextCalcRow.GetEditText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
procedure TdxInspectorTextCalcRow.SetEditText(const Value: string);
|
|
begin
|
|
if FText <> Value then
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorTextCalcRow.SetText(const Value: string);
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
|
|
{ TdxInspectorButtonRow }
|
|
|
|
type
|
|
TdxRowEditButtons = class(TdxEditButtons)
|
|
procedure Update(Item: TCollectionItem); override;
|
|
end;
|
|
|
|
procedure TdxRowEditButtons.Update(Item: TCollectionItem);
|
|
begin
|
|
inherited Update(Item);
|
|
if Owner is TdxInspectorButtonRow then
|
|
(Owner as TdxInspectorButtonRow).Changed;
|
|
end;
|
|
|
|
constructor TdxInspectorButtonRow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FButtons := TdxRowEditButtons.Create(Self, TdxEditButton);
|
|
FButtons.Add;
|
|
FEditButtonStyle := ebsEllipsis;
|
|
FClickKey := VK_RETURN + scCtrl;
|
|
FGlyph := TBitmap.Create;
|
|
end;
|
|
|
|
destructor TdxInspectorButtonRow.Destroy;
|
|
begin
|
|
FButtons.Free;
|
|
FGlyph.Free;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TdxInspectorButtonRow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorButtonRow then
|
|
begin
|
|
inherited Assign(Source);
|
|
ButtonOnly := TdxInspectorButtonRow(Source).ButtonOnly;
|
|
Buttons := TdxInspectorButtonRow(Source).Buttons;
|
|
EditButtonStyle := TdxInspectorButtonRow(Source).EditButtonStyle;
|
|
ClickKey := TdxInspectorButtonRow(Source).ClickKey;
|
|
Glyph := TdxInspectorButtonRow(Source).Glyph;
|
|
HideEditCursor := TdxInspectorButtonRow(Source).HideEditCursor;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
procedure TdxInspectorButtonRow.RestoreDefaults;
|
|
begin
|
|
inherited RestoreDefaults;
|
|
FButtonOnly := False;
|
|
Buttons.RestoreDefaults;
|
|
Buttons.Clear;
|
|
Buttons.Add;
|
|
FEditButtonStyle := ebsEllipsis;
|
|
FClickKey := VK_RETURN + scCtrl;
|
|
FGlyph.ReleaseHandle;
|
|
FGlyph.Width := 0;
|
|
FGlyph.Height := 0;
|
|
FHideEditCursor := False;
|
|
end;
|
|
|
|
procedure TdxInspectorButtonRow.DoButtonClick(Sender: TObject; AbsoluteIndex: Integer);
|
|
begin
|
|
if Assigned(FOnButtonClick) then FOnButtonClick(Self, AbsoluteIndex);
|
|
end;
|
|
|
|
function TdxInspectorButtonRow.GetdxInplaceEditClass: TdxInplaceEditClass;
|
|
begin
|
|
Result := TdxInspectorButtonEdit;
|
|
end;
|
|
|
|
procedure TdxInspectorButtonRow.InitEditProperties(AInplaceEdit: TdxInplaceEdit);
|
|
begin
|
|
inherited InitEditProperties(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceButtonEdit then
|
|
with TdxInspectorButtonEdit(AInplaceEdit) do
|
|
begin
|
|
Buttons := Self.Buttons;
|
|
ClickKey := Self.ClickKey;
|
|
if ButtonOnly then
|
|
ViewStyle := vsButtonOnly
|
|
else
|
|
if HideEditCursor then
|
|
ViewStyle := vsHideCursor
|
|
else ViewStyle := vsStandard;
|
|
OnButtonClick := Self.DoButtonClick;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorButtonRow.PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData);
|
|
begin
|
|
inherited PrepareViewData(AViewData, ACellViewData);
|
|
if AViewData is TdxButtonEditViewData then
|
|
with TdxButtonEditViewData(AViewData) do
|
|
begin
|
|
if not HideButtons then
|
|
begin
|
|
ButtonOnly := Self.ButtonOnly;
|
|
EditButtons := Self.Buttons;
|
|
end
|
|
else
|
|
begin
|
|
ButtonOnly := False;
|
|
EditButtons := nil;
|
|
end;
|
|
HideEditCursor := Self.HideEditCursor;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorButtonRow.SetButtonOnly(Value: Boolean);
|
|
begin
|
|
if FButtonOnly <> Value then
|
|
begin
|
|
FButtonOnly := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorButtonRow.SetButtons(Value: TdxEditButtons);
|
|
begin
|
|
Buttons.Assign(Value);
|
|
end;
|
|
|
|
procedure TdxInspectorButtonRow.SetEditButtonStyle(Value: TdxEditButtonStyle);
|
|
const
|
|
BStyle: array [ebsEllipsis..ebsGlyph] of TdxEditButtonKind = (bkEllipsis, bkDown, bkGlyph);
|
|
begin
|
|
if FEditButtonStyle <> Value then
|
|
begin
|
|
FEditButtonStyle := Value;
|
|
if FEditButtonStyle = ebsSimple then
|
|
Buttons.Clear
|
|
else
|
|
begin
|
|
if Buttons.Count = 0 then Buttons.Add;
|
|
Buttons[0].Kind := BStyle[FEditButtonStyle];
|
|
end;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorButtonRow.SetGlyph(Value: TBitmap);
|
|
begin
|
|
FGlyph.Assign(Value);
|
|
if Buttons.Count > 0 then
|
|
Buttons[0].Glyph.Assign(FGlyph);
|
|
end;
|
|
|
|
procedure TdxInspectorButtonRow.SetHideEditCursor(Value: Boolean);
|
|
begin
|
|
if FHideEditCursor <> Value then
|
|
begin
|
|
FHideEditCursor := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
{ TdxInspectorTextButtonRow }
|
|
function TdxInspectorTextButtonRow.GetDisplayText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
function TdxInspectorTextButtonRow.GetEditText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
procedure TdxInspectorTextButtonRow.SetEditText(const Value: string);
|
|
begin
|
|
if FText <> Value then
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorTextButtonRow.SetText(const Value: string);
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
|
|
{ TdxInspectorSpinRow }
|
|
|
|
constructor TdxInspectorSpinRow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FEditorEnabled := True;
|
|
FIncrement := 1.0;
|
|
FUseCtrlIncrement := True;
|
|
end;
|
|
|
|
procedure TdxInspectorSpinRow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorSpinRow then
|
|
begin
|
|
inherited Assign(Source);
|
|
EditorEnabled := TdxInspectorSpinRow(Source).EditorEnabled;
|
|
Increment := TdxInspectorSpinRow(Source).Increment;
|
|
MinValue := TdxInspectorSpinRow(Source).MinValue;
|
|
MaxValue := TdxInspectorSpinRow(Source).MaxValue;
|
|
UseCtrlIncrement := TdxInspectorSpinRow(Source).UseCtrlIncrement;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
function TdxInspectorSpinRow.DefaultMinValue: Double;
|
|
begin
|
|
Result := 0.0;
|
|
end;
|
|
|
|
function TdxInspectorSpinRow.DefaultMaxValue: Double;
|
|
begin
|
|
Result := 0.0;
|
|
end;
|
|
|
|
procedure TdxInspectorSpinRow.RestoreDefaults;
|
|
begin
|
|
inherited RestoreDefaults;
|
|
FAssignedValues := [];
|
|
FEditorEnabled := True;
|
|
FIncrement := 1.0;
|
|
FMinValue := 0.0;
|
|
FMaxValue := 0.0;
|
|
FUseCtrlIncrement := True;
|
|
end;
|
|
|
|
// protected TdxInspectorSpinRow
|
|
function TdxInspectorSpinRow.AssignEditValue(AInplaceEdit: TdxInplaceEdit): Variant;
|
|
begin
|
|
if AInplaceEdit is TdxInplaceSpinEdit then
|
|
with TdxInspectorSpinEdit(AInplaceEdit) do
|
|
if ValueType = vtFloat then
|
|
Self.EditText := FloatToStrF(Value, ffGeneral, 15, 0)
|
|
else
|
|
Self.EditText := IntToStr(Round(Value));
|
|
Result := EditText;
|
|
end;
|
|
|
|
function TdxInspectorSpinRow.GetdxInplaceEditClass: TdxInplaceEditClass;
|
|
begin
|
|
Result := TdxInspectorSpinEdit;
|
|
end;
|
|
|
|
function TdxInspectorSpinRow.GetValueType: TdxValueType;
|
|
begin
|
|
Result := vtInt;
|
|
end;
|
|
|
|
procedure TdxInspectorSpinRow.InitEditProperties(AInplaceEdit: TdxInplaceEdit);
|
|
begin
|
|
inherited InitEditProperties(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceSpinEdit then
|
|
with TdxInspectorSpinEdit(AInplaceEdit) do
|
|
begin
|
|
EditorEnabled := Self.EditorEnabled;
|
|
Increment := Self.Increment;
|
|
// MinValue := Self.MinValue;
|
|
// MaxValue := Self.MaxValue;
|
|
SetMinMaxValues(Self.MinValue, Self.MaxValue);
|
|
UseCtrlIncrement := Self.UseCtrlIncrement;
|
|
ValueType := Self.ValueType;
|
|
end;
|
|
end;
|
|
|
|
function TdxInspectorSpinRow.InitEditValue(AInplaceEdit: TdxInplaceEdit): Variant;
|
|
begin
|
|
Result := inherited InitEditValue(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceSpinEdit then
|
|
with TdxInspectorSpinEdit(AInplaceEdit) do
|
|
try
|
|
if Result <> '' then
|
|
Value := StrToFloat(Result)
|
|
else
|
|
Value := 0;
|
|
Result := Value;
|
|
except
|
|
on EConvertError do
|
|
Value := 0;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorSpinRow.PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData);
|
|
begin
|
|
inherited PrepareViewData(AViewData, ACellViewData);
|
|
if AViewData is TdxSpinEditViewData then
|
|
with TdxSpinEditViewData(AViewData) do
|
|
begin
|
|
ShowButton := False; // TODO
|
|
end;
|
|
end;
|
|
|
|
function TdxInspectorSpinRow.IsIncrementStored: Boolean;
|
|
begin
|
|
Result := FIncrement <> 1.0;
|
|
end;
|
|
|
|
function TdxInspectorSpinRow.IsMaxStored: Boolean;
|
|
begin
|
|
Result := (srMaxValue in FAssignedValues) and (MaxValue <> DefaultMaxValue);
|
|
end;
|
|
|
|
function TdxInspectorSpinRow.IsMinStored: Boolean;
|
|
begin
|
|
Result := (srMinValue in FAssignedValues) and (MinValue <> DefaultMinValue);
|
|
end;
|
|
|
|
function TdxInspectorSpinRow.GetMinValue: Double;
|
|
begin
|
|
if srMinValue in FAssignedValues then
|
|
Result := FMinValue
|
|
else
|
|
Result := DefaultMinValue;
|
|
end;
|
|
|
|
function TdxInspectorSpinRow.GetMaxValue: Double;
|
|
begin
|
|
if srMaxValue in FAssignedValues then
|
|
Result := FMaxValue
|
|
else
|
|
Result := DefaultMaxValue;
|
|
end;
|
|
|
|
procedure TdxInspectorSpinRow.SetMinValue(Value: Double);
|
|
begin
|
|
if (srMinValue in FAssignedValues) and (Value = FMinValue) then Exit;
|
|
FMinValue := Value;
|
|
Include(FAssignedValues, srMinValue);
|
|
end;
|
|
|
|
procedure TdxInspectorSpinRow.SetMaxValue(Value: Double);
|
|
begin
|
|
if (srMaxValue in FAssignedValues) and (Value = FMaxValue) then Exit;
|
|
FMaxValue := Value;
|
|
Include(FAssignedValues, srMaxValue);
|
|
end;
|
|
|
|
{ TdxInspectorTextSpinRow }
|
|
procedure TdxInspectorTextSpinRow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorTextSpinRow then
|
|
begin
|
|
inherited Assign(Source);
|
|
ValueType := TdxInspectorTextSpinRow(Source).ValueType;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
procedure TdxInspectorTextSpinRow.RestoreDefaults;
|
|
begin
|
|
inherited RestoreDefaults;
|
|
FValueType := vtInt;
|
|
end;
|
|
|
|
function TdxInspectorTextSpinRow.GetDisplayText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
function TdxInspectorTextSpinRow.GetEditText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
function TdxInspectorTextSpinRow.GetValueType: TdxValueType;
|
|
begin
|
|
Result := FValueType;
|
|
end;
|
|
|
|
procedure TdxInspectorTextSpinRow.SetEditText(const Value: string);
|
|
begin
|
|
if FText <> Value then
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorTextSpinRow.SetText(const Value: string);
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
|
|
{ TdxInspectorPickRow }
|
|
|
|
constructor TdxInspectorPickRow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FItems := TStringList.Create;
|
|
ImmediateDropDown := True;
|
|
FRevertable := True;
|
|
end;
|
|
|
|
destructor TdxInspectorPickRow.Destroy;
|
|
begin
|
|
FItems.Free;
|
|
FItems := nil;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TdxInspectorPickRow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorPickRow then
|
|
begin
|
|
inherited Assign(Source);
|
|
DropDownListStyle := TdxInspectorPickRow(Source).DropDownListStyle;
|
|
Items.Assign(TdxInspectorPickRow(Source).Items);
|
|
CanDeleteText := TdxInspectorPickRow(Source).CanDeleteText;
|
|
Revertable := TdxInspectorPickRow(Source).Revertable;
|
|
Sorted := TdxInspectorPickRow(Source).Sorted;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
procedure TdxInspectorPickRow.RestoreDefaults;
|
|
begin
|
|
inherited RestoreDefaults;
|
|
FDropDownListStyle := False;
|
|
ImmediateDropDown := True;
|
|
FCanDeleteText := False;
|
|
FRevertable := True;
|
|
FSorted := False;
|
|
end;
|
|
|
|
procedure TdxInspectorPickRow.DoCloseUp(Sender: TObject; var Value: string; var Accept: Boolean);
|
|
var
|
|
V: Variant;
|
|
begin
|
|
V := Value;
|
|
if Assigned(FOnCloseUp) then FOnCloseUp(Self, V, Accept);
|
|
Value := V;
|
|
end;
|
|
|
|
function TdxInspectorPickRow.GetdxInplaceEditClass: TdxInplaceEditClass;
|
|
begin
|
|
Result := TdxInspectorPickEdit;
|
|
end;
|
|
|
|
procedure TdxInspectorPickRow.InitEditProperties(AInplaceEdit: TdxInplaceEdit);
|
|
begin
|
|
inherited InitEditProperties(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplacePickEdit then
|
|
with TdxInspectorPickEdit(AInplaceEdit) do
|
|
begin
|
|
DropDownListStyle := Self.DropDownListStyle;
|
|
Items := Self.Items;
|
|
CanDeleteText := Self.CanDeleteText;
|
|
Revertable := Self.Revertable;
|
|
Sorted := Self.Sorted;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorPickRow.SetItems(Value: TStrings);
|
|
begin
|
|
FItems.Assign(Value);
|
|
Changed;
|
|
end;
|
|
|
|
{ TdxInspectorTextPickRow }
|
|
function TdxInspectorTextPickRow.GetDisplayText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
function TdxInspectorTextPickRow.GetEditText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
procedure TdxInspectorTextPickRow.SetEditText(const Value: string);
|
|
begin
|
|
if FText <> Value then
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorTextPickRow.SetText(const Value: string);
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
|
|
{ TdxInspectorImageRow }
|
|
|
|
constructor TdxInspectorImageRow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
Alignment := taLeftJustify;
|
|
FDefaultImages := True;
|
|
FDescriptions := TStringList.Create;
|
|
FImageChangeLink := TChangeLink.Create;
|
|
FImageChangeLink.OnChange := ImageListChange;
|
|
FImageIndexes := TStringList.Create;
|
|
FLargeImageChangeLink := TChangeLink.Create;
|
|
FLargeImageChangeLink.OnChange := ImageListChange;
|
|
FValues := TStringList.Create;
|
|
end;
|
|
|
|
destructor TdxInspectorImageRow.Destroy;
|
|
begin
|
|
FDescriptions.Free;
|
|
FDescriptions := nil;
|
|
FValues.Free;
|
|
FValues := nil;
|
|
FImageIndexes.Free;
|
|
FImageIndexes := nil;
|
|
FImageChangeLink.Free;
|
|
FLargeImageChangeLink.Free;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TdxInspectorImageRow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorImageRow then
|
|
begin
|
|
if Assigned(Inspector) then Inspector.BeginUpdate;
|
|
try
|
|
inherited Assign(Source);
|
|
DefaultImages := TdxInspectorImageRow(Source).DefaultImages;
|
|
Descriptions.Assign(TdxInspectorImageRow(Source).Descriptions);
|
|
Images := TdxInspectorImageRow(Source).Images;
|
|
ImageIndexes.Assign(TdxInspectorImageRow(Source).ImageIndexes);
|
|
LargeImages := TdxInspectorImageRow(Source).LargeImages;
|
|
MultiLineText := TdxInspectorImageRow(Source).MultiLineText;
|
|
ShowDescription := TdxInspectorImageRow(Source).ShowDescription;
|
|
Values.Assign(TdxInspectorImageRow(Source).Values);
|
|
finally
|
|
if Assigned(Inspector) then Inspector.EndUpdate;
|
|
end;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
function TdxInspectorImageRow.GetImageIndex(const AText: string): Integer;
|
|
var
|
|
ATempIndex: Integer;
|
|
begin
|
|
TdxInplaceImageEdit.CalcViewIndexes(AText,
|
|
ImageIndexes, Descriptions, Values, DefaultImages,
|
|
Result, ATempIndex);
|
|
end;
|
|
|
|
procedure TdxInspectorImageRow.GetIndexes(const AText: string; var AImageIndex, ADescIndex: Integer);
|
|
begin
|
|
TdxInplaceImageEdit.CalcViewIndexes(AText,
|
|
ImageIndexes, Descriptions, Values, DefaultImages,
|
|
AImageIndex, ADescIndex);
|
|
end;
|
|
|
|
procedure TdxInspectorImageRow.RestoreDefaults;
|
|
begin
|
|
inherited RestoreDefaults;
|
|
FDefaultImages := True;
|
|
FMultiLineText := False;
|
|
FShowDescription := False;
|
|
end;
|
|
|
|
//protected TdxInspectorImageRow
|
|
procedure TdxInspectorImageRow.Notification(AComponent: TComponent; Operation: TOperation);
|
|
begin
|
|
inherited Notification(AComponent, Operation);
|
|
if Operation = opRemove then
|
|
begin
|
|
if AComponent = Images then Images := nil;
|
|
if AComponent = LargeImages then LargeImages := nil;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorImageRow.DoCloseUp(Sender: TObject; var Value: string; var Accept: Boolean);
|
|
begin
|
|
if Assigned(FOnCloseUp) then FOnCloseUp(Self, Value, Accept);
|
|
end;
|
|
|
|
function TdxInspectorImageRow.GetdxInplaceEditClass: TdxInplaceEditClass;
|
|
begin
|
|
Result := TdxInspectorImageEdit;
|
|
end;
|
|
|
|
function TdxInspectorImageRow.GetMinRowHeight(ACanvas: TCanvas): Integer;
|
|
begin
|
|
Result := inherited GetMinRowHeight(ACanvas);
|
|
if (Images <> nil) and (Images.Height > Result) then
|
|
Result := Images.Height;
|
|
end;
|
|
|
|
procedure TdxInspectorImageRow.InitEditProperties(AInplaceEdit: TdxInplaceEdit);
|
|
begin
|
|
inherited InitEditProperties(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceImageEdit then
|
|
with TdxInspectorImageEdit(AInplaceEdit) do
|
|
begin
|
|
DefaultImages := Self.DefaultImages;
|
|
Descriptions := Self.Descriptions;
|
|
Images := Self.Images;
|
|
ImageIndexes := Self.ImageIndexes;
|
|
LargeImages := Self.LargeImages;
|
|
MultiLineText := Self.MultiLineText;
|
|
ShowDescription := Self.ShowDescription;
|
|
Values := Self.Values;
|
|
end;
|
|
end;
|
|
|
|
type TWinControlCracker = class(TWinControl);
|
|
|
|
function TdxInspectorImageRow.IsShowHint(IsValue: Boolean; const R: TRect; var AText: string): Boolean;
|
|
var
|
|
I1, I2, W: Integer;
|
|
begin
|
|
if not IsValue then
|
|
Result := inherited IsShowHint(IsValue, R, AText)
|
|
else
|
|
begin
|
|
Result := False;
|
|
if (Inspector <> nil) and Inspector.HandleAllocated then
|
|
begin
|
|
GetIndexes(EditText, I1, I2);
|
|
if (0 <= I2) and (I2 < FDescriptions.Count) then
|
|
begin
|
|
AText := FDescriptions[I2];
|
|
if AText <> '' then
|
|
begin
|
|
Inspector.Canvas.Font.Assign(TWinControlCracker(Inspector).Font);
|
|
W := Inspector.Canvas.TextWidth(AText);
|
|
if (Images <> nil) then Inc(W, Images.Width);
|
|
Result := W > (R.Right - R.Left);
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorImageRow.PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData);
|
|
begin
|
|
inherited PrepareViewData(AViewData, ACellViewData);
|
|
if AViewData is TdxImageEditViewData then
|
|
with TdxImageEditViewData(AViewData) do
|
|
begin
|
|
if Self.MultilineText then
|
|
DrawAlignment := daMultiLine;
|
|
DefaultImages := Self.DefaultImages;
|
|
Descriptions := Self.Descriptions;
|
|
ImageIndexes := Self.ImageIndexes;
|
|
Images := Self.Images;
|
|
ShowDescription := Self.ShowDescription;
|
|
Values := Self.Values;
|
|
end;
|
|
end;
|
|
|
|
function TdxInspectorImageRow.GetListWidth: Integer;
|
|
begin
|
|
Result := DropDownWidth;
|
|
end;
|
|
|
|
procedure TdxInspectorImageRow.ImageListChange(Sender: TObject);
|
|
begin
|
|
if (Sender = Images) then Changed;
|
|
end;
|
|
|
|
procedure TdxInspectorImageRow.SetImages(Value: TImageList);
|
|
begin
|
|
if Images <> nil then
|
|
Images.UnRegisterChanges(FImageChangeLink);
|
|
FImages := Value;
|
|
if Value <> nil then
|
|
begin
|
|
Images.RegisterChanges(FImageChangeLink);
|
|
Value.FreeNotification(Self);
|
|
end;
|
|
Changed;
|
|
end;
|
|
|
|
procedure TdxInspectorImageRow.SetLargeImages(Value: TImageList);
|
|
begin
|
|
if LargeImages <> nil then
|
|
LargeImages.UnRegisterChanges(FLargeImageChangeLink);
|
|
FLargeImages := Value;
|
|
if Value <> nil then
|
|
begin
|
|
LargeImages.RegisterChanges(FLargeImageChangeLink);
|
|
Value.FreeNotification(Self);
|
|
end;
|
|
Changed;
|
|
end;
|
|
|
|
procedure TdxInspectorImageRow.SetImageIndexes(Value: TStrings);
|
|
begin
|
|
FImageIndexes.Assign(Value);
|
|
Changed;
|
|
end;
|
|
|
|
procedure TdxInspectorImageRow.SetValues(Value: TStrings);
|
|
begin
|
|
FValues.Assign(Value);
|
|
Changed;
|
|
end;
|
|
|
|
procedure TdxInspectorImageRow.SetDescriptions(Value: TStrings);
|
|
begin
|
|
FDescriptions.Assign(Value);
|
|
Changed;
|
|
end;
|
|
|
|
procedure TdxInspectorImageRow.SetShowDescription(Value: Boolean);
|
|
begin
|
|
if ShowDescription <> Value then
|
|
begin
|
|
FShowDescription := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorImageRow.SetDefaultImages(Value: Boolean);
|
|
begin
|
|
if DefaultImages <> Value then
|
|
begin
|
|
FDefaultImages := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorImageRow.SetListWidth(Value: Integer);
|
|
begin
|
|
DropDownWidth := Value;
|
|
end;
|
|
|
|
procedure TdxInspectorImageRow.SetMultiLineText(Value: Boolean);
|
|
begin
|
|
if FMultiLineText <> Value then
|
|
begin
|
|
FMultiLineText := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
{ TdxInspectorTextImageRow }
|
|
function TdxInspectorTextImageRow.GetDisplayText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
function TdxInspectorTextImageRow.GetEditText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
procedure TdxInspectorTextImageRow.SetEditText(const Value: string);
|
|
begin
|
|
if FText <> Value then
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorTextImageRow.SetText(const Value: string);
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
|
|
{ TdxInspectorTimeRow }
|
|
|
|
constructor TdxInspectorTimeRow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FUseCtrlIncrement := True;
|
|
end;
|
|
|
|
procedure TdxInspectorTimeRow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorTimeRow then
|
|
begin
|
|
inherited Assign(Source);
|
|
TimeEditFormat := TdxInspectorTimeRow(Source).TimeEditFormat;
|
|
UseCtrlIncrement := TdxInspectorTimeRow(Source).UseCtrlIncrement;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
procedure TdxInspectorTimeRow.RestoreDefaults;
|
|
begin
|
|
inherited RestoreDefaults;
|
|
FTimeEditFormat := tfHourMinSec;
|
|
FUseCtrlIncrement := True;
|
|
end;
|
|
|
|
function TdxInspectorTimeRow.AssignEditValue(AInplaceEdit: TdxInplaceEdit): Variant;
|
|
begin
|
|
if AInplaceEdit is TdxInplaceTimeEdit then
|
|
with TdxInspectorTimeEdit(AInplaceEdit) do
|
|
if Time = 0 then
|
|
Self.EditText := ''
|
|
else
|
|
Self.EditText := EditText;
|
|
Result := EditText;
|
|
end;
|
|
|
|
function TdxInspectorTimeRow.GetdxInplaceEditClass: TdxInplaceEditClass;
|
|
begin
|
|
Result := TdxInspectorTimeEdit;
|
|
end;
|
|
|
|
procedure TdxInspectorTimeRow.InitEditProperties(AInplaceEdit: TdxInplaceEdit);
|
|
begin
|
|
inherited InitEditProperties(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceTimeEdit then
|
|
with TdxInspectorTimeEdit(AInplaceEdit) do
|
|
begin
|
|
TimeEditFormat := Self.TimeEditFormat;
|
|
UseCtrlIncrement := Self.UseCtrlIncrement;
|
|
end;
|
|
end;
|
|
|
|
{ TdxInspectorTextTimeRow }
|
|
function TdxInspectorTextTimeRow.GetDisplayText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
function TdxInspectorTextTimeRow.GetEditText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
procedure TdxInspectorTextTimeRow.SetEditText(const Value: string);
|
|
begin
|
|
if FText <> Value then
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorTextTimeRow.SetText(const Value: string);
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
|
|
{ TdxInspectorCurrencyRow }
|
|
|
|
constructor TdxInspectorCurrencyRow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FDecimalPlaces := 2;
|
|
FDisplayFormat := DefaultCurrencyDisplayFormat;
|
|
end;
|
|
|
|
procedure TdxInspectorCurrencyRow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorCurrencyRow then
|
|
begin
|
|
inherited Assign(Source);
|
|
DecimalPlaces := TdxInspectorCurrencyRow(Source).DecimalPlaces;
|
|
DisplayFormat := TdxInspectorCurrencyRow(Source).DisplayFormat;
|
|
MinValue := TdxInspectorCurrencyRow(Source).MinValue;
|
|
MaxValue := TdxInspectorCurrencyRow(Source).MaxValue;
|
|
Nullable := TdxInspectorCurrencyRow(Source).Nullable;
|
|
NullString := TdxInspectorCurrencyRow(Source).NullString;
|
|
UseThousandSeparator := TdxInspectorCurrencyRow(Source).UseThousandSeparator;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
function TdxInspectorCurrencyRow.DefaultMinValue: Double;
|
|
begin
|
|
Result := 0.0;
|
|
end;
|
|
|
|
function TdxInspectorCurrencyRow.DefaultMaxValue: Double;
|
|
begin
|
|
Result := 0.0;
|
|
end;
|
|
|
|
procedure TdxInspectorCurrencyRow.RestoreDefaults;
|
|
begin
|
|
inherited RestoreDefaults;
|
|
FAssignedValues := [];
|
|
FDecimalPlaces := 2;
|
|
FDisplayFormat := DefaultCurrencyDisplayFormat;
|
|
FDisplayFormatStored := False;
|
|
FMinValue := 0.0;
|
|
FMaxValue := 0.0;
|
|
FNullable := False;
|
|
FNullString := '';
|
|
FUseThousandSeparator := False;
|
|
end;
|
|
|
|
function TdxInspectorCurrencyRow.AssignEditValue(AInplaceEdit: TdxInplaceEdit): Variant;
|
|
var
|
|
V: Variant;
|
|
begin
|
|
if AInplaceEdit is TdxInplaceCurrencyEdit then
|
|
with TdxInspectorCurrencyEdit(AInplaceEdit) do
|
|
begin
|
|
V := TdxInspectorCurrencyEdit(AInplaceEdit).ReturnEditValue;
|
|
if VarIsNull(V) then
|
|
Self.EditText := ''
|
|
else
|
|
if Value = 0 then
|
|
Self.EditText := '0'
|
|
else
|
|
Self.EditText := EditText;
|
|
end;
|
|
Result := EditText;
|
|
end;
|
|
|
|
function TdxInspectorCurrencyRow.GetDataValue: Variant;
|
|
begin
|
|
if EditText = '' then
|
|
Result := Null
|
|
else
|
|
Result := StrToFloat(EditText);
|
|
end;
|
|
|
|
function TdxInspectorCurrencyRow.GetdxInplaceEditClass: TdxInplaceEditClass;
|
|
begin
|
|
Result := TdxInspectorCurrencyEdit;
|
|
end;
|
|
|
|
procedure TdxInspectorCurrencyRow.InitEditProperties(AInplaceEdit: TdxInplaceEdit);
|
|
begin
|
|
inherited InitEditProperties(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceCurrencyEdit then
|
|
with TdxInspectorCurrencyEdit(AInplaceEdit) do
|
|
begin
|
|
DecimalPlaces := Self.DecimalPlaces;
|
|
DisplayFormat := ''; //Self.DisplayFormat;
|
|
// MinValue := Self.MinValue;
|
|
// MaxValue := Self.MaxValue;
|
|
SetMinMaxValues(Self.MinValue, Self.MaxValue);
|
|
Nullable := Self.Nullable;
|
|
NullString := Self.NullString;
|
|
UseThousandSeparator := Self.UseThousandSeparator;
|
|
end;
|
|
end;
|
|
|
|
function TdxInspectorCurrencyRow.InitEditValue(AInplaceEdit: TdxInplaceEdit): Variant;
|
|
begin
|
|
Result := inherited InitEditValue(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceCurrencyEdit then
|
|
with TdxInspectorCurrencyEdit(AInplaceEdit) do
|
|
try
|
|
Text := '';
|
|
if Result = '' then
|
|
begin
|
|
Value := 0;
|
|
if Nullable then
|
|
Text := '';
|
|
end
|
|
else
|
|
Value := StrToCurr(Result);
|
|
Result := Value;
|
|
// if Result = 0 then
|
|
// Text := '';
|
|
|
|
(* if Result <> '' then
|
|
Value := StrToCurr(Result)
|
|
else
|
|
Value := 0;
|
|
Result := Value;
|
|
if Result = 0 then
|
|
Text := '';*)
|
|
except
|
|
on EConvertError do
|
|
Value := 0;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorCurrencyRow.PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData);
|
|
var
|
|
V: Variant;
|
|
begin
|
|
inherited PrepareViewData(AViewData, ACellViewData);
|
|
if FDisplayFormat <> '' then
|
|
with TdxEditViewData(AViewData) do
|
|
begin
|
|
V := Self.GetDataValue;
|
|
try
|
|
if VarIsNull(V) or (VarType(V) = varString) then
|
|
begin
|
|
Data := VarToStr(V);
|
|
if (Data = '') and Nullable then
|
|
Data := NullString;
|
|
end
|
|
else
|
|
Data := FormatFloat(FDisplayFormat, V);
|
|
except
|
|
on EConvertError do;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TdxInspectorCurrencyRow.IsMaxStored: Boolean;
|
|
begin
|
|
Result := (srMaxValue in FAssignedValues) and (MaxValue <> DefaultMaxValue);
|
|
end;
|
|
|
|
function TdxInspectorCurrencyRow.IsMinStored: Boolean;
|
|
begin
|
|
Result := (srMinValue in FAssignedValues) and (MinValue <> DefaultMinValue);
|
|
end;
|
|
|
|
function TdxInspectorCurrencyRow.GetMinValue: Double;
|
|
begin
|
|
if srMinValue in FAssignedValues then
|
|
Result := FMinValue
|
|
else
|
|
Result := DefaultMinValue;
|
|
end;
|
|
|
|
function TdxInspectorCurrencyRow.GetMaxValue: Double;
|
|
begin
|
|
if srMaxValue in FAssignedValues then
|
|
Result := FMaxValue
|
|
else
|
|
Result := DefaultMaxValue;
|
|
end;
|
|
|
|
procedure TdxInspectorCurrencyRow.SetDisplayFormat(const Value: string);
|
|
begin
|
|
if FDisplayFormat <> Value then
|
|
begin
|
|
FDisplayFormat := Value;
|
|
FDisplayFormatStored := True;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorCurrencyRow.SetMinValue(Value: Double);
|
|
begin
|
|
if (srMinValue in FAssignedValues) and (Value = FMinValue) then Exit;
|
|
FMinValue := Value;
|
|
Include(FAssignedValues, srMinValue);
|
|
end;
|
|
|
|
procedure TdxInspectorCurrencyRow.SetMaxValue(Value: Double);
|
|
begin
|
|
if (srMaxValue in FAssignedValues) and (Value = FMaxValue) then Exit;
|
|
FMaxValue := Value;
|
|
Include(FAssignedValues, srMaxValue);
|
|
end;
|
|
|
|
procedure TdxInspectorCurrencyRow.SetNullable(Value: Boolean);
|
|
begin
|
|
if FNullable <> Value then
|
|
begin
|
|
FNullable := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorCurrencyRow.SetNullString(const Value: string);
|
|
begin
|
|
if FNullString <> Value then
|
|
begin
|
|
FNullString := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorCurrencyRow.CMWinIniChange(var Message: TWMWinIniChange);
|
|
begin
|
|
inherited;
|
|
if not Application.UpdateFormatSettings then Exit;
|
|
if not FDisplayFormatStored then
|
|
begin
|
|
SysUtils.GetFormatSettings; // TODO ?
|
|
FDisplayFormat := DefaultCurrencyDisplayFormat;
|
|
end;
|
|
end;
|
|
|
|
{ TdxInspectorTextCurrencyRow }
|
|
function TdxInspectorTextCurrencyRow.GetDisplayText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
function TdxInspectorTextCurrencyRow.GetEditText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
procedure TdxInspectorTextCurrencyRow.SetEditText(const Value: string);
|
|
begin
|
|
if FText <> Value then
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorTextCurrencyRow.SetText(const Value: string);
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
|
|
{ TdxInspectorHyperLinkRow }
|
|
|
|
constructor TdxInspectorHyperLinkRow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FEditBackgroundColor := clWhite;
|
|
FEditFontColor := clBlue;
|
|
FStartKey := VK_RETURN + scCtrl;
|
|
PrepareLinkFont;
|
|
end;
|
|
|
|
destructor TdxInspectorHyperLinkRow.Destroy;
|
|
begin
|
|
FLinkFont.Free;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TdxInspectorHyperLinkRow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorHyperLinkRow then
|
|
begin
|
|
if Assigned(Inspector) then Inspector.BeginUpdate;
|
|
try
|
|
inherited Assign(Source);
|
|
EditBackgroundColor := TdxInspectorHyperLinkRow(Source).EditBackgroundColor;
|
|
EditFontColor := TdxInspectorHyperLinkRow(Source).EditFontColor;
|
|
SingleClick := TdxInspectorHyperLinkRow(Source).SingleClick;
|
|
StartKey := TdxInspectorHyperLinkRow(Source).StartKey;
|
|
finally
|
|
if Assigned(Inspector) then Inspector.EndUpdate;
|
|
end;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
procedure TdxInspectorHyperLinkRow.RestoreDefaults;
|
|
begin
|
|
inherited RestoreDefaults;
|
|
FEditBackgroundColor := clWhite;
|
|
FEditFontColor := clBlue;
|
|
FSingleClick := False;
|
|
FStartKey := VK_RETURN + scCtrl;
|
|
end;
|
|
|
|
procedure TdxInspectorHyperLinkRow.DoStartClick(Sender: TObject);
|
|
begin
|
|
if Assigned(FOnStartClick) then FOnStartClick(Self);
|
|
end;
|
|
|
|
function TdxInspectorHyperLinkRow.GetdxInplaceEditClass : TdxInplaceEditClass;
|
|
begin
|
|
Result := TdxInspectorHyperLinkEdit;
|
|
end;
|
|
|
|
procedure TdxInspectorHyperLinkRow.InitEditProperties(AInplaceEdit: TdxInplaceEdit);
|
|
begin
|
|
inherited InitEditProperties(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceHyperLinkEdit then
|
|
with TdxInspectorHyperLinkEdit(AInplaceEdit) do
|
|
begin
|
|
Color := Self.EditBackgroundColor;
|
|
LinkColor := Self.EditFontColor;
|
|
SingleClick := Self.SingleClick;
|
|
StartKey := Self.StartKey;
|
|
if Assigned(Self.FOnStartClick) then
|
|
OnStartClick := Self.DoStartClick
|
|
else
|
|
OnStartClick := nil;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorHyperLinkRow.PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData);
|
|
begin
|
|
inherited PrepareViewData(AViewData, ACellViewData);
|
|
if AViewData is TdxHyperLinkEditViewData then
|
|
with TdxHyperLinkEditViewData(AViewData) do
|
|
begin
|
|
if not ACellViewData.Cell_Selected and (LinkFont.Color <> clDefault) then
|
|
TextColor := ColorToRGB(LinkFont.Color);
|
|
Font := LinkFont.Handle;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorHyperLinkRow.PrepareLinkFont;
|
|
begin
|
|
if FLinkFont = nil then
|
|
FLinkFont := TFont.Create;
|
|
FLinkFont.Style := FLinkFont.Style + [fsUnderline];
|
|
if SingleClick then
|
|
FLinkFont.Color := EditFontColor
|
|
else
|
|
FLinkFont.Color := clDefault;
|
|
end;
|
|
|
|
procedure TdxInspectorHyperLinkRow.SetEditBackgroundColor(Value: TColor);
|
|
begin
|
|
if FEditBackgroundColor <> Value then
|
|
begin
|
|
FEditBackgroundColor := Value;
|
|
PrepareLinkFont;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorHyperLinkRow.SetEditFontColor(Value: TColor);
|
|
begin
|
|
if FEditFontColor <> Value then
|
|
begin
|
|
FEditFontColor := Value;
|
|
PrepareLinkFont;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorHyperLinkRow.SetSingleClick(Value: Boolean);
|
|
begin
|
|
if FSingleClick <> Value then
|
|
begin
|
|
FSingleClick := Value;
|
|
PrepareLinkFont;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
{ TdxInspectorTextHyperLinkRow }
|
|
|
|
function TdxInspectorTextHyperLinkRow.GetDisplayText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
function TdxInspectorTextHyperLinkRow.GetEditText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
procedure TdxInspectorTextHyperLinkRow.SetEditText(const Value: string);
|
|
begin
|
|
if FText <> Value then
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorTextHyperLinkRow.SetText(const Value: string);
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
|
|
{ TdxInspectorCustomBlobRow }
|
|
|
|
constructor TdxInspectorCustomBlobRow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FBlobPaintStyle := bpsIcon;
|
|
FMaxDisplayLength := 255;
|
|
FMemoHideScrollBars := True;
|
|
FMemoScrollBars := ssBoth;
|
|
FMemoWantReturns := True;
|
|
FMemoWantTabs := True;
|
|
FMemoWordWrap := True;
|
|
FPictureAutoSize := True;
|
|
FPictureClipboardFormat := CF_PICTURE;
|
|
FPopupHeight := 140;
|
|
FPopupWidth := 200;
|
|
FSizeablePopup := True;
|
|
end;
|
|
|
|
procedure TdxInspectorCustomBlobRow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorCustomBlobRow then
|
|
begin
|
|
if Assigned(Inspector) then Inspector.BeginUpdate;
|
|
try
|
|
inherited Assign(Source);
|
|
AlwaysSaveText := TdxInspectorCustomBlobRow(Source).AlwaysSaveText;
|
|
BlobEditKind := TdxInspectorCustomBlobRow(Source).BlobEditKind;
|
|
BlobKind := TdxInspectorCustomBlobRow(Source).BlobKind;
|
|
BlobPaintStyle := TdxInspectorCustomBlobRow(Source).BlobPaintStyle;
|
|
MaxDisplayLength := TdxInspectorCustomBlobRow(Source).MaxDisplayLength;
|
|
MemoMaxLength := TdxInspectorCustomBlobRow(Source).MemoMaxLength;
|
|
MemoCharCase := TdxInspectorCustomBlobRow(Source).MemoCharCase;
|
|
MemoHideScrollBars := TdxInspectorCustomBlobRow(Source).MemoHideScrollBars;
|
|
MemoMaxLength := TdxInspectorCustomBlobRow(Source).MemoMaxLength;
|
|
MemoOEMConvert := TdxInspectorCustomBlobRow(Source).MemoOEMConvert;
|
|
MemoScrollBars := TdxInspectorCustomBlobRow(Source).MemoScrollBars;
|
|
MemoSelectionBar := TdxInspectorCustomBlobRow(Source).MemoSelectionBar;
|
|
MemoWantReturns := TdxInspectorCustomBlobRow(Source).MemoWantReturns;
|
|
MemoWantTabs := TdxInspectorCustomBlobRow(Source).MemoWantTabs;
|
|
MemoWordWrap := TdxInspectorCustomBlobRow(Source).MemoWordWrap;
|
|
PictureAutoSize := TdxInspectorCustomBlobRow(Source).PictureAutoSize;
|
|
PictureFilter := TdxInspectorCustomBlobRow(Source).PictureFilter;
|
|
PictureTransparency := TdxInspectorCustomBlobRow(Source).PictureTransparency;
|
|
PopupHeight := TdxInspectorCustomBlobRow(Source).PopupHeight;
|
|
PopupWidth := TdxInspectorCustomBlobRow(Source).PopupWidth;
|
|
ShowExPopupItems := TdxInspectorCustomBlobRow(Source).ShowExPopupItems;
|
|
ShowPicturePopup := TdxInspectorCustomBlobRow(Source).ShowPicturePopup;
|
|
SizeablePopup := TdxInspectorCustomBlobRow(Source).SizeablePopup;
|
|
finally
|
|
if Assigned(Inspector) then Inspector.EndUpdate;
|
|
end;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
procedure TdxInspectorCustomBlobRow.RestoreDefaults;
|
|
begin
|
|
inherited RestoreDefaults;
|
|
FAlwaysSaveText := False;
|
|
FBlobEditKind := bekMemo;
|
|
FBlobKind := bkAuto;
|
|
FBlobPaintStyle := bpsIcon;
|
|
FMaxDisplayLength := 255;
|
|
FMemoCharCase := ecNormal;
|
|
FMemoHideScrollBars := True;
|
|
FMemoMaxLength := 0;
|
|
FMemoOEMConvert := False;
|
|
FMemoScrollBars := ssBoth;
|
|
FMemoSelectionBar := False;
|
|
FMemoWantReturns := True;
|
|
FMemoWantTabs := True;
|
|
FMemoWordWrap := True;
|
|
FPictureAutoSize := True;
|
|
FPictureTransparency := gtDefault;
|
|
FPopupHeight := 140;
|
|
FPopupWidth := 200;
|
|
FShowExPopupItems := False;
|
|
FShowPicturePopup := False;
|
|
FSizeablePopup := True;
|
|
end;
|
|
|
|
function TdxInspectorCustomBlobRow.AssignEditValue(AInplaceEdit: TdxInplaceEdit): Variant;
|
|
begin
|
|
if AInplaceEdit is TdxInplaceBlobEdit then
|
|
Self.EditText := TdxInspectorBlobEdit(AInplaceEdit).Text;
|
|
Result := EditText;
|
|
end;
|
|
|
|
procedure TdxInspectorCustomBlobRow.DoAssignPicture(Sender: TObject; var Picture: TPicture);
|
|
begin
|
|
if Assigned(FOnAssignPicture) then FOnAssignPicture(Self, Picture);
|
|
end;
|
|
|
|
procedure TdxInspectorCustomBlobRow.DoGetGraphicClass(Sender: TObject; var GraphicClass: TGraphicClass);
|
|
begin
|
|
GraphicClass := GetGraphicClass;
|
|
end;
|
|
|
|
procedure TdxInspectorCustomBlobRow.DoSavePopupSize(Sender: TObject);
|
|
begin
|
|
if Sender is TdxInspectorBlobEdit then
|
|
begin
|
|
PopupWidth := TdxInspectorBlobEdit(Sender).PopupWidth;
|
|
PopupHeight := TdxInspectorBlobEdit(Sender).PopupHeight;
|
|
end;
|
|
end;
|
|
|
|
function TdxInspectorCustomBlobRow.GetBlobData: Variant;
|
|
begin
|
|
Result := EditText;
|
|
end;
|
|
|
|
function TdxInspectorCustomBlobRow.GetBlobEditKind: TdxBlobEditKind;
|
|
begin
|
|
Result := FBlobEditKind;
|
|
end;
|
|
|
|
function TdxInspectorCustomBlobRow.GetBlobText: string;
|
|
begin
|
|
Result := DisplayText;
|
|
end;
|
|
|
|
function TdxInspectorCustomBlobRow.GetdxInplaceEditClass: TdxInplaceEditClass;
|
|
begin
|
|
Result := TdxInspectorBlobEdit;
|
|
end;
|
|
|
|
function TdxInspectorCustomBlobRow.GetGraphicClass: TGraphicClass;
|
|
begin
|
|
Result := PictureGraphicClass;
|
|
if Assigned(FOnGetGraphicClass) then FOnGetGraphicClass(Self, Result);
|
|
end;
|
|
|
|
procedure TdxInspectorCustomBlobRow.InitEditProperties(AInplaceEdit: TdxInplaceEdit);
|
|
begin
|
|
inherited InitEditProperties(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceBlobEdit then
|
|
with TdxInspectorBlobEdit(AInplaceEdit) do
|
|
begin
|
|
AlwaysSaveText := Self.AlwaysSaveText;
|
|
BlobEditKind := Self.GetBlobEditKind;
|
|
BlobPaintStyle := Self.BlobPaintStyle;
|
|
if BlobPaintStyle = bpsText then
|
|
BlobText := Self.GetBlobData
|
|
else
|
|
BlobText := Self.GetBlobText; // Self.EditText; // TODO
|
|
MemoCharCase := Self.MemoCharCase;
|
|
MemoHideScrollBars := Self.MemoHideScrollBars;
|
|
MemoMaxLength := Self.MemoMaxLength;
|
|
MemoOEMConvert := Self.MemoOEMConvert;
|
|
MemoScrollBars := Self.MemoScrollBars;
|
|
MemoSelectionBar := Self.MemoSelectionBar;
|
|
MemoWantReturns := Self.MemoWantReturns;
|
|
MemoWantTabs := Self.MemoWantTabs;
|
|
MemoWordWrap := Self.MemoWordWrap;
|
|
PictureAutoSize := Self.PictureAutoSize;
|
|
PictureClipboardFormat := Self.PictureClipboardFormat;
|
|
PictureFilter := Self.PictureFilter;
|
|
PictureGraphicClass := Self.PictureGraphicClass;
|
|
PictureTransparency := Self.PictureTransparency;
|
|
PopupHeight := Self.PopupHeight;
|
|
PopupWidth := Self.PopupWidth;
|
|
ShowExPopupItems := Self.ShowExPopupItems;
|
|
ShowPicturePopup := Self.ShowPicturePopup;
|
|
SizeablePopup := Self.SizeablePopup;
|
|
OnAssignPicture := Self.DoAssignPicture;
|
|
OnGetGraphicClass := Self.DoGetGraphicClass;
|
|
OnSavePopupSize := Self.DoSavePopupSize;
|
|
end;
|
|
end;
|
|
|
|
function TdxInspectorCustomBlobRow.InitEditValue(AInplaceEdit: TdxInplaceEdit): Variant;
|
|
begin
|
|
inherited InitEditValue(AInplaceEdit);
|
|
Result := EditText;
|
|
if AInplaceEdit is TdxInplaceBlobEdit then
|
|
with TdxInspectorBlobEdit(AInplaceEdit) do
|
|
Text := Result;
|
|
end;
|
|
|
|
procedure TdxInspectorCustomBlobRow.PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData);
|
|
begin
|
|
inherited PrepareViewData(AViewData, ACellViewData);
|
|
if AViewData is TdxBlobEditViewData then
|
|
with TdxBlobEditViewData(AViewData) do
|
|
begin
|
|
BlobEditKind := Self.GetBlobEditKind;
|
|
BlobPaintStyle := Self.BlobPaintStyle;
|
|
Images := imgBlobImages;
|
|
Data := Self.GetBlobData;
|
|
IsNull := VarIsNull(Data) or ((VarType(Data) = varString) and (Data = ''));
|
|
if BlobPaintStyle = bpsText then
|
|
Data := VarToStr(Self.GetBlobData)
|
|
else
|
|
Data := Self.GetBlobText; // Self.EditText; // TODO
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorCustomBlobRow.SetBlobEditKind(Value: TdxBlobEditKind);
|
|
begin
|
|
if FBlobEditKind <> Value then
|
|
begin
|
|
FBlobEditKind := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorCustomBlobRow.SetBlobKind(Value: TdxBlobKind);
|
|
begin
|
|
if FBlobKind <> Value then
|
|
begin
|
|
FBlobKind := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorCustomBlobRow.SetBlobPaintStyle(Value: TdxBlobPaintStyle);
|
|
begin
|
|
if BlobPaintStyle <> Value then
|
|
begin
|
|
FBlobPaintStyle := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
{ TdxInspectorTextBlobRow }
|
|
|
|
function TdxInspectorTextBlobRow.GetDisplayText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
function TdxInspectorTextBlobRow.GetEditText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
procedure TdxInspectorTextBlobRow.SetEditText(const Value: string);
|
|
begin
|
|
if FText <> Value then
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorTextBlobRow.SetText(const Value: string);
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
|
|
{ TdxInspectorMRURow }
|
|
|
|
constructor TdxInspectorMRURow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
ImmediateDropDown := False;
|
|
FMaxItemCount := 7;
|
|
FShowEllipsis := True;
|
|
end;
|
|
|
|
procedure TdxInspectorMRURow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorMRURow then
|
|
begin
|
|
if Assigned(Inspector) then Inspector.BeginUpdate;
|
|
try
|
|
inherited Assign(Source);
|
|
MaxItemCount := TdxInspectorMRURow(Source).MaxItemCount;
|
|
ShowEllipsis := TdxInspectorMRURow(Source).ShowEllipsis;
|
|
finally
|
|
if Assigned(Inspector) then Inspector.EndUpdate;
|
|
end;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
procedure TdxInspectorMRURow.RestoreDefaults;
|
|
begin
|
|
inherited RestoreDefaults;
|
|
FMaxItemCount := 7;
|
|
FShowEllipsis := True;
|
|
end;
|
|
|
|
function TdxInspectorMRURow.AssignEditValue(AInplaceEdit: TdxInplaceEdit): Variant;
|
|
begin
|
|
Items.Assign(TdxInspectorMRUEdit(AInplaceEdit).Items);
|
|
Result := inherited AssignEditValue(AInplaceEdit);
|
|
end;
|
|
|
|
procedure TdxInspectorMRURow.DoButtonClick(Sender: TObject);
|
|
begin
|
|
if Assigned(FOnButtonClick) then FOnButtonClick(Self);
|
|
end;
|
|
|
|
function TdxInspectorMRURow.GetdxInplaceEditClass: TdxInplaceEditClass;
|
|
begin
|
|
Result := TdxInspectorMRUEdit;
|
|
end;
|
|
|
|
procedure TdxInspectorMRURow.InitEditProperties(AInplaceEdit: TdxInplaceEdit);
|
|
begin
|
|
inherited InitEditProperties(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceMRUEdit then
|
|
with TdxInspectorMRUEdit(AInplaceEdit) do
|
|
begin
|
|
MaxItemCount := Self.MaxItemCount;
|
|
ShowEllipsis := Self.ShowEllipsis;
|
|
OnButtonClick := Self.DoButtonClick;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorMRURow.PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData);
|
|
begin
|
|
inherited PrepareViewData(AViewData, ACellViewData);
|
|
if AViewData is TdxMRUEditViewData then
|
|
with TdxMRUEditViewData(AViewData) do
|
|
begin
|
|
ShowEllipsis := Self.ShowEllipsis;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorMRURow.SetShowEllipsis(Value: Boolean);
|
|
begin
|
|
if FShowEllipsis <> Value then
|
|
begin
|
|
FShowEllipsis := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
{ TdxInspectorTextMRURow }
|
|
|
|
function TdxInspectorTextMRURow.GetDisplayText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
function TdxInspectorTextMRURow.GetEditText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
procedure TdxInspectorTextMRURow.SetEditText(const Value: string);
|
|
begin
|
|
if FText <> Value then
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorTextMRURow.SetText(const Value: string);
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
|
|
{ TdxInspectorPopupRow }
|
|
|
|
constructor TdxInspectorPopupRow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FPopupFormBorderStyle := pbsDialog;
|
|
FPopupFormFlatBorder := True;
|
|
FPopupFormSizeable := True;
|
|
FPopupAutoSize := True;
|
|
FPopupHeight := 200;
|
|
FPopupWidth := 250;
|
|
FPopupMinHeight := 100;
|
|
FPopupMinWidth := 100;
|
|
end;
|
|
|
|
procedure TdxInspectorPopupRow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorPopupRow then
|
|
begin
|
|
inherited Assign(Source);
|
|
HideEditCursor := TdxInspectorPopupRow(Source).HideEditCursor;
|
|
PopupAutoSize := TdxInspectorPopupRow(Source).PopupAutoSize;
|
|
PopupHeight := TdxInspectorPopupRow(Source).PopupHeight;
|
|
PopupWidth := TdxInspectorPopupRow(Source).PopupWidth;
|
|
PopupFormBorderStyle := TdxInspectorPopupRow(Source).PopupFormBorderStyle;
|
|
PopupFormCaption := TdxInspectorPopupRow(Source).PopupFormCaption;
|
|
PopupFormClientEdge := TdxInspectorPopupRow(Source).PopupFormClientEdge;
|
|
PopupFormFlatBorder := TdxInspectorPopupRow(Source).PopupFormFlatBorder;
|
|
PopupFormSizeable := TdxInspectorPopupRow(Source).PopupFormSizeable;
|
|
PopupMinHeight := TdxInspectorPopupRow(Source).PopupMinHeight;
|
|
PopupMinWidth := TdxInspectorPopupRow(Source).PopupMinWidth;
|
|
PopupControl := TdxInspectorPopupRow(Source).PopupControl;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
procedure TdxInspectorPopupRow.RestoreDefaults;
|
|
begin
|
|
inherited RestoreDefaults;
|
|
FHideEditCursor := False;
|
|
FPopupAutoSize := True;
|
|
FPopupHeight := 200;
|
|
FPopupWidth := 250;
|
|
FPopupMinHeight := 100;
|
|
FPopupMinWidth := 100;
|
|
FPopupFormBorderStyle := pbsDialog;
|
|
FPopupFormClientEdge := False;
|
|
FPopupFormFlatBorder := True;
|
|
FPopupFormSizeable := True;
|
|
end;
|
|
|
|
procedure TdxInspectorPopupRow.Notification(AComponent: TComponent; Operation: TOperation);
|
|
begin
|
|
inherited Notification(AComponent, Operation);
|
|
if Operation = opRemove then
|
|
if AComponent = PopupControl then PopupControl := nil;
|
|
end;
|
|
|
|
procedure TdxInspectorPopupRow.DoCloseQuery(Sender: TObject; var CanClose: Boolean);
|
|
begin
|
|
if Assigned(FOnCloseQuery) then FOnCloseQuery(Self, CanClose);
|
|
end;
|
|
|
|
procedure TdxInspectorPopupRow.DoCloseUp(Sender: TObject; var Text: string; var Accept: Boolean);
|
|
begin
|
|
if Assigned(FOnCloseUp) then FOnCloseUp(Self, Text, Accept);
|
|
end;
|
|
|
|
procedure TdxInspectorPopupRow.DoInitPopup(Sender: TObject);
|
|
begin
|
|
if Assigned(FOnInitPopup) then FOnInitPopup(Self);
|
|
end;
|
|
|
|
procedure TdxInspectorPopupRow.DoPopup(Sender: TObject; const EditText: string);
|
|
begin
|
|
if Assigned(FOnPopup) then FOnPopup(Self, EditText);
|
|
end;
|
|
|
|
function TdxInspectorPopupRow.GetdxInplaceEditClass: TdxInplaceEditClass;
|
|
begin
|
|
Result := TdxInspectorPopupEdit;
|
|
end;
|
|
|
|
procedure TdxInspectorPopupRow.InitEditProperties(AInplaceEdit: TdxInplaceEdit);
|
|
begin
|
|
inherited InitEditProperties(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplacePopupEdit then
|
|
with TdxInspectorPopupEdit(AInplaceEdit) do
|
|
begin
|
|
HideEditCursor := Self.HideEditCursor;
|
|
PopupAutoSize := Self.PopupAutoSize;
|
|
PopupControl := Self.PopupControl;
|
|
PopupFormBorderStyle := Self.PopupFormBorderStyle;
|
|
PopupFormCaption := Self.PopupFormCaption;
|
|
PopupClientEdge := Self.PopupFormClientEdge;
|
|
PopupFlatBorder := Self.PopupFormFlatBorder;
|
|
PopupHeight := Self.PopupHeight;
|
|
PopupMinHeight := Self.PopupMinHeight;
|
|
PopupMinWidth := Self.PopupMinWidth;
|
|
PopupSizeable := Self.PopupFormSizeable;
|
|
PopupWidth := Self.PopupWidth;
|
|
OnCloseQuery := Self.DoCloseQuery;
|
|
OnCloseUp := Self.DoCloseUp;
|
|
OnInitPopup := Self.DoInitPopup;
|
|
OnPopup := Self.DoPopup;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorPopupRow.SetPopupControl(Value: TControl);
|
|
begin
|
|
FPopupControl := Value;
|
|
if Value <> nil then
|
|
Value.FreeNotification(Self)
|
|
else
|
|
if csDestroying in ComponentState then Exit;
|
|
end;
|
|
|
|
procedure TdxInspectorPopupRow.SetPopupHeight(Value: Integer);
|
|
begin
|
|
if Value < FPopupMinHeight then Value := FPopupMinHeight;
|
|
if FPopupHeight <> Value then
|
|
FPopupHeight := Value;
|
|
end;
|
|
|
|
procedure TdxInspectorPopupRow.SetPopupMinHeight(Value: Integer);
|
|
begin
|
|
if Value < 0 then Value := 0;
|
|
FPopupMinHeight := Value;
|
|
SetPopupHeight(FPopupHeight);
|
|
end;
|
|
|
|
procedure TdxInspectorPopupRow.SetPopupMinWidth(Value: Integer);
|
|
begin
|
|
if Value < 0 then Value := 0;
|
|
FPopupMinWidth := Value;
|
|
SetPopupWidth(FPopupWidth);
|
|
end;
|
|
|
|
procedure TdxInspectorPopupRow.SetPopupWidth(Value: Integer);
|
|
begin
|
|
if Value < FPopupMinWidth then Value := FPopupMinWidth;
|
|
if FPopupWidth <> Value then
|
|
FPopupWidth := Value;
|
|
end;
|
|
|
|
{ TdxInspectorTextPopupRow }
|
|
|
|
function TdxInspectorTextPopupRow.GetDisplayText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
function TdxInspectorTextPopupRow.GetEditText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
procedure TdxInspectorTextPopupRow.SetEditText(const Value: string);
|
|
begin
|
|
if FText <> Value then
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorTextPopupRow.SetText(const Value: string);
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
|
|
{ TdxInspectorMemoRow }
|
|
|
|
constructor TdxInspectorMemoRow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FHideScrollBars := True;
|
|
FWantReturns := True;
|
|
FWordWrap := True;
|
|
end;
|
|
|
|
procedure TdxInspectorMemoRow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorMemoRow then
|
|
begin
|
|
if Assigned(Inspector) then Inspector.BeginUpdate;
|
|
try
|
|
inherited Assign(Source);
|
|
HideScrollBars := TdxInspectorMemoRow(Source).HideScrollBars;
|
|
ScrollBars := TdxInspectorMemoRow(Source).ScrollBars;
|
|
SelectionBar := TdxInspectorMemoRow(Source).SelectionBar;
|
|
WantReturns := TdxInspectorMemoRow(Source).WantReturns;
|
|
WantTabs := TdxInspectorMemoRow(Source).WantTabs;
|
|
WordWrap := TdxInspectorMemoRow(Source).WordWrap;
|
|
finally
|
|
if Assigned(Inspector) then Inspector.EndUpdate;
|
|
end;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
procedure TdxInspectorMemoRow.RestoreDefaults;
|
|
begin
|
|
inherited RestoreDefaults;
|
|
FHideScrollBars := True;
|
|
FScrollBars := ssNone;
|
|
SelectionBar := False;
|
|
FWantReturns := True;
|
|
FWantTabs := False;
|
|
FWordWrap := True;
|
|
end;
|
|
|
|
function TdxInspectorMemoRow.GetdxInplaceEditClass: TdxInplaceEditClass;
|
|
begin
|
|
Result := TdxInspectorMemoEdit;
|
|
end;
|
|
|
|
function TdxInspectorMemoRow.GetMemoText: string;
|
|
begin
|
|
Result := EditText;
|
|
end;
|
|
|
|
procedure TdxInspectorMemoRow.InitEditProperties(AInplaceEdit: TdxInplaceEdit);
|
|
begin
|
|
inherited InitEditProperties(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceMemoEdit then
|
|
with TdxInspectorMemoEdit(AInplaceEdit) do
|
|
begin
|
|
HideScrollBars := Self.HideScrollBars;
|
|
ScrollBars := Self.ScrollBars;
|
|
SelectionBar := Self.SelectionBar;
|
|
WantReturns := Self.WantReturns;
|
|
WantTabs := Self.WantTabs;
|
|
WordWrap := Self.WordWrap;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorMemoRow.PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData);
|
|
begin
|
|
inherited PrepareViewData(AViewData, ACellViewData);
|
|
if AViewData is TdxTextEditViewData then
|
|
with TdxTextEditViewData(AViewData) do
|
|
begin
|
|
DrawAlignment := daMultiLine; // TODO: !
|
|
Data := Self.GetMemoText;
|
|
SelectionBar := Self.SelectionBar;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorMemoRow.SetSelectionBar(Value: Boolean);
|
|
begin
|
|
if FSelectionBar <> Value then
|
|
begin
|
|
FSelectionBar := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
{ TdxInspectorTextMemoRow }
|
|
|
|
function TdxInspectorTextMemoRow.GetDisplayText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
function TdxInspectorTextMemoRow.GetEditText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
procedure TdxInspectorTextMemoRow.SetEditText(const Value: string);
|
|
begin
|
|
if FText <> Value then
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorTextMemoRow.SetText(const Value: string);
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
|
|
{ TdxInspectorGraphicRow }
|
|
|
|
constructor TdxInspectorGraphicRow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
FPicture := TPicture.Create;
|
|
FPopupToolBar := TdxPopupToolBarWindow.Create(nil);
|
|
FPopupToolbarPos := Point(-10000, -10000);
|
|
FCenter := True;
|
|
FClipboardFormat := CF_PICTURE;
|
|
FDblClickActivate := True;
|
|
FPopupToolbarPosStored := True;
|
|
FStretch := True;
|
|
end;
|
|
|
|
destructor TdxInspectorGraphicRow.Destroy;
|
|
begin
|
|
FPopupToolBar.Free;
|
|
FPopupToolBar := nil;
|
|
FPicture.Free;
|
|
FPicture := nil;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TdxInspectorGraphicRow.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxInspectorGraphicRow then
|
|
begin
|
|
if Assigned(Inspector) then Inspector.BeginUpdate;
|
|
try
|
|
inherited Assign(Source);
|
|
Center := TdxInspectorGraphicRow(Source).Center;
|
|
CustomFilter := TdxInspectorGraphicRow(Source).CustomFilter;
|
|
CustomGraphic := TdxInspectorGraphicRow(Source).CustomGraphic;
|
|
DblClickActivate := TdxInspectorGraphicRow(Source).DblClickActivate;
|
|
GraphicTransparency := TdxInspectorGraphicRow(Source).GraphicTransparency;
|
|
PopupToolBar := TdxInspectorGraphicRow(Source).PopupToolBar;
|
|
PopupToolbarPosStored := TdxInspectorGraphicRow(Source).PopupToolbarPosStored;
|
|
QuickDraw := TdxInspectorGraphicRow(Source).QuickDraw;
|
|
Stretch := TdxInspectorGraphicRow(Source).Stretch;
|
|
finally
|
|
if Assigned(Inspector) then Inspector.EndUpdate;
|
|
end;
|
|
end
|
|
else
|
|
inherited Assign(Source);
|
|
end;
|
|
|
|
procedure TdxInspectorGraphicRow.RestoreDefaults; // TODO: BeginUpdate/Endupdate
|
|
begin
|
|
inherited RestoreDefaults;
|
|
FCenter := True;
|
|
FCustomGraphic := False;
|
|
FDblClickActivate := True;
|
|
FGraphicTransparency := gtDefault;
|
|
FPopupToolbarPosStored := True;
|
|
FQuickDraw := False;
|
|
FStretch := True;
|
|
end;
|
|
|
|
function TdxInspectorGraphicRow.AssignEditValue(AInplaceEdit: TdxInplaceEdit): Variant;
|
|
var
|
|
S: string;
|
|
APicture: TPicture;
|
|
begin
|
|
if AInplaceEdit is TdxInplaceGraphicEdit then
|
|
with TdxInspectorGraphicEdit(AInplaceEdit) do
|
|
begin
|
|
APicture := Picture;
|
|
DoAssignPicture(Self, APicture);
|
|
SavePicture(Picture, S);
|
|
Self.EditText := S;
|
|
end;
|
|
Result := EditText;
|
|
end;
|
|
|
|
procedure TdxInspectorGraphicRow.DoAssignPicture(Sender: TObject; var Picture: TPicture);
|
|
begin
|
|
if Assigned(FOnAssignPicture) then FOnAssignPicture(Self, Picture);
|
|
end;
|
|
|
|
procedure TdxInspectorGraphicRow.DoCustomClick(Sender: TObject);
|
|
begin
|
|
if Assigned(FOnCustomClick) then FOnCustomClick(Self);
|
|
end;
|
|
|
|
procedure TdxInspectorGraphicRow.DoGetGraphicClass(Sender: TObject; var GraphicClass: TGraphicClass);
|
|
begin
|
|
GraphicClass := GetGraphicClass;
|
|
end;
|
|
|
|
function TdxInspectorGraphicRow.GetdxInplaceEditClass: TdxInplaceEditClass;
|
|
begin
|
|
Result := TdxInspectorGraphicEdit;
|
|
end;
|
|
|
|
function TdxInspectorGraphicRow.GetGraphicClass: TGraphicClass;
|
|
begin
|
|
Result := nil;
|
|
if Assigned(FOnGetGraphicClass) then
|
|
FOnGetGraphicClass(Self, Result);
|
|
end;
|
|
|
|
function TdxInspectorGraphicRow.GetGraphicValue: Variant;
|
|
begin
|
|
Result := EditText;
|
|
end;
|
|
|
|
procedure TdxInspectorGraphicRow.InitEditProperties(AInplaceEdit: TdxInplaceEdit);
|
|
begin
|
|
inherited InitEditProperties(AInplaceEdit);
|
|
if AInplaceEdit is TdxInplaceGraphicEdit then
|
|
with TdxInspectorGraphicEdit(AInplaceEdit) do
|
|
begin
|
|
Center := Self.Center;
|
|
ClipboardFormat := Self.ClipboardFormat;
|
|
CustomFilter := Self.CustomFilter;
|
|
DblClickActivate := Self.DblClickActivate;
|
|
GraphicTransparency := Self.GraphicTransparency;
|
|
ToolbarLayout.Assign(Self.PopupToolBar);
|
|
ToolbarPos := Self.PopupToolbarPos;
|
|
ToolbarPosStored := Self.PopupToolbarPosStored;
|
|
QuickDraw := Self.QuickDraw;
|
|
Stretch := Self.Stretch;
|
|
OnAssignPicture := Self.DoAssignPicture;
|
|
OnCustomClick := Self.DoCustomClick;
|
|
OnGetGraphicClass := Self.DoGetGraphicClass;
|
|
end;
|
|
end;
|
|
|
|
function TdxInspectorGraphicRow.InitEditValue(AInplaceEdit: TdxInplaceEdit): Variant;
|
|
begin
|
|
inherited InitEditValue(AInplaceEdit);
|
|
Result := GetGraphicValue;
|
|
if AInplaceEdit is TdxInplaceGraphicEdit then
|
|
with TdxInspectorGraphicEdit(AInplaceEdit) do
|
|
begin
|
|
OffsetSize := Rect(0, 0, 0, 0);
|
|
Caption := '';
|
|
LoadPicture(Picture, Self.GetGraphicClass, Result);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorGraphicRow.PrepareViewData(AViewData: TdxEditViewData; ACellViewData: TdxInspectorCellViewData);
|
|
begin
|
|
inherited PrepareViewData(AViewData, ACellViewData);
|
|
if AViewData is TdxGraphicEditViewData then
|
|
with TdxGraphicEditViewData(AViewData) do
|
|
begin
|
|
LoadPictureFromText(FPicture);
|
|
if Self.GraphicTransparency <> gtDefault then
|
|
begin
|
|
if not IsPictureEmpty(Self.FPicture) then
|
|
FPicture.Graphic.Transparent := Self.GraphicTransparency = gtTransparent;
|
|
end;
|
|
Picture := Self.FPicture;
|
|
Data := '';
|
|
// // Other
|
|
// BkColor := ColorToRGB(ACellViewData.Cell_CellColor);
|
|
// Brush := ACellViewData.Cell_CellBrush;
|
|
Center := Self.Center;
|
|
QuickDraw := Self.QuickDraw;
|
|
// ShadowColor := ColorToRGB(ACellViewData.Cell_SelectionColor);
|
|
Stretch := Self.Stretch;
|
|
// TempTransparentBitmap := TdxTreeListCracker(TreeList).DrawBitmap; // TODO
|
|
TempTransparentBitmap := nil;
|
|
// TempDrawBitmap := TdxTreeListCracker(TreeList).DrawBitmap; // TODO
|
|
OffsetSize := Rect(0, 0, 0, 0);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorGraphicRow.LoadPictureFromText(APicture: TPicture);
|
|
begin
|
|
if not (CustomGraphic and (csDesigning in ComponentState)) then
|
|
LoadPicture(APicture, GetGraphicClass, GetGraphicValue)
|
|
else
|
|
APicture.Graphic := nil;
|
|
end;
|
|
|
|
procedure TdxInspectorGraphicRow.SetCenter(Value: Boolean);
|
|
begin
|
|
if FCenter <> Value then
|
|
begin
|
|
FCenter := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorGraphicRow.SetCustomGraphic(Value: Boolean);
|
|
begin
|
|
if FCustomGraphic <> Value then
|
|
begin
|
|
FCustomGraphic := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorGraphicRow.SetGraphicTransparency(Value: TdxGraphicEditTransparency);
|
|
begin
|
|
if FGraphicTransparency <> Value then
|
|
begin
|
|
FGraphicTransparency := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorGraphicRow.SetPopupToolBar(Value: TdxPopupToolBarWindow);
|
|
begin
|
|
FPopupToolBar.Assign(Value);
|
|
end;
|
|
|
|
procedure TdxInspectorGraphicRow.SetPopupToolbarPosStored(Value: Boolean);
|
|
begin
|
|
FPopupToolbarPosStored := Value;
|
|
if not FPopupToolbarPosStored then
|
|
FPopupToolbarPos := Point(-10000, -10000);
|
|
end;
|
|
|
|
procedure TdxInspectorGraphicRow.SetQuickDraw(Value: Boolean);
|
|
begin
|
|
if FQuickDraw <> Value then
|
|
begin
|
|
FQuickDraw := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorGraphicRow.SetStretch(Value: Boolean);
|
|
begin
|
|
if FStretch <> Value then
|
|
begin
|
|
FStretch := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
{ TdxInspectorTextGraphicRow }
|
|
|
|
function TdxInspectorTextGraphicRow.GetDisplayText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
function TdxInspectorTextGraphicRow.GetEditText: string;
|
|
begin
|
|
Result := FText;
|
|
end;
|
|
|
|
procedure TdxInspectorTextGraphicRow.SetEditText(const Value: string);
|
|
begin
|
|
if FText <> Value then
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxInspectorTextGraphicRow.SetText(const Value: string);
|
|
begin
|
|
FText := Value;
|
|
Changed;
|
|
end;
|
|
|
|
initialization
|
|
sdxInspCheckTextTrue := LoadStr(dxSTextTrue);
|
|
sdxInspCheckTextFalse := LoadStr(dxSTextFalse);
|
|
|
|
Classes.RegisterClasses([TdxInspectorTextMaskRow, TdxInspectorTextDateRow,
|
|
TdxInspectorTextCheckRow, TdxInspectorTextCalcRow, TdxInspectorTextButtonRow,
|
|
TdxInspectorTextSpinRow, TdxInspectorTextPickRow, TdxInspectorTextImageRow,
|
|
TdxInspectorTextTimeRow, TdxInspectorTextCurrencyRow, TdxInspectorTextHyperLinkRow,
|
|
TdxInspectorTextBlobRow, TdxInspectorTextMRURow, TdxInspectorTextPopupRow,
|
|
TdxInspectorTextMemoRow, TdxInspectorTextGraphicRow]);
|
|
|
|
end.
|
|
|