2752 lines
73 KiB
ObjectPascal
2752 lines
73 KiB
ObjectPascal
|
|
{******************************************}
|
|
{ }
|
|
{ FastReport VCL - Dialog designer }
|
|
{ Standard Dialog controls }
|
|
{ }
|
|
{ Copyright (c) 1998-2021 }
|
|
{ by Fast Reports Inc. }
|
|
{ }
|
|
{******************************************}
|
|
|
|
unit frxDCtrl;
|
|
|
|
interface
|
|
|
|
{$I frx.inc}
|
|
|
|
uses
|
|
{$IFNDEF FPC}
|
|
Windows, Messages, CommCtrl,
|
|
{$ENDIF}
|
|
SysUtils, Classes, Graphics, Controls, StdCtrls,
|
|
ExtCtrls, Forms, Menus, Dialogs, Comctrls, Buttons,
|
|
{$IFDEF FPC}
|
|
LMessages,MaskEdit, LCLType, LCLIntf, LCLProc,LazHelper, LazarusPackageIntf,
|
|
{$ELSE}
|
|
Mask,
|
|
{$ENDIF}
|
|
CheckLst, frxClass
|
|
{$IFDEF Delphi6}
|
|
, Variants
|
|
{$ENDIF};
|
|
|
|
|
|
type
|
|
{$IFDEF DELPHI16}
|
|
/// <summary>
|
|
/// The TfrxDialogControls lets you use the Frdialog controls in your report.
|
|
/// TfrxDialogControls is an empty component. It is used to add the
|
|
/// frxDCtrl.pas file to the "uses" list.
|
|
/// </summary>
|
|
[ComponentPlatformsAttribute(pidWin32 or pidWin64)]
|
|
{$ENDIF}
|
|
TfrxDialogControls = class(TComponent) // fake component
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxLabelControl component represents a TLabel adapter.
|
|
/// </summary>
|
|
TfrxLabelControl = class(TfrxDialogControl)
|
|
private
|
|
FLabel: TLabel;
|
|
function GetAlignment: TAlignment;
|
|
function GetAutoSize: Boolean;
|
|
function GetWordWrap: Boolean;
|
|
procedure SetAlignment(const Value: TAlignment);
|
|
procedure SetAutoSize(const Value: Boolean);
|
|
procedure SetWordWrap(const Value: Boolean);
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
class function GetDescription: String; override;
|
|
procedure BeforeStartReport; override;
|
|
procedure Draw(Canvas: TCanvas; ScaleX, ScaleY, OffsetX, OffsetY: Extended); override;
|
|
/// <summary>
|
|
/// Reference to internal TLabel object.
|
|
/// </summary>
|
|
property LabelCtl: TLabel read FLabel;
|
|
published
|
|
/// <summary>
|
|
/// Controls the horizontal placement of the text within the label.
|
|
/// </summary>
|
|
property Alignment: TAlignment read GetAlignment write SetAlignment
|
|
default taLeftJustify;
|
|
/// <summary>
|
|
/// Determines whether the size of the label automatically resizes to
|
|
/// accommodate the text.
|
|
/// </summary>
|
|
property AutoSize: Boolean read GetAutoSize write SetAutoSize default True;
|
|
property Caption;
|
|
property Color;
|
|
/// <summary>
|
|
/// Specifies whether the label text wraps when it is too long for the
|
|
/// width of the label.
|
|
/// </summary>
|
|
property WordWrap: Boolean read GetWordWrap write SetWordWrap default False;
|
|
|
|
property OnClick;
|
|
property OnDblClick;
|
|
property OnMouseDown;
|
|
property OnMouseMove;
|
|
property OnMouseUp;
|
|
end;
|
|
|
|
TfrxOnChangingEvent = type String;
|
|
|
|
TfrxPageControl = class(TfrxDialogControl)
|
|
private
|
|
FPageControl: TPageControl;
|
|
FOnChange: TfrxNotifyEvent;
|
|
FOnChanging: TfrxOnChangingEvent;
|
|
function GetMultiLine: Boolean;
|
|
function GetPageCount: Integer;
|
|
{$IFNDEF FPC}
|
|
function GetRaggedRight: Boolean;
|
|
function GetScrollOpposite: Boolean;
|
|
function GetStyle: TTabStyle;
|
|
{$ENDIF}
|
|
function GetTabHeight: Smallint;
|
|
function GetTabIndex: Integer;
|
|
function GetTabOrder: Integer;
|
|
function GetTabPosition: TTabPosition;
|
|
function GetTabWidth: Smallint;
|
|
procedure SetMultiLine(const Value: Boolean);
|
|
{$IFNDEF FPC}
|
|
procedure SetRaggedRight(const Value: Boolean);
|
|
procedure SetScrollOpposite(const Value: Boolean);
|
|
procedure SetStyle(const Value: TTabStyle);
|
|
{$ENDIF}
|
|
procedure SetTabHeight(const Value: Smallint);
|
|
procedure SetTabIndex(const Value: Integer);
|
|
procedure SetTabOrder(const Value: Integer);
|
|
procedure SetTabPosition(const Value: TTabPosition);
|
|
procedure SetTabWidth(const Value: Smallint);
|
|
{$IFNDEF FPC}
|
|
function GetHotTrack: Boolean;
|
|
procedure SetHotTrack(const Value: Boolean);
|
|
{$ENDIF}
|
|
procedure DoOnChange(Sender: TObject);
|
|
procedure DoOnChanging(Sender: TObject; var AllowChange: Boolean);
|
|
protected
|
|
procedure SetParent(AParent: TfrxComponent); override;
|
|
procedure SetWidth(Value: Extended); override;
|
|
procedure SetHeight(Value: Extended); override;
|
|
procedure UpdateSize;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
procedure Draw(Canvas: TCanvas; ScaleX, ScaleY, OffsetX, OffsetY: Extended); override;
|
|
function IsAcceptControl(aControl: TfrxComponent): Boolean; override;
|
|
function DoMouseDown(X, Y: Integer; Button: TMouseButton;
|
|
Shift: TShiftState; var EventParams: TfrxInteractiveEventsParams)
|
|
: Boolean; override;
|
|
property PageControl: TPageControl read FPageControl;
|
|
property PageCount: Integer read GetPageCount;
|
|
published
|
|
{$IFNDEF FPC}
|
|
property HotTrack: Boolean read GetHotTrack write SetHotTrack default False;
|
|
{$ENDIF}
|
|
property MultiLine: Boolean read GetMultiLine write SetMultiLine default False;
|
|
{$IFNDEF FPC}
|
|
property RaggedRight: Boolean read GetRaggedRight write SetRaggedRight default False;
|
|
property ScrollOpposite: Boolean read GetScrollOpposite
|
|
write SetScrollOpposite default False;
|
|
property Style: TTabStyle read GetStyle write SetStyle default tsTabs;
|
|
{$ENDIF}
|
|
property TabHeight: Smallint read GetTabHeight write SetTabHeight default 0;
|
|
property TabIndex: Integer read GetTabIndex write SetTabIndex stored False;
|
|
property TabPosition: TTabPosition read GetTabPosition write SetTabPosition
|
|
default tpTop;
|
|
property TabWidth: Smallint read GetTabWidth write SetTabWidth default 0;
|
|
property TabOrder: Integer read GetTabOrder write SetTabOrder;
|
|
property TabStop;
|
|
property OnChange: TfrxNotifyEvent read FOnChange write FOnChange;
|
|
property OnChanging: TfrxOnChangingEvent read FOnChanging write FOnChanging;
|
|
property OnEnter;
|
|
property OnExit;
|
|
property OnMouseDown;
|
|
property OnMouseMove;
|
|
property OnMouseUp;
|
|
end;
|
|
|
|
{ TfrxTabSheet }
|
|
|
|
TfrxTabSheet = class(TfrxDialogControl)
|
|
private
|
|
FTabSheet: TTabSheet;
|
|
function GetBorderWidth: Integer;
|
|
{$IFNDEF FPC}
|
|
function GetHighlighted: Boolean;
|
|
{$ENDIF}
|
|
function GetImageIndex: Integer;
|
|
function GetPageIndex: Integer;
|
|
function GetTabVisible: Boolean;
|
|
procedure SetBorderWidth(const Value: Integer);
|
|
{$IFNDEF FPC}
|
|
procedure SetHighlighted(const Value: Boolean);
|
|
{$ENDIF}
|
|
procedure SetImageIndex(const Value: Integer);
|
|
procedure SetPageIndex(const Value: Integer);
|
|
procedure SetTabVisible(const Value: Boolean);
|
|
protected
|
|
procedure CorrectControlCoordinates; override;
|
|
procedure SetParent(AParent: TfrxComponent); override;
|
|
procedure DoSetParent;
|
|
procedure SetLeft(Value: Extended); override;
|
|
procedure SetTop(Value: Extended); override;
|
|
procedure SetWidth(Value: Extended); override;
|
|
procedure SetHeight(Value: Extended); override;
|
|
procedure UpdateSize;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
function IsAcceptAsChild(aParent: TfrxComponent): Boolean; override;
|
|
function IsOwnerDraw: Boolean; override;
|
|
function IsContain(X, Y: Extended): Boolean; override;
|
|
function GetContainedComponent(X, Y: Extended; IsCanContain: TfrxComponent = nil): TfrxComponent; override;
|
|
property TabSheet: TTabSheet read FTabSheet;
|
|
// todo
|
|
property ImageIndex: Integer read GetImageIndex write SetImageIndex default 0;
|
|
published
|
|
property Caption;
|
|
property TabStop;
|
|
property BorderWidth: Integer read GetBorderWidth write SetBorderWidth ;
|
|
property TabVisible: Boolean read GetTabVisible write SetTabVisible default True;
|
|
property PageIndex: Integer read GetPageIndex write SetPageIndex stored False;
|
|
{$IFNDEF FPC}
|
|
property Highlighted: Boolean read GetHighlighted write SetHighlighted default False;
|
|
{$ENDIF}
|
|
property OnEnter;
|
|
property OnExit;
|
|
property OnMouseDown;
|
|
property OnMouseMove;
|
|
property OnMouseUp;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxCustomEditControl is the base class for TCustomEdit-based
|
|
/// controls.
|
|
/// </summary>
|
|
TfrxCustomEditControl = class(TfrxDialogControl)
|
|
private
|
|
FOnChange: TfrxNotifyEvent;
|
|
function GetMaxLength: Integer;
|
|
function GetPasswordChar: Char;
|
|
function GetReadOnly: Boolean;
|
|
function GetText: String;
|
|
procedure DoOnChange(Sender: TObject);
|
|
procedure SetMaxLength(const Value: Integer);
|
|
procedure SetPasswordChar(const Value: Char);
|
|
procedure SetReadOnly(const Value: Boolean);
|
|
procedure SetText(const Value: String);
|
|
protected
|
|
FCustomEdit: TCustomEdit;
|
|
function GetCharCase: TEditCharCase; virtual;
|
|
procedure SetCharCase(const Value: TEditCharCase); virtual;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
property CharCase: TEditCharCase read GetCharCase write SetCharCase default ecNormal;
|
|
/// <summary>
|
|
/// Specifies the maximum number of characters the user can enter into
|
|
/// the edit control.
|
|
/// </summary>
|
|
property MaxLength: Integer read GetMaxLength write SetMaxLength;
|
|
/// <summary>
|
|
/// Indicates the character, if any, to display in place of the actual
|
|
/// characters typed in the control.
|
|
/// </summary>
|
|
property PasswordChar: Char read GetPasswordChar write SetPasswordChar;
|
|
/// <summary>
|
|
/// Determines whether the user can change the text of the edit control.
|
|
/// </summary>
|
|
property ReadOnly: Boolean read GetReadOnly write SetReadOnly default False;
|
|
/// <summary>
|
|
/// Contains a text string associated with the control.
|
|
/// </summary>
|
|
property Text: String read GetText write SetText;
|
|
/// <summary>
|
|
/// Name of the script procedure that will be executed when the text for
|
|
/// the edit control may have changed.
|
|
/// </summary>
|
|
property OnChange: TfrxNotifyEvent read FOnChange write FOnChange;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxEditControl component represents a TEdit adapter.
|
|
/// </summary>
|
|
TfrxEditControl = class(TfrxCustomEditControl)
|
|
private
|
|
FEdit: TEdit;
|
|
protected
|
|
function GetCharCase: TEditCharCase; override;
|
|
procedure SetCharCase(const Value: TEditCharCase); override;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
class function GetDescription: String; override;
|
|
/// <summary>
|
|
/// Reference to internal TEdit object.
|
|
/// </summary>
|
|
property Edit: TEdit read FEdit;
|
|
published
|
|
property CharCase;
|
|
property Color;
|
|
property MaxLength;
|
|
property PasswordChar;
|
|
property ReadOnly;
|
|
property TabStop;
|
|
property Text;
|
|
property OnChange;
|
|
property OnClick;
|
|
property OnDblClick;
|
|
property OnEnter;
|
|
property OnExit;
|
|
property OnKeyDown;
|
|
property OnKeyPress;
|
|
property OnKeyUp;
|
|
property OnMouseDown;
|
|
property OnMouseMove;
|
|
property OnMouseUp;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxMemoControl component represents a TMemo adapter.
|
|
/// </summary>
|
|
TfrxMemoControl = class(TfrxCustomEditControl)
|
|
private
|
|
FMemo: TMemo;
|
|
function GetLines: TStrings;
|
|
procedure SetLines(const Value: TStrings);
|
|
function GetScrollStyle: TScrollStyle;
|
|
function GetWordWrap: Boolean;
|
|
procedure SetScrollStyle(const Value: TScrollStyle);
|
|
procedure SetWordWrap(const Value: Boolean);
|
|
protected
|
|
function GetCharCase: TEditCharCase; override;
|
|
procedure SetCharCase(const Value: TEditCharCase); override;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
class function GetDescription: String; override;
|
|
/// <summary>
|
|
/// Reference to internal TMemo object.
|
|
/// </summary>
|
|
property Memo: TMemo read FMemo;
|
|
published
|
|
property CharCase;
|
|
property Color;
|
|
/// <summary>
|
|
/// Contains the individual lines of text in the memo control.
|
|
/// </summary>
|
|
property Lines: TStrings read GetLines write SetLines;
|
|
property MaxLength;
|
|
property ReadOnly;
|
|
property ScrollBars: TScrollStyle read GetScrollStyle write SetScrollStyle default ssNone;
|
|
property TabStop;
|
|
/// <summary>
|
|
/// Specifies whether the label text wraps when it is too long for the
|
|
/// width of the label.
|
|
/// </summary>
|
|
property WordWrap: Boolean read GetWordWrap write SetWordWrap default True;
|
|
property OnChange;
|
|
property OnClick;
|
|
property OnDblClick;
|
|
property OnEnter;
|
|
property OnExit;
|
|
property OnKeyDown;
|
|
property OnKeyPress;
|
|
property OnKeyUp;
|
|
property OnMouseDown;
|
|
property OnMouseMove;
|
|
property OnMouseUp;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxButtonControl component represents a TButton adapter.
|
|
/// </summary>
|
|
TfrxButtonControl = class(TfrxDialogControl)
|
|
private
|
|
FButton: TButton;
|
|
function GetCancel: Boolean;
|
|
function GetDefault: Boolean;
|
|
function GetModalResult: TModalResult;
|
|
procedure SetCancel(const Value: Boolean);
|
|
procedure SetDefault(const Value: Boolean);
|
|
procedure SetModalResult(const Value: TModalResult);
|
|
{$IFDEF Delphi7}
|
|
function GetWordWrap: Boolean;
|
|
procedure SetWordWrap(const Value: Boolean);
|
|
{$ENDIF}
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
class function GetDescription: String; override;
|
|
/// <summary>
|
|
/// Reference to internal TButton object.
|
|
/// </summary>
|
|
property Button: TButton read FButton;
|
|
published
|
|
/// <summary>
|
|
/// Determines whether the button's OnClick event handler executes when
|
|
/// the Escape key is pressed.
|
|
/// </summary>
|
|
property Cancel: Boolean read GetCancel write SetCancel default False;
|
|
property Caption;
|
|
/// <summary>
|
|
/// Determines whether the button's OnClick event handler executes when
|
|
/// the Enter key is pressed.
|
|
/// </summary>
|
|
property Default: Boolean read GetDefault write SetDefault default False;
|
|
/// <summary>
|
|
/// Determines if and how the button closes its (modal) parent form.
|
|
/// </summary>
|
|
property ModalResult: TModalResult read GetModalResult write SetModalResult default mrNone;
|
|
{$IFDEF Delphi7}
|
|
/// <summary>
|
|
/// Specifies whether the label text wraps when it is too long for the
|
|
/// width of the label.
|
|
/// </summary>
|
|
property WordWrap: Boolean read GetWordWrap write SetWordWrap default False;
|
|
{$ENDIF}
|
|
property TabStop;
|
|
property OnClick;
|
|
property OnEnter;
|
|
property OnExit;
|
|
property OnKeyDown;
|
|
property OnKeyPress;
|
|
property OnKeyUp;
|
|
property OnMouseDown;
|
|
property OnMouseMove;
|
|
property OnMouseUp;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxCheckBoxControl component represents a TCheckBox adapter.
|
|
/// </summary>
|
|
TfrxCheckBoxControl = class(TfrxDialogControl)
|
|
private
|
|
FCheckBox: TCheckBox;
|
|
function GetAlignment: TAlignment;
|
|
function GetAllowGrayed: Boolean;
|
|
function GetChecked: Boolean;
|
|
function GetState: TCheckBoxState;
|
|
procedure SetAlignment(const Value: TAlignment);
|
|
procedure SetAllowGrayed(const Value: Boolean);
|
|
procedure SetChecked(const Value: Boolean);
|
|
procedure SetState(const Value: TCheckBoxState);
|
|
{$IFDEF Delphi7}
|
|
function GetWordWrap: Boolean;
|
|
procedure SetWordWrap(const Value: Boolean);
|
|
{$ENDIF}
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
class function GetDescription: String; override;
|
|
/// <summary>
|
|
/// Reference to internal TCheckBox object.
|
|
/// </summary>
|
|
property CheckBox: TCheckBox read FCheckBox;
|
|
published
|
|
/// <summary>
|
|
/// Controls the position of the check box's caption.
|
|
/// </summary>
|
|
property Alignment: TAlignment read GetAlignment write SetAlignment
|
|
default taRightJustify;
|
|
property Caption;
|
|
/// <summary>
|
|
/// Specifies lf the check box appears checked.
|
|
/// </summary>
|
|
property Checked: Boolean read GetChecked write SetChecked default False;
|
|
/// <summary>
|
|
/// Determines if the check box can be in a "grayed" state.
|
|
/// </summary>
|
|
property AllowGrayed: Boolean read GetAllowGrayed write SetAllowGrayed default False;
|
|
/// <summary>
|
|
/// Indicates if the check box is selected, deselected, or grayed.
|
|
/// </summary>
|
|
property State: TCheckBoxState read GetState write SetState default cbUnchecked;
|
|
property TabStop;
|
|
{$IFDEF Delphi7}
|
|
/// <summary>
|
|
/// Specifies if the label text wraps when it is too long for the width
|
|
/// of the label.
|
|
/// </summary>
|
|
property WordWrap: Boolean read GetWordWrap write SetWordWrap default False;
|
|
{$ENDIF}
|
|
property Color;
|
|
property OnClick;
|
|
property OnEnter;
|
|
property OnExit;
|
|
property OnKeyDown;
|
|
property OnKeyPress;
|
|
property OnKeyUp;
|
|
property OnMouseDown;
|
|
property OnMouseMove;
|
|
property OnMouseUp;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxRadioButtonControl component represents a TRadioButton adapter.
|
|
/// </summary>
|
|
TfrxRadioButtonControl = class(TfrxDialogControl)
|
|
private
|
|
FRadioButton: TRadioButton;
|
|
function GetAlignment: TAlignment;
|
|
function GetChecked: Boolean;
|
|
procedure SetAlignment(const Value: TAlignment);
|
|
procedure SetChecked(const Value: Boolean);
|
|
{$IFDEF Delphi7}
|
|
function GetWordWrap: Boolean;
|
|
procedure SetWordWrap(const Value: Boolean);
|
|
{$ENDIF}
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
class function GetDescription: String; override;
|
|
/// <summary>
|
|
/// Reference to internal TRadioButton object.
|
|
/// </summary>
|
|
property RadioButton: TRadioButton read FRadioButton;
|
|
published
|
|
/// <summary>
|
|
/// Controls the position of the radio button's caption.
|
|
/// </summary>
|
|
property Alignment: TAlignment read GetAlignment write SetAlignment
|
|
default taRightJustify;
|
|
property Caption;
|
|
/// <summary>
|
|
/// Determines if the option represented by the radio button is selected.
|
|
/// </summary>
|
|
property Checked: Boolean read GetChecked write SetChecked default False;
|
|
property TabStop;
|
|
{$IFDEF Delphi7}
|
|
/// <summary>
|
|
/// Specifies if the label text wraps when it is too long for the width
|
|
/// of the label.
|
|
/// </summary>
|
|
property WordWrap: Boolean read GetWordWrap write SetWordWrap default False;
|
|
{$ENDIF}
|
|
property Color;
|
|
property OnClick;
|
|
property OnDblClick;
|
|
property OnEnter;
|
|
property OnExit;
|
|
property OnKeyDown;
|
|
property OnKeyPress;
|
|
property OnKeyUp;
|
|
property OnMouseDown;
|
|
property OnMouseMove;
|
|
property OnMouseUp;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxListBoxControl component represents a TListBox adapter.
|
|
/// </summary>
|
|
TfrxListBoxControl = class(TfrxDialogControl)
|
|
private
|
|
FListBox: TListBox;
|
|
function GetItems: TStrings;
|
|
procedure SetItems(const Value: TStrings);
|
|
function GetItemIndex: Integer;
|
|
procedure SetItemIndex(const Value: Integer);
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
class function GetDescription: String; override;
|
|
/// <summary>
|
|
/// Reference to internal TListBox object.
|
|
/// </summary>
|
|
property ListBox: TListBox read FListBox;
|
|
property ItemIndex: Integer read GetItemIndex write SetItemIndex;
|
|
published
|
|
property Color;
|
|
/// <summary>
|
|
/// Contains the strings that appear in the list box.
|
|
/// </summary>
|
|
property Items: TStrings read GetItems write SetItems;
|
|
property TabStop;
|
|
property OnClick;
|
|
property OnDblClick;
|
|
property OnEnter;
|
|
property OnExit;
|
|
property OnKeyDown;
|
|
property OnKeyPress;
|
|
property OnKeyUp;
|
|
property OnMouseDown;
|
|
property OnMouseMove;
|
|
property OnMouseUp;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxComboBoxControl component represents a TComboBox adapter.
|
|
/// </summary>
|
|
TfrxComboBoxControl = class(TfrxDialogControl)
|
|
private
|
|
FComboBox: TComboBox;
|
|
FOnChange: TfrxNotifyEvent;
|
|
function GetItemIndex: Integer;
|
|
function GetItems: TStrings;
|
|
function GetStyle: TComboBoxStyle;
|
|
function GetText: String;
|
|
procedure DoOnChange(Sender: TObject);
|
|
procedure SetItemIndex(const Value: Integer);
|
|
procedure SetItems(const Value: TStrings);
|
|
procedure SetStyle(const Value: TComboBoxStyle);
|
|
procedure SetText(const Value: String);
|
|
protected
|
|
function GetCharCase: TEditCharCase; virtual;
|
|
procedure SetCharCase(const Value: TEditCharCase); virtual;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
class function GetDescription: String; override;
|
|
/// <summary>
|
|
/// Reference to internal TComboBox object.
|
|
/// </summary>
|
|
property ComboBox: TComboBox read FComboBox;
|
|
published
|
|
property CharCase: TEditCharCase read GetCharCase write SetCharCase default ecNormal;
|
|
property Color;
|
|
/// <summary>
|
|
/// Contains the strings that appear in the combo box.
|
|
/// </summary>
|
|
property Items: TStrings read GetItems write SetItems;
|
|
/// <summary>
|
|
/// Determines the display style of the combo box.
|
|
/// </summary>
|
|
property Style: TComboBoxStyle read GetStyle write SetStyle default csDropDown;
|
|
property TabStop;
|
|
property Text: String read GetText write SetText;
|
|
property ItemIndex: Integer read GetItemIndex write SetItemIndex;
|
|
/// <summary>
|
|
/// Name of the script procedure that will be executed when the user
|
|
/// changes the text displayed in the edit region.
|
|
/// </summary>
|
|
property OnChange: TfrxNotifyEvent read FOnChange write FOnChange;
|
|
property OnClick;
|
|
property OnDblClick;
|
|
property OnEnter;
|
|
property OnExit;
|
|
property OnKeyDown;
|
|
property OnKeyPress;
|
|
property OnKeyUp;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxPanelControl component represents a TPanel adapter.
|
|
/// </summary>
|
|
TfrxPanelControl = class(TfrxDialogControl)
|
|
private
|
|
FPanel: TPanel;
|
|
function GetAlignment: TAlignment;
|
|
function GetBevelInner: TPanelBevel;
|
|
function GetBevelOuter: TPanelBevel;
|
|
function GetBevelWidth: Integer;
|
|
procedure SetAlignment(const Value: TAlignment);
|
|
procedure SetBevelInner(const Value: TPanelBevel);
|
|
procedure SetBevelOuter(const Value: TPanelBevel);
|
|
procedure SetBevelWidth(const Value: Integer);
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
class function GetDescription: String; override;
|
|
/// <summary>
|
|
/// Reference to internal TPanel object.
|
|
/// </summary>
|
|
property Panel: TPanel read FPanel;
|
|
published
|
|
/// <summary>
|
|
/// Determines how caption is aligned within the panel.
|
|
/// </summary>
|
|
property Alignment: TAlignment read GetAlignment write SetAlignment default taCenter;
|
|
/// <summary>
|
|
/// Determines the style of the inner bevel of a panel.
|
|
/// </summary>
|
|
property BevelInner: TPanelBevel read GetBevelInner write SetBevelInner default bvNone;
|
|
/// <summary>
|
|
/// Determines the style of the outer bevel of a panel.
|
|
/// </summary>
|
|
property BevelOuter: TPanelBevel read GetBevelOuter write SetBevelOuter default bvRaised;
|
|
/// <summary>
|
|
/// Determines the width, in pixels, of both the inner and outer bevels
|
|
/// of a panel.
|
|
/// </summary>
|
|
property BevelWidth: Integer read GetBevelWidth write SetBevelWidth default 1;
|
|
property Caption;
|
|
property Color;
|
|
property OnClick;
|
|
property OnDblClick;
|
|
property OnEnter;
|
|
property OnExit;
|
|
property OnMouseDown;
|
|
property OnMouseMove;
|
|
property OnMouseUp;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxGroupBoxControl component represents a TGroupBox adapter.
|
|
/// </summary>
|
|
TfrxGroupBoxControl = class(TfrxDialogControl)
|
|
private
|
|
FGroupBox: TGroupBox;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
class function GetDescription: String; override;
|
|
procedure Draw(Canvas: TCanvas; ScaleX, ScaleY, OffsetX, OffsetY: Extended); override;
|
|
/// <summary>
|
|
/// Reference to internal TGroupBox object.
|
|
/// </summary>
|
|
property GroupBox: TGroupBox read FGroupBox;
|
|
published
|
|
property Caption;
|
|
property Color;
|
|
property OnClick;
|
|
property OnDblClick;
|
|
property OnEnter;
|
|
property OnExit;
|
|
property OnMouseDown;
|
|
property OnMouseMove;
|
|
property OnMouseUp;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxDateEditControl component represents a TDateTimePicker adapter.
|
|
/// </summary>
|
|
TfrxDateEditControl = class(TfrxDialogControl)
|
|
private
|
|
FDateEdit: TDateTimePicker;
|
|
FOnChange: TfrxNotifyEvent;
|
|
FWeekNumbers: Boolean;
|
|
function GetDate: TDate;
|
|
function GetTime: TTime;
|
|
function GetDateFormat: TDTDateFormat;
|
|
function GetKind: TDateTimeKind;
|
|
procedure DoOnChange(Sender: TObject);
|
|
procedure SetDate(const Value: TDate);
|
|
procedure SetTime(const Value: TTime);
|
|
procedure SetDateFormat(const Value: TDTDateFormat);
|
|
procedure SetKind(const Value: TDateTimeKind);
|
|
procedure DropDown(Sender: TObject);
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
class function GetDescription: String; override;
|
|
/// <summary>
|
|
/// Reference to internal TDateTimePicker object.
|
|
/// </summary>
|
|
property DateEdit: TDateTimePicker read FDateEdit;
|
|
published
|
|
property Color;
|
|
/// <summary>
|
|
/// Indicates the date that is marked on the calendar.
|
|
/// </summary>
|
|
property Date: TDate read GetDate write SetDate;
|
|
/// <summary>
|
|
/// Specifies format in which the date is presented.
|
|
/// </summary>
|
|
property DateFormat: TDTDateFormat read GetDateFormat write SetDateFormat
|
|
default dfShort;
|
|
property Kind: TDateTimeKind read GetKind write SetKind default dtkDate;
|
|
property TabStop;
|
|
property Time: TTime read GetTime write SetTime;
|
|
property WeekNumbers: Boolean read FWeekNumbers write FWeekNumbers;
|
|
/// <summary>
|
|
/// Name of the script procedure that will be executed when a date or
|
|
/// time is entered.
|
|
/// </summary>
|
|
property OnChange: TfrxNotifyEvent read FOnChange write FOnChange;
|
|
property OnClick;
|
|
property OnDblClick;
|
|
property OnEnter;
|
|
property OnExit;
|
|
property OnKeyDown;
|
|
property OnKeyPress;
|
|
property OnKeyUp;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxImageControl component represents a TImage adapter.
|
|
/// </summary>
|
|
TfrxImageControl = class(TfrxDialogControl)
|
|
private
|
|
FImage: TImage;
|
|
function GetAutoSize: Boolean;
|
|
function GetCenter: Boolean;
|
|
function GetPicture: TPicture;
|
|
function GetStretch: Boolean;
|
|
procedure SetAutoSize(const Value: Boolean);
|
|
procedure SetCenter(const Value: Boolean);
|
|
procedure SetPicture(const Value: TPicture);
|
|
procedure SetStretch(const Value: Boolean);
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
class function GetDescription: String; override;
|
|
/// <summary>
|
|
/// Reference to internal TImage object.
|
|
/// </summary>
|
|
property Image: TImage read FImage;
|
|
published
|
|
/// <summary>
|
|
/// Determines whether the image control resizes to accommodate the image
|
|
/// it displays.
|
|
/// </summary>
|
|
property AutoSize: Boolean read GetAutoSize write SetAutoSize default False;
|
|
/// <summary>
|
|
/// Indicates whether the image is centered in the image control.
|
|
/// </summary>
|
|
property Center: Boolean read GetCenter write SetCenter default False;
|
|
/// <summary>
|
|
/// Specifies the image that appears on the image control.
|
|
/// </summary>
|
|
property Picture: TPicture read GetPicture write SetPicture;
|
|
/// <summary>
|
|
/// Indicates whether the image should be changed so that it exactly fits
|
|
/// the bounds of the image control.
|
|
/// </summary>
|
|
property Stretch: Boolean read GetStretch write SetStretch default False;
|
|
property OnClick;
|
|
property OnDblClick;
|
|
property OnMouseDown;
|
|
property OnMouseMove;
|
|
property OnMouseUp;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxBevelControl component represents a TBevel adapter.
|
|
/// </summary>
|
|
TfrxBevelControl = class(TfrxDialogControl)
|
|
private
|
|
FBevel: TBevel;
|
|
function GetBevelShape: TBevelShape;
|
|
function GetBevelStyle: TBevelStyle;
|
|
procedure SetBevelShape(const Value: TBevelShape);
|
|
procedure SetBevelStyle(const Value: TBevelStyle);
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
class function GetDescription: String; override;
|
|
/// <summary>
|
|
/// Reference to internal TBevel object.
|
|
/// </summary>
|
|
property Bevel: TBevel read FBevel;
|
|
published
|
|
/// <summary>
|
|
/// Determines the shape of the bevel.
|
|
/// </summary>
|
|
property Shape: TBevelShape read GetBevelShape write SetBevelShape default bsBox;
|
|
/// <summary>
|
|
/// Determines whether the bevel appears raised or lowered.
|
|
/// </summary>
|
|
property Style: TBevelStyle read GetBevelStyle write SetBevelStyle default bsLowered;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxBitBtnControl component represents a TBitBtn adapter.
|
|
/// </summary>
|
|
TfrxBitBtnControl = class(TfrxDialogControl)
|
|
private
|
|
FBitBtn: TBitBtn;
|
|
function GetGlyph: TBitmap;
|
|
function GetKind: TBitBtnKind;
|
|
function GetLayout: TButtonLayout;
|
|
function GetMargin: Integer;
|
|
function GetModalResult: TModalResult;
|
|
function GetSpacing: Integer;
|
|
procedure SetGlyph(const Value: TBitmap);
|
|
procedure SetKind(const Value: TBitBtnKind);
|
|
procedure SetLayout(const Value: TButtonLayout);
|
|
procedure SetMargin(const Value: Integer);
|
|
procedure SetModalResult(const Value: TModalResult);
|
|
procedure SetSpacing(const Value: Integer);
|
|
function GetNumGlyphs: Integer;
|
|
procedure SetNumGlyphs(const Value: Integer);
|
|
{$IFDEF Delphi7}
|
|
function GetWordWrap: Boolean;
|
|
procedure SetWordWrap(const Value: Boolean);
|
|
{$ENDIF}
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
procedure Draw(Canvas: TCanvas; ScaleX, ScaleY, OffsetX, OffsetY: Extended); override;
|
|
class function GetDescription: String; override;
|
|
/// <summary>
|
|
/// Reference to internal TBitBtn object.
|
|
/// </summary>
|
|
property BitBtn: TBitBtn read FBitBtn;
|
|
published
|
|
/// <summary>
|
|
/// Specifies the bitmap that appears on the selected bitmap button.
|
|
/// </summary>
|
|
property Glyph: TBitmap read GetGlyph write SetGlyph;
|
|
/// <summary>
|
|
/// Determines the kind of bitmap button.
|
|
/// </summary>
|
|
property Kind: TBitBtnKind read GetKind write SetKind default bkCustom;
|
|
property Caption; // should be after Kind prop
|
|
/// <summary>
|
|
/// Determines where the image appears on the bitmap button.
|
|
/// </summary>
|
|
property Layout: TButtonLayout read GetLayout write SetLayout default blGlyphLeft;
|
|
/// <summary>
|
|
/// Determines the number of pixels between the edge of the image
|
|
/// (specified in the Glyph property) and the edge of the button.
|
|
/// </summary>
|
|
property Margin: Integer read GetMargin write SetMargin default -1;
|
|
/// <summary>
|
|
/// Determines if and how the button closes its (modal) parent form.
|
|
/// </summary>
|
|
property ModalResult: TModalResult read GetModalResult write SetModalResult default mrNone;
|
|
/// <summary>
|
|
/// Indicates the number of images that are in the graphic specified in
|
|
/// the Glyph property for use on a bitmap button or speed button.
|
|
/// </summary>
|
|
property NumGlyphs: Integer read GetNumGlyphs write SetNumGlyphs default 1;
|
|
/// <summary>
|
|
/// Determines where the image and text appear on a bitmap or speed
|
|
/// button.
|
|
/// </summary>
|
|
property Spacing: Integer read GetSpacing write SetSpacing default 4;
|
|
{$IFDEF Delphi7}
|
|
/// <summary>
|
|
/// Specifies whether the label text wraps when it is too long for the
|
|
/// width of the label.
|
|
/// </summary>
|
|
property WordWrap: Boolean read GetWordWrap write SetWordWrap default False;
|
|
{$ENDIF}
|
|
property TabStop;
|
|
property OnClick;
|
|
property OnEnter;
|
|
property OnExit;
|
|
property OnKeyDown;
|
|
property OnKeyPress;
|
|
property OnKeyUp;
|
|
property OnMouseDown;
|
|
property OnMouseMove;
|
|
property OnMouseUp;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxSpeedButtonControl component represents a TSpeedButton adapter.
|
|
/// </summary>
|
|
TfrxSpeedButtonControl = class(TfrxDialogControl)
|
|
private
|
|
FSpeedButton: TSpeedButton;
|
|
function GetAllowAllUp: Boolean;
|
|
function GetDown: Boolean;
|
|
function GetFlat: Boolean;
|
|
function GetGlyph: TBitmap;
|
|
function GetGroupIndex: Integer;
|
|
function GetLayout: TButtonLayout;
|
|
function GetMargin: Integer;
|
|
function GetSpacing: Integer;
|
|
procedure SetAllowAllUp(const Value: Boolean);
|
|
procedure SetDown(const Value: Boolean);
|
|
procedure SetFlat(const Value: Boolean);
|
|
procedure SetGlyph(const Value: TBitmap);
|
|
procedure SetGroupIndex(const Value: Integer);
|
|
procedure SetLayout(const Value: TButtonLayout);
|
|
procedure SetMargin(const Value: Integer);
|
|
procedure SetSpacing(const Value: Integer);
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
class function GetDescription: String; override;
|
|
/// <summary>
|
|
/// Reference to internal TSpeedButton object.
|
|
/// </summary>
|
|
property SpeedButton: TSpeedButton read FSpeedButton;
|
|
published
|
|
/// <summary>
|
|
/// Specifies if all speed buttons in the group that contains this speed
|
|
/// button can be unselected at the same time.
|
|
/// </summary>
|
|
property AllowAllUp: Boolean read GetAllowAllUp write SetAllowAllUp default False;
|
|
property Caption;
|
|
/// <summary>
|
|
/// Specifies if the button is selected (down) or unselected (up).
|
|
/// </summary>
|
|
property Down: Boolean read GetDown write SetDown default False;
|
|
/// <summary>
|
|
/// Determines if the button has a 3D border that provides a raised or
|
|
/// lowered look.
|
|
/// </summary>
|
|
property Flat: Boolean read GetFlat write SetFlat default False;
|
|
/// <summary>
|
|
/// Specifies the bitmap that appears on the speed button.
|
|
/// </summary>
|
|
property Glyph: TBitmap read GetGlyph write SetGlyph;
|
|
/// <summary>
|
|
/// Allows speed buttons to work together as a group.
|
|
/// </summary>
|
|
property GroupIndex: Integer read GetGroupIndex write SetGroupIndex;
|
|
/// <summary>
|
|
/// Determines where the image or text appears on the speed button.
|
|
/// </summary>
|
|
property Layout: TButtonLayout read GetLayout write SetLayout default blGlyphLeft;
|
|
/// <summary>
|
|
/// Specifies the number of pixels between the edge of the button and the
|
|
/// image or caption drawn on its surface.
|
|
/// </summary>
|
|
property Margin: Integer read GetMargin write SetMargin default -1;
|
|
/// <summary>
|
|
/// Determines where the image and text appear on a speed button
|
|
/// </summary>
|
|
property Spacing: Integer read GetSpacing write SetSpacing default 4;
|
|
property OnClick;
|
|
property OnDblClick;
|
|
property OnMouseDown;
|
|
property OnMouseMove;
|
|
property OnMouseUp;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxMaskEditControl component represents a TMaskEdit adapter.
|
|
/// </summary>
|
|
TfrxMaskEditControl = class(TfrxCustomEditControl)
|
|
private
|
|
FMaskEdit: TMaskEdit;
|
|
function GetEditMask: String;
|
|
procedure SetEditMask(const Value: String);
|
|
protected
|
|
function GetCharCase: TEditCharCase; override;
|
|
procedure SetCharCase(const Value: TEditCharCase); override;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
class function GetDescription: String; override;
|
|
/// <summary>
|
|
/// Reference to internal TMaskEdit object.
|
|
/// </summary>
|
|
property MaskEdit: TMaskEdit read FMaskEdit;
|
|
published
|
|
property CharCase;
|
|
property Color;
|
|
/// <summary>
|
|
/// Specifies the mask that represents what text is valid for the masked
|
|
/// edit control.
|
|
/// </summary>
|
|
property EditMask: String read GetEditMask write SetEditMask;
|
|
property MaxLength;
|
|
property ReadOnly;
|
|
property TabStop;
|
|
property Text;
|
|
property OnChange;
|
|
property OnClick;
|
|
property OnDblClick;
|
|
property OnEnter;
|
|
property OnExit;
|
|
property OnKeyDown;
|
|
property OnKeyPress;
|
|
property OnKeyUp;
|
|
property OnMouseDown;
|
|
property OnMouseMove;
|
|
property OnMouseUp;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// The TfrxCheckListBoxControl component represents a TCheckListBox
|
|
/// adapter.
|
|
/// </summary>
|
|
TfrxCheckListBoxControl = class(TfrxDialogControl)
|
|
private
|
|
FCheckListBox: TCheckListBox;
|
|
function GetAllowGrayed: Boolean;
|
|
function GetItems: TStrings;
|
|
function GetSorted: Boolean;
|
|
function GetChecked(Index: Integer): Boolean;
|
|
function GetState(Index: Integer): TCheckBoxState;
|
|
procedure SetAllowGrayed(const Value: Boolean);
|
|
procedure SetItems(const Value: TStrings);
|
|
procedure SetSorted(const Value: Boolean);
|
|
procedure SetChecked(Index: Integer; const Value: Boolean);
|
|
procedure SetState(Index: Integer; const Value: TCheckBoxState);
|
|
function GetItemIndex: Integer;
|
|
procedure SetItemIndex(const Value: Integer);
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
class function GetDescription: String; override;
|
|
/// <summary>
|
|
/// Reference to internal TCheckListBox object.
|
|
/// </summary>
|
|
property CheckListBox: TCheckListBox read FCheckListBox;
|
|
property Checked[Index: Integer]: Boolean read GetChecked write SetChecked;
|
|
property ItemIndex: Integer read GetItemIndex write SetItemIndex;
|
|
property State[Index: Integer]: TCheckBoxState read GetState write SetState;
|
|
published
|
|
/// <summary>
|
|
/// Determines if the check box can be in a "grayed" state.
|
|
/// </summary>
|
|
property AllowGrayed: Boolean read GetAllowGrayed write SetAllowGrayed default False;
|
|
property Color;
|
|
/// <summary>
|
|
/// Contains the strings that appear in the list box.
|
|
/// </summary>
|
|
property Items: TStrings read GetItems write SetItems;
|
|
/// <summary>
|
|
/// Specifies if the items in a list box are arranged alphabetically.
|
|
/// </summary>
|
|
property Sorted: Boolean read GetSorted write SetSorted default False;
|
|
property TabStop;
|
|
property OnClick;
|
|
property OnDblClick;
|
|
property OnEnter;
|
|
property OnExit;
|
|
property OnKeyDown;
|
|
property OnKeyPress;
|
|
property OnKeyUp;
|
|
property OnMouseDown;
|
|
property OnMouseMove;
|
|
property OnMouseUp;
|
|
end;
|
|
|
|
{$IFDEF FPC}
|
|
procedure Register;
|
|
{$ENDIF}
|
|
|
|
implementation
|
|
|
|
uses frxDCtrlRTTI, frxUtils, frxDsgnIntf, frxRes;
|
|
|
|
type
|
|
THackCustomEdit = class(TCustomEdit);
|
|
THackControl = class(TControl);
|
|
|
|
TfrxPageControlEditor = class(TfrxComponentEditor)
|
|
public
|
|
procedure GetMenuItems; override;
|
|
function Execute(Tag: Integer; Checked: Boolean): Boolean; override;
|
|
end;
|
|
|
|
{ TfrxLabelControl }
|
|
|
|
constructor TfrxLabelControl.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FLabel := TLabel.Create(nil);
|
|
InitControl(FLabel);
|
|
end;
|
|
|
|
class function TfrxLabelControl.GetDescription: String;
|
|
begin
|
|
Result := frxResources.Get('obLabel');
|
|
end;
|
|
|
|
procedure TfrxLabelControl.Draw(Canvas: TCanvas; ScaleX, ScaleY, OffsetX,
|
|
OffsetY: Extended);
|
|
begin
|
|
if FLabel.AutoSize then
|
|
begin
|
|
Width := FLabel.Width / ScaleX;
|
|
Height := FLabel.Height / ScaleY;
|
|
end
|
|
else
|
|
begin
|
|
FLabel.Width := Round(Width * ScaleX);
|
|
FLabel.Height := Round(Height * ScaleY);
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
function TfrxLabelControl.GetAlignment: TAlignment;
|
|
begin
|
|
Result := FLabel.Alignment;
|
|
end;
|
|
|
|
function TfrxLabelControl.GetAutoSize: Boolean;
|
|
begin
|
|
Result := FLabel.AutoSize;
|
|
end;
|
|
|
|
function TfrxLabelControl.GetWordWrap: Boolean;
|
|
begin
|
|
Result := FLabel.WordWrap;
|
|
end;
|
|
|
|
procedure TfrxLabelControl.SetAlignment(const Value: TAlignment);
|
|
begin
|
|
FLabel.Alignment := Value;
|
|
end;
|
|
|
|
procedure TfrxLabelControl.SetAutoSize(const Value: Boolean);
|
|
begin
|
|
FLabel.AutoSize := Value;
|
|
end;
|
|
|
|
procedure TfrxLabelControl.SetWordWrap(const Value: Boolean);
|
|
begin
|
|
FLabel.WordWrap := Value;
|
|
end;
|
|
|
|
procedure TfrxLabelControl.BeforeStartReport;
|
|
begin
|
|
if not FLabel.AutoSize then
|
|
begin
|
|
FLabel.Width := Round(Width);
|
|
FLabel.Height := Round(Height);
|
|
end;
|
|
end;
|
|
|
|
|
|
{ TfrxCustomEditControl }
|
|
|
|
constructor TfrxCustomEditControl.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
THackCustomEdit(FCustomEdit).OnChange := DoOnChange;
|
|
InitControl(FCustomEdit);
|
|
end;
|
|
|
|
function TfrxCustomEditControl.GetMaxLength: Integer;
|
|
begin
|
|
Result := THackCustomEdit(FCustomEdit).MaxLength;
|
|
end;
|
|
|
|
function TfrxCustomEditControl.GetPasswordChar: Char;
|
|
begin
|
|
Result := THackCustomEdit(FCustomEdit).PasswordChar;
|
|
end;
|
|
|
|
function TfrxCustomEditControl.GetReadOnly: Boolean;
|
|
begin
|
|
Result := THackCustomEdit(FCustomEdit).ReadOnly;
|
|
end;
|
|
|
|
function TfrxCustomEditControl.GetText: String;
|
|
begin
|
|
Result := THackCustomEdit(FCustomEdit).Text;
|
|
end;
|
|
|
|
procedure TfrxCustomEditControl.SetMaxLength(const Value: Integer);
|
|
begin
|
|
THackCustomEdit(FCustomEdit).MaxLength := Value;
|
|
end;
|
|
|
|
procedure TfrxCustomEditControl.SetPasswordChar(const Value: Char);
|
|
begin
|
|
THackCustomEdit(FCustomEdit).PasswordChar := Value;
|
|
end;
|
|
|
|
procedure TfrxCustomEditControl.SetReadOnly(const Value: Boolean);
|
|
begin
|
|
THackCustomEdit(FCustomEdit).ReadOnly := Value;
|
|
end;
|
|
|
|
procedure TfrxCustomEditControl.SetText(const Value: String);
|
|
begin
|
|
THackCustomEdit(FCustomEdit).Text := Value;
|
|
end;
|
|
|
|
procedure TfrxCustomEditControl.DoOnChange(Sender: TObject);
|
|
begin
|
|
if Report <> nil then
|
|
Report.DoNotifyEvent(Self, FOnChange, True);
|
|
end;
|
|
|
|
function TfrxCustomEditControl.GetCharCase: TEditCharCase;
|
|
begin
|
|
Result := ecNormal; //Modify on inherited classes
|
|
end;
|
|
|
|
procedure TfrxCustomEditControl.SetCharCase(const Value: TEditCharCase);
|
|
begin
|
|
//Modify on inherited classes
|
|
end;
|
|
|
|
{ TfrxEditControl }
|
|
|
|
constructor TfrxEditControl.Create(AOwner: TComponent);
|
|
begin
|
|
FEdit := TEdit.Create(nil);
|
|
FCustomEdit := FEdit;
|
|
inherited;
|
|
|
|
Width := 121;
|
|
Height := 21;
|
|
end;
|
|
|
|
class function TfrxEditControl.GetDescription: String;
|
|
begin
|
|
Result := frxResources.Get('obEdit');
|
|
end;
|
|
|
|
function TfrxEditControl.GetCharCase: TEditCharCase;
|
|
begin
|
|
Result := FEdit.CharCase;
|
|
end;
|
|
|
|
procedure TfrxEditControl.SetCharCase(const Value: TEditCharCase);
|
|
begin
|
|
FEdit.CharCase := Value;
|
|
end;
|
|
|
|
{ TfrxMemoControl }
|
|
|
|
constructor TfrxMemoControl.Create(AOwner: TComponent);
|
|
begin
|
|
FMemo := TMemo.Create(nil);
|
|
FCustomEdit := FMemo;
|
|
inherited;
|
|
|
|
Width := 185;
|
|
Height := 89;
|
|
end;
|
|
|
|
class function TfrxMemoControl.GetDescription: String;
|
|
begin
|
|
Result := frxResources.Get('obMemoC');
|
|
end;
|
|
|
|
function TfrxMemoControl.GetLines: TStrings;
|
|
begin
|
|
Result := FMemo.Lines;
|
|
end;
|
|
|
|
function TfrxMemoControl.GetScrollStyle: TScrollStyle;
|
|
begin
|
|
Result := FMemo.ScrollBars;
|
|
end;
|
|
|
|
function TfrxMemoControl.GetWordWrap: Boolean;
|
|
begin
|
|
Result := FMemo.WordWrap;
|
|
end;
|
|
|
|
procedure TfrxMemoControl.SetLines(const Value: TStrings);
|
|
begin
|
|
FMemo.Lines := Value;
|
|
end;
|
|
|
|
procedure TfrxMemoControl.SetScrollStyle(const Value: TScrollStyle);
|
|
begin
|
|
FMemo.ScrollBars := Value;
|
|
end;
|
|
|
|
procedure TfrxMemoControl.SetWordWrap(const Value: Boolean);
|
|
begin
|
|
FMemo.WordWrap := Value;
|
|
end;
|
|
|
|
function TfrxMemoControl.GetCharCase: TEditCharCase;
|
|
begin
|
|
Result := THackCustomEdit(FMemo).CharCase;
|
|
end;
|
|
|
|
procedure TfrxMemoControl.SetCharCase(const Value: TEditCharCase);
|
|
begin
|
|
THackCustomEdit(FMemo).CharCase := Value;
|
|
end;
|
|
|
|
{ TfrxButtonControl }
|
|
|
|
constructor TfrxButtonControl.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FButton := TButton.Create(nil);
|
|
InitControl(FButton);
|
|
|
|
Width := 75;
|
|
Height := 25;
|
|
end;
|
|
|
|
class function TfrxButtonControl.GetDescription: String;
|
|
begin
|
|
Result := frxResources.Get('obButton');
|
|
end;
|
|
|
|
function TfrxButtonControl.GetCancel: Boolean;
|
|
begin
|
|
Result := FButton.Cancel;
|
|
end;
|
|
|
|
function TfrxButtonControl.GetDefault: Boolean;
|
|
begin
|
|
Result := FButton.Default;
|
|
end;
|
|
|
|
function TfrxButtonControl.GetModalResult: TModalResult;
|
|
begin
|
|
Result := FButton.ModalResult;
|
|
end;
|
|
|
|
procedure TfrxButtonControl.SetCancel(const Value: Boolean);
|
|
begin
|
|
FButton.Cancel := Value;
|
|
end;
|
|
|
|
procedure TfrxButtonControl.SetDefault(const Value: Boolean);
|
|
begin
|
|
FButton.Default := Value;
|
|
end;
|
|
|
|
procedure TfrxButtonControl.SetModalResult(const Value: TModalResult);
|
|
begin
|
|
FButton.ModalResult := Value;
|
|
end;
|
|
|
|
{$IFDEF Delphi7}
|
|
function TfrxButtonControl.GetWordWrap: Boolean;
|
|
begin
|
|
Result := FButton.WordWrap;
|
|
end;
|
|
|
|
procedure TfrxButtonControl.SetWordWrap(const Value: Boolean);
|
|
begin
|
|
FButton.WordWrap := Value;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
{ TfrxCheckBoxControl }
|
|
|
|
constructor TfrxCheckBoxControl.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FCheckBox := TCheckBox.Create(nil);
|
|
InitControl(FCheckBox);
|
|
|
|
Width := 97;
|
|
Height := 17;
|
|
Alignment := taRightJustify;
|
|
end;
|
|
|
|
class function TfrxCheckBoxControl.GetDescription: String;
|
|
begin
|
|
Result := frxResources.Get('obChBoxC');
|
|
end;
|
|
|
|
function TfrxCheckBoxControl.GetAlignment: TAlignment;
|
|
begin
|
|
{$IFDEF FPC}
|
|
Result := taLeftJustify;
|
|
{$ELSE}
|
|
Result := FCheckBox.Alignment;
|
|
{$ENDIF}
|
|
end;
|
|
|
|
function TfrxCheckBoxControl.GetAllowGrayed: Boolean;
|
|
begin
|
|
Result := FCheckBox.AllowGrayed;
|
|
end;
|
|
|
|
function TfrxCheckBoxControl.GetChecked: Boolean;
|
|
begin
|
|
Result := FCheckBox.Checked;
|
|
end;
|
|
|
|
function TfrxCheckBoxControl.GetState: TCheckBoxState;
|
|
begin
|
|
Result := FCheckBox.State;
|
|
end;
|
|
|
|
procedure TfrxCheckBoxControl.SetAlignment(const Value: TAlignment);
|
|
begin
|
|
{$IFNDEF FPC}
|
|
FCheckBox.Alignment := Value;
|
|
{$ENDIF}
|
|
end;
|
|
|
|
procedure TfrxCheckBoxControl.SetAllowGrayed(const Value: Boolean);
|
|
begin
|
|
FCheckBox.AllowGrayed := Value;
|
|
end;
|
|
|
|
procedure TfrxCheckBoxControl.SetChecked(const Value: Boolean);
|
|
begin
|
|
FCheckBox.Checked := Value;
|
|
end;
|
|
|
|
procedure TfrxCheckBoxControl.SetState(const Value: TCheckBoxState);
|
|
begin
|
|
FCheckBox.State := Value;
|
|
end;
|
|
|
|
{$IFDEF Delphi7}
|
|
function TfrxCheckBoxControl.GetWordWrap: Boolean;
|
|
begin
|
|
Result := FCheckBox.WordWrap;
|
|
end;
|
|
|
|
procedure TfrxCheckBoxControl.SetWordWrap(const Value: Boolean);
|
|
begin
|
|
FCheckBox.WordWrap := Value;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
|
|
{ TfrxRadioButtonControl }
|
|
|
|
constructor TfrxRadioButtonControl.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FRadioButton := TRadioButton.Create(nil);
|
|
InitControl(FRadioButton);
|
|
|
|
Width := 113;
|
|
Height := 17;
|
|
Alignment := taRightJustify;
|
|
end;
|
|
|
|
class function TfrxRadioButtonControl.GetDescription: String;
|
|
begin
|
|
Result := frxResources.Get('obRButton');
|
|
end;
|
|
|
|
function TfrxRadioButtonControl.GetAlignment: TAlignment;
|
|
begin
|
|
{$IFDEF FPC}
|
|
Result := taLeftJustify;
|
|
{$ELSE}
|
|
Result := FRadioButton.Alignment;
|
|
{$ENDIF}
|
|
end;
|
|
|
|
function TfrxRadioButtonControl.GetChecked: Boolean;
|
|
begin
|
|
Result := FRadioButton.Checked;
|
|
end;
|
|
|
|
procedure TfrxRadioButtonControl.SetAlignment(const Value: TAlignment);
|
|
begin
|
|
{$IFNDEF FPC}
|
|
FRadioButton.Alignment := Value;
|
|
{$ENDIF}
|
|
end;
|
|
|
|
procedure TfrxRadioButtonControl.SetChecked(const Value: Boolean);
|
|
begin
|
|
FRadioButton.Checked := Value;
|
|
end;
|
|
|
|
{$IFDEF Delphi7}
|
|
function TfrxRadioButtonControl.GetWordWrap: Boolean;
|
|
begin
|
|
Result := FRadioButton.WordWrap;
|
|
end;
|
|
|
|
procedure TfrxRadioButtonControl.SetWordWrap(const Value: Boolean);
|
|
begin
|
|
FRadioButton.WordWrap := Value;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
|
|
{ TfrxListBoxControl }
|
|
|
|
constructor TfrxListBoxControl.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FListBox := TListBox.Create(nil);
|
|
InitControl(FListBox);
|
|
|
|
Width := 121;
|
|
Height := 97;
|
|
end;
|
|
|
|
class function TfrxListBoxControl.GetDescription: String;
|
|
begin
|
|
Result := frxResources.Get('obLBox');
|
|
end;
|
|
|
|
function TfrxListBoxControl.GetItems: TStrings;
|
|
begin
|
|
Result := FListBox.Items;
|
|
end;
|
|
|
|
function TfrxListBoxControl.GetItemIndex: Integer;
|
|
begin
|
|
Result := FListBox.ItemIndex;
|
|
end;
|
|
|
|
procedure TfrxListBoxControl.SetItems(const Value: TStrings);
|
|
begin
|
|
FListBox.Items := Value;
|
|
end;
|
|
|
|
procedure TfrxListBoxControl.SetItemIndex(const Value: Integer);
|
|
begin
|
|
FListBox.ItemIndex := Value;
|
|
end;
|
|
|
|
|
|
{ TfrxComboBoxControl }
|
|
|
|
constructor TfrxComboBoxControl.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FComboBox := TComboBox.Create(nil);
|
|
FComboBox.OnChange := DoOnChange;
|
|
InitControl(FComboBox);
|
|
|
|
Width := 145;
|
|
Height := 21;
|
|
end;
|
|
|
|
class function TfrxComboBoxControl.GetDescription: String;
|
|
begin
|
|
Result := frxResources.Get('obCBox');
|
|
end;
|
|
|
|
function TfrxComboBoxControl.GetItems: TStrings;
|
|
begin
|
|
Result := FComboBox.Items;
|
|
end;
|
|
|
|
function TfrxComboBoxControl.GetItemIndex: Integer;
|
|
begin
|
|
Result := FComboBox.ItemIndex;
|
|
end;
|
|
|
|
function TfrxComboBoxControl.GetStyle: TComboBoxStyle;
|
|
begin
|
|
Result := FComboBox.Style;
|
|
end;
|
|
|
|
function TfrxComboBoxControl.GetText: String;
|
|
begin
|
|
Result := FComboBox.Text;
|
|
end;
|
|
|
|
procedure TfrxComboBoxControl.SetItems(const Value: TStrings);
|
|
begin
|
|
FComboBox.Items := Value;
|
|
end;
|
|
|
|
procedure TfrxComboBoxControl.SetItemIndex(const Value: Integer);
|
|
begin
|
|
FComboBox.ItemIndex := Value;
|
|
end;
|
|
|
|
procedure TfrxComboBoxControl.SetStyle(const Value: TComboBoxStyle);
|
|
begin
|
|
FComboBox.Style := Value;
|
|
end;
|
|
|
|
procedure TfrxComboBoxControl.SetText(const Value: String);
|
|
begin
|
|
FComboBox.Text := Value;
|
|
end;
|
|
|
|
procedure TfrxComboBoxControl.DoOnChange(Sender: TObject);
|
|
begin
|
|
if Report <> nil then
|
|
Report.DoNotifyEvent(Self, FOnChange, True);
|
|
end;
|
|
|
|
function TfrxComboBoxControl.GetCharCase: TEditCharCase;
|
|
begin
|
|
Result := FComboBox.CharCase;
|
|
end;
|
|
|
|
procedure TfrxComboBoxControl.SetCharCase(const Value: TEditCharCase);
|
|
begin
|
|
FComboBox.CharCase := Value;
|
|
end;
|
|
|
|
{ TfrxDateEditControl }
|
|
|
|
constructor TfrxDateEditControl.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FDateEdit := TDateTimePicker.Create(nil);
|
|
FDateEdit.OnChange := DoOnChange;
|
|
{$IFNDEF FPC}
|
|
FDateEdit.OnDropDown := DropDown;
|
|
{$ENDIF}
|
|
InitControl(FDateEdit);
|
|
|
|
Width := 145;
|
|
Height := 21;
|
|
end;
|
|
|
|
class function TfrxDateEditControl.GetDescription: String;
|
|
begin
|
|
Result := frxResources.Get('obDateEdit');
|
|
end;
|
|
|
|
function TfrxDateEditControl.GetDate: TDate;
|
|
begin
|
|
Result := FDateEdit.Date;
|
|
end;
|
|
|
|
function TfrxDateEditControl.GetTime: TTime;
|
|
begin
|
|
Result := FDateEdit.Time;
|
|
end;
|
|
|
|
function TfrxDateEditControl.GetDateFormat: TDTDateFormat;
|
|
begin
|
|
Result := FDateEdit.DateFormat;
|
|
end;
|
|
|
|
function TfrxDateEditControl.GetKind: TDateTimeKind;
|
|
begin
|
|
Result := FDateEdit.Kind;
|
|
end;
|
|
|
|
procedure TfrxDateEditControl.SetDate(const Value: TDate);
|
|
begin
|
|
FDateEdit.Date := Value;
|
|
end;
|
|
|
|
procedure TfrxDateEditControl.SetTime(const Value: TTime);
|
|
begin
|
|
FDateEdit.Time := Value;
|
|
end;
|
|
|
|
procedure TfrxDateEditControl.SetDateFormat(const Value: TDTDateFormat);
|
|
begin
|
|
FDateEdit.DateFormat := Value;
|
|
end;
|
|
|
|
procedure TfrxDateEditControl.SetKind(const Value: TDateTimeKind);
|
|
begin
|
|
FDateEdit.Kind := Value;
|
|
end;
|
|
|
|
procedure TfrxDateEditControl.DoOnChange(Sender: TObject);
|
|
begin
|
|
if Report <> nil then
|
|
Report.DoNotifyEvent(Self, FOnChange, True);
|
|
end;
|
|
|
|
procedure TfrxDateEditControl.DropDown(Sender: TObject);
|
|
{$IFNDEF FPC}
|
|
var
|
|
CalHandle: HWND;
|
|
CalStyle: Cardinal;
|
|
CalRect: TRect;
|
|
CalMaxWidth: Integer;
|
|
ClassName: array[0..256] of Char;
|
|
{$ENDIF}
|
|
begin
|
|
if not FWeekNumbers then Exit;
|
|
{$IFNDEF FPC}
|
|
CalHandle := SendMessage(FDateEdit.Handle, DTM_GETMONTHCAL, 0, 0);
|
|
CalStyle := GetWindowLong (CalHandle, GWL_STYLE);
|
|
SetWindowLong(CalHandle, GWL_STYLE, CalStyle or MCS_WEEKNUMBERS);
|
|
FillChar(CalRect, SizeOf (TRect), 0);
|
|
SendMessage(CalHandle, MCM_GETMINREQRECT, 0, frxInteger(@CalRect));
|
|
CalMaxWidth := SendMessage(CalHandle, MCM_GETMAXTODAYWIDTH, 0, 0);
|
|
if CalMaxWidth > CalRect.Right then
|
|
CalRect.Right := CalMaxWidth;
|
|
GetClassName(GetParent(CalHandle), ClassName, sizeof(ClassName));
|
|
if AnsiSameText(ClassName, 'DropDown') then
|
|
SetWindowPos(GetParent(CalHandle), 0, 0, 0, CalRect.Right + 6, CalRect.Bottom + 6, SWP_NOACTIVATE or SWP_NOMOVE or SWP_NOZORDER)
|
|
else
|
|
SetWindowPos(CalHandle, 0, 0, 0, CalRect.Right, CalRect.Bottom, SWP_NOACTIVATE or SWP_NOMOVE or SWP_NOZORDER);
|
|
{$ENDIF}
|
|
end;
|
|
|
|
{ TfrxImageControl }
|
|
|
|
constructor TfrxImageControl.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FImage := TImage.Create(nil);
|
|
InitControl(FImage);
|
|
|
|
Width := 100;
|
|
Height := 100;
|
|
end;
|
|
|
|
class function TfrxImageControl.GetDescription: String;
|
|
begin
|
|
Result := frxResources.Get('obImageC');
|
|
end;
|
|
|
|
function TfrxImageControl.GetAutoSize: Boolean;
|
|
begin
|
|
Result := FImage.AutoSize;
|
|
end;
|
|
|
|
function TfrxImageControl.GetCenter: Boolean;
|
|
begin
|
|
Result := FImage.Center;
|
|
end;
|
|
|
|
function TfrxImageControl.GetPicture: TPicture;
|
|
begin
|
|
Result := FImage.Picture;
|
|
end;
|
|
|
|
function TfrxImageControl.GetStretch: Boolean;
|
|
begin
|
|
Result := FImage.Stretch;
|
|
end;
|
|
|
|
procedure TfrxImageControl.SetAutoSize(const Value: Boolean);
|
|
begin
|
|
FImage.AutoSize := Value;
|
|
end;
|
|
|
|
procedure TfrxImageControl.SetCenter(const Value: Boolean);
|
|
begin
|
|
FImage.Center := Value;
|
|
end;
|
|
|
|
procedure TfrxImageControl.SetPicture(const Value: TPicture);
|
|
begin
|
|
FImage.Picture.Assign(Value);
|
|
end;
|
|
|
|
procedure TfrxImageControl.SetStretch(const Value: Boolean);
|
|
begin
|
|
FImage.Stretch := Value;
|
|
end;
|
|
|
|
|
|
{ TfrxBevelControl }
|
|
|
|
constructor TfrxBevelControl.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FBevel := TBevel.Create(nil);
|
|
InitControl(FBevel);
|
|
|
|
Width := 50;
|
|
Height := 50;
|
|
end;
|
|
|
|
class function TfrxBevelControl.GetDescription: String;
|
|
begin
|
|
Result := frxResources.Get('obBevel');
|
|
end;
|
|
|
|
function TfrxBevelControl.GetBevelShape: TBevelShape;
|
|
begin
|
|
Result := FBevel.Shape;
|
|
end;
|
|
|
|
function TfrxBevelControl.GetBevelStyle: TBevelStyle;
|
|
begin
|
|
Result := FBevel.Style;
|
|
end;
|
|
|
|
procedure TfrxBevelControl.SetBevelShape(const Value: TBevelShape);
|
|
begin
|
|
FBevel.Shape := Value;
|
|
end;
|
|
|
|
procedure TfrxBevelControl.SetBevelStyle(const Value: TBevelStyle);
|
|
begin
|
|
FBevel.Style := Value;
|
|
end;
|
|
|
|
|
|
{ TfrxPanelControl }
|
|
|
|
constructor TfrxPanelControl.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FPanel := TPanel.Create(nil);
|
|
InitControl(FPanel);
|
|
{$IFDEF Delphi9}
|
|
FPanel.ParentColor := False;
|
|
FPanel.ParentBackground := False;
|
|
{$ENDIF}
|
|
Width := 185;
|
|
Height := 41;
|
|
frComponentStyle := frComponentStyle + [csAcceptsFrxComponents];
|
|
end;
|
|
|
|
class function TfrxPanelControl.GetDescription: String;
|
|
begin
|
|
Result := frxResources.Get('obPanel');
|
|
end;
|
|
|
|
function TfrxPanelControl.GetAlignment: TAlignment;
|
|
begin
|
|
Result := FPanel.Alignment;
|
|
end;
|
|
|
|
function TfrxPanelControl.GetBevelInner: TPanelBevel;
|
|
begin
|
|
Result := FPanel.BevelInner;
|
|
end;
|
|
|
|
function TfrxPanelControl.GetBevelOuter: TPanelBevel;
|
|
begin
|
|
Result := FPanel.BevelOuter;
|
|
end;
|
|
|
|
function TfrxPanelControl.GetBevelWidth: Integer;
|
|
begin
|
|
Result := FPanel.BevelWidth;
|
|
end;
|
|
|
|
procedure TfrxPanelControl.SetAlignment(const Value: TAlignment);
|
|
begin
|
|
FPanel.Alignment := Value;
|
|
end;
|
|
|
|
procedure TfrxPanelControl.SetBevelInner(const Value: TPanelBevel);
|
|
begin
|
|
FPanel.BevelInner := Value;
|
|
end;
|
|
|
|
procedure TfrxPanelControl.SetBevelOuter(const Value: TPanelBevel);
|
|
begin
|
|
FPanel.BevelOuter := Value;
|
|
end;
|
|
|
|
procedure TfrxPanelControl.SetBevelWidth(const Value: Integer);
|
|
begin
|
|
FPanel.BevelWidth := Value;
|
|
end;
|
|
|
|
|
|
{ TfrxGroupBoxControl }
|
|
|
|
constructor TfrxGroupBoxControl.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FGroupBox := TGroupBox.Create(nil);
|
|
InitControl(FGroupBox);
|
|
|
|
Width := 185;
|
|
Height := 105;
|
|
frComponentStyle := frComponentStyle + [csAcceptsFrxComponents];
|
|
end;
|
|
|
|
class function TfrxGroupBoxControl.GetDescription: String;
|
|
begin
|
|
Result := frxResources.Get('obGrBox');
|
|
end;
|
|
|
|
procedure TfrxGroupBoxControl.Draw(Canvas: TCanvas; ScaleX, ScaleY, OffsetX,
|
|
OffsetY: Extended);
|
|
{$IFDEF LCLGTK2}
|
|
var
|
|
Bmp: TBitmap;
|
|
pt: TPoint;
|
|
h: Integer;
|
|
{$ENDIF}
|
|
begin
|
|
{$IFDEF LCLGTK2}
|
|
pt := Point(0, 0);
|
|
if Assigned(Control.Parent) then
|
|
begin
|
|
pt := Control.ClientToParent(Point(0, 0), Control.Parent);
|
|
pt.x := pt.x - Control.Left;
|
|
pt.y := pt.y - Control.Top;
|
|
end;
|
|
|
|
Bmp := TBitmap.Create;
|
|
Bmp.Width := Round(Width * ScaleX);
|
|
Bmp.Height := Round(Height * ScaleX);
|
|
Bmp.Canvas.Lock;
|
|
try
|
|
Bmp.Canvas.Font := Control.Font;
|
|
h := -Bmp.Canvas.Font.Height + 4;
|
|
Bmp.Canvas.Brush.Color := Color;
|
|
Bmp.Canvas.FillRect(Rect(0, 0, Bmp.Width + 1, Bmp.Height + 1));
|
|
Bmp.Canvas.Brush.Color := Color;
|
|
Bmp.Canvas.Pen.Color := clMenuText;
|
|
Bmp.Canvas.Pen.Width := 1;
|
|
Bmp.Canvas.RoundRect(1, h div 2 + 1, Bmp.Width - 1, Bmp.Height - 1, 4, 4);
|
|
Bmp.Canvas.TextOut(6, 0, Control.Caption);
|
|
finally
|
|
Bmp.Canvas.Unlock;
|
|
end;
|
|
Canvas.Draw(Round(AbsLeft * ScaleX), Round(AbsTop * ScaleY), Bmp);
|
|
Bmp.Free;
|
|
{$ELSE}
|
|
inherited Draw(Canvas, ScaleX, ScaleY, OffsetX, OffsetY);
|
|
{$ENDIF}
|
|
end;
|
|
|
|
|
|
{ TfrxBitBtnControl }
|
|
|
|
constructor TfrxBitBtnControl.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FBitBtn := TBitBtn.Create(nil);
|
|
InitControl(FBitBtn);
|
|
|
|
Width := 75;
|
|
Height := 25;
|
|
end;
|
|
|
|
{$IFDEF FPC}
|
|
type
|
|
THackCustomBitBtn = class(TCustomBitBtn);
|
|
{$ENDIF}
|
|
procedure TfrxBitBtnControl.Draw(Canvas: TCanvas; ScaleX, ScaleY, OffsetX,
|
|
OffsetY: Extended);
|
|
begin
|
|
{$IFDEF FPC}
|
|
if Assigned(THackCustomBitBtn(FBitBtn).FButtonGlyph) and
|
|
not THackCustomBitBtn(FBitBtn).FButtonGlyph.IsDesigning then
|
|
begin
|
|
THackCustomBitBtn(FBitBtn).FButtonGlyph.IsDesigning := IsDesigning;
|
|
THackCustomBitBtn(FBitBtn).GlyphChanged(FBitBtn);
|
|
end;
|
|
{$ENDIF}
|
|
inherited Draw(Canvas, ScaleX, ScaleY, OffsetX, OffsetY);
|
|
end;
|
|
|
|
class function TfrxBitBtnControl.GetDescription: String;
|
|
begin
|
|
Result := frxResources.Get('obBBtn');
|
|
end;
|
|
|
|
function TfrxBitBtnControl.GetGlyph: TBitmap;
|
|
begin
|
|
Result := FBitBtn.Glyph;
|
|
end;
|
|
|
|
function TfrxBitBtnControl.GetKind: TBitBtnKind;
|
|
begin
|
|
Result := FBitBtn.Kind;
|
|
end;
|
|
|
|
function TfrxBitBtnControl.GetLayout: TButtonLayout;
|
|
begin
|
|
Result := FBitBtn.Layout;
|
|
end;
|
|
|
|
function TfrxBitBtnControl.GetMargin: Integer;
|
|
begin
|
|
Result := FBitBtn.Margin;
|
|
end;
|
|
|
|
function TfrxBitBtnControl.GetModalResult: TModalResult;
|
|
begin
|
|
Result := FBitBtn.ModalResult;
|
|
end;
|
|
|
|
function TfrxBitBtnControl.GetNumGlyphs: Integer;
|
|
begin
|
|
Result := FBitBtn.NumGlyphs;
|
|
end;
|
|
|
|
function TfrxBitBtnControl.GetSpacing: Integer;
|
|
begin
|
|
Result := FBitBtn.Spacing;
|
|
end;
|
|
|
|
{$IFDEF Delphi7}
|
|
function TfrxBitBtnControl.GetWordWrap: Boolean;
|
|
begin
|
|
Result := FBitBtn.WordWrap;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
procedure TfrxBitBtnControl.SetGlyph(const Value: TBitmap);
|
|
begin
|
|
FBitBtn.Glyph := Value;
|
|
end;
|
|
|
|
procedure TfrxBitBtnControl.SetKind(const Value: TBitBtnKind);
|
|
begin
|
|
FBitBtn.Kind := Value;
|
|
end;
|
|
|
|
procedure TfrxBitBtnControl.SetLayout(const Value: TButtonLayout);
|
|
begin
|
|
FBitBtn.Layout := Value;
|
|
end;
|
|
|
|
procedure TfrxBitBtnControl.SetMargin(const Value: Integer);
|
|
begin
|
|
FBitBtn.Margin := Value;
|
|
end;
|
|
|
|
procedure TfrxBitBtnControl.SetModalResult(const Value: TModalResult);
|
|
begin
|
|
FBitBtn.ModalResult := Value;
|
|
end;
|
|
|
|
procedure TfrxBitBtnControl.SetNumGlyphs(const Value: Integer);
|
|
begin
|
|
FBitBtn.NumGlyphs := Value;
|
|
end;
|
|
|
|
procedure TfrxBitBtnControl.SetSpacing(const Value: Integer);
|
|
begin
|
|
FBitBtn.Spacing := Value;
|
|
end;
|
|
|
|
{$IFDEF Delphi7}
|
|
procedure TfrxBitBtnControl.SetWordWrap(const Value: Boolean);
|
|
begin
|
|
FBitBtn.WordWrap := Value;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
{ TfrxSpeedButtonControl }
|
|
|
|
constructor TfrxSpeedButtonControl.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FSpeedButton := TSpeedButton.Create(nil);
|
|
InitControl(FSpeedButton);
|
|
|
|
Width := 22;
|
|
Height := 22;
|
|
end;
|
|
|
|
class function TfrxSpeedButtonControl.GetDescription: String;
|
|
begin
|
|
Result := frxResources.Get('obSBtn');
|
|
end;
|
|
|
|
function TfrxSpeedButtonControl.GetAllowAllUp: Boolean;
|
|
begin
|
|
Result := FSpeedButton.AllowAllUp;
|
|
end;
|
|
|
|
function TfrxSpeedButtonControl.GetDown: Boolean;
|
|
begin
|
|
Result := FSpeedButton.Down;
|
|
end;
|
|
|
|
function TfrxSpeedButtonControl.GetFlat: Boolean;
|
|
begin
|
|
Result := FSpeedButton.Flat;
|
|
end;
|
|
|
|
function TfrxSpeedButtonControl.GetGlyph: TBitmap;
|
|
begin
|
|
Result := FSpeedButton.Glyph;
|
|
end;
|
|
|
|
function TfrxSpeedButtonControl.GetGroupIndex: Integer;
|
|
begin
|
|
Result := FSpeedButton.GroupIndex;
|
|
end;
|
|
|
|
function TfrxSpeedButtonControl.GetLayout: TButtonLayout;
|
|
begin
|
|
Result := FSpeedButton.Layout;
|
|
end;
|
|
|
|
function TfrxSpeedButtonControl.GetMargin: Integer;
|
|
begin
|
|
Result := FSpeedButton.Margin;
|
|
end;
|
|
|
|
function TfrxSpeedButtonControl.GetSpacing: Integer;
|
|
begin
|
|
Result := FSpeedButton.Spacing;
|
|
end;
|
|
|
|
procedure TfrxSpeedButtonControl.SetAllowAllUp(const Value: Boolean);
|
|
begin
|
|
FSpeedButton.AllowAllUp := Value;
|
|
end;
|
|
|
|
procedure TfrxSpeedButtonControl.SetDown(const Value: Boolean);
|
|
begin
|
|
FSpeedButton.Down := Value;
|
|
end;
|
|
|
|
procedure TfrxSpeedButtonControl.SetFlat(const Value: Boolean);
|
|
begin
|
|
FSpeedButton.Flat := Value;
|
|
end;
|
|
|
|
procedure TfrxSpeedButtonControl.SetGlyph(const Value: TBitmap);
|
|
begin
|
|
FSpeedButton.Glyph := Value;
|
|
end;
|
|
|
|
procedure TfrxSpeedButtonControl.SetGroupIndex(const Value: Integer);
|
|
begin
|
|
FSpeedButton.GroupIndex := Value;
|
|
end;
|
|
|
|
procedure TfrxSpeedButtonControl.SetLayout(const Value: TButtonLayout);
|
|
begin
|
|
FSpeedButton.Layout := Value;
|
|
end;
|
|
|
|
procedure TfrxSpeedButtonControl.SetMargin(const Value: Integer);
|
|
begin
|
|
FSpeedButton.Margin := Value;
|
|
end;
|
|
|
|
procedure TfrxSpeedButtonControl.SetSpacing(const Value: Integer);
|
|
begin
|
|
FSpeedButton.Spacing := Value;
|
|
end;
|
|
|
|
|
|
{ TfrxMaskEditControl }
|
|
|
|
constructor TfrxMaskEditControl.Create(AOwner: TComponent);
|
|
begin
|
|
FMaskEdit := TMaskEdit.Create(nil);
|
|
FCustomEdit := FMaskEdit;
|
|
inherited;
|
|
|
|
Width := 121;
|
|
Height := 21;
|
|
end;
|
|
|
|
class function TfrxMaskEditControl.GetDescription: String;
|
|
begin
|
|
Result := frxResources.Get('obMEdit');
|
|
end;
|
|
|
|
function TfrxMaskEditControl.GetEditMask: String;
|
|
begin
|
|
Result := FMaskEdit.EditMask;
|
|
end;
|
|
|
|
procedure TfrxMaskEditControl.SetEditMask(const Value: String);
|
|
begin
|
|
FMaskEdit.EditMask := Value;
|
|
end;
|
|
|
|
function TfrxMaskEditControl.GetCharCase: TEditCharCase;
|
|
begin
|
|
Result := FMaskEdit.CharCase;
|
|
end;
|
|
|
|
procedure TfrxMaskEditControl.SetCharCase(const Value: TEditCharCase);
|
|
begin
|
|
FMaskEdit.CharCase := Value;
|
|
end;
|
|
|
|
{ TfrxCheckListBoxControl }
|
|
|
|
constructor TfrxCheckListBoxControl.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FCheckListBox := TCheckListBox.Create(nil);
|
|
InitControl(FCheckListBox);
|
|
|
|
Width := 121;
|
|
Height := 97;
|
|
end;
|
|
|
|
class function TfrxCheckListBoxControl.GetDescription: String;
|
|
begin
|
|
Result := frxResources.Get('obChLB');
|
|
end;
|
|
|
|
function TfrxCheckListBoxControl.GetAllowGrayed: Boolean;
|
|
begin
|
|
Result := FCheckListBox.AllowGrayed;
|
|
end;
|
|
|
|
function TfrxCheckListBoxControl.GetItems: TStrings;
|
|
begin
|
|
Result := FCheckListBox.Items;
|
|
end;
|
|
|
|
function TfrxCheckListBoxControl.GetSorted: Boolean;
|
|
begin
|
|
Result := FCheckListBox.Sorted;
|
|
end;
|
|
|
|
function TfrxCheckListBoxControl.GetChecked(Index: Integer): Boolean;
|
|
begin
|
|
Result := FCheckListBox.Checked[Index];
|
|
end;
|
|
|
|
function TfrxCheckListBoxControl.GetState(Index: Integer): TCheckBoxState;
|
|
begin
|
|
Result := FCheckListBox.State[Index];
|
|
end;
|
|
|
|
procedure TfrxCheckListBoxControl.SetAllowGrayed(const Value: Boolean);
|
|
begin
|
|
FCheckListBox.AllowGrayed := Value;
|
|
end;
|
|
|
|
procedure TfrxCheckListBoxControl.SetItems(const Value: TStrings);
|
|
begin
|
|
FCheckListBox.Items := Value;
|
|
end;
|
|
|
|
procedure TfrxCheckListBoxControl.SetSorted(const Value: Boolean);
|
|
begin
|
|
FCheckListBox.Sorted := Value;
|
|
end;
|
|
|
|
procedure TfrxCheckListBoxControl.SetChecked(Index: Integer; const Value: Boolean);
|
|
begin
|
|
FCheckListBox.Checked[Index] := Value;
|
|
end;
|
|
|
|
procedure TfrxCheckListBoxControl.SetState(Index: Integer; const Value: TCheckBoxState);
|
|
begin
|
|
FCheckListBox.State[Index] := Value;
|
|
end;
|
|
|
|
function TfrxCheckListBoxControl.GetItemIndex: Integer;
|
|
begin
|
|
Result := FCheckListBox.ItemIndex;
|
|
end;
|
|
|
|
procedure TfrxCheckListBoxControl.SetItemIndex(const Value: Integer);
|
|
begin
|
|
FCheckListBox.ItemIndex := Value;
|
|
end;
|
|
|
|
|
|
{$IFDEF FPC}
|
|
procedure RegisterUnitfrxDCtrl;
|
|
begin
|
|
RegisterComponents('Fast Report 6',[TfrxDialogControls]);
|
|
end;
|
|
|
|
procedure Register;
|
|
begin
|
|
RegisterUnit('frxDCtrl',@RegisterUnitfrxDCtrl);
|
|
end;
|
|
{$ENDIF}
|
|
|
|
{ TfrxPageControl }
|
|
|
|
constructor TfrxPageControl.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FPageControl := TPageControl.Create(nil);
|
|
InitControl(FPageControl);
|
|
FPageControl.OnChange := DoOnChange;
|
|
FPageControl.OnChanging := DoOnChanging;
|
|
frComponentStyle := frComponentStyle - [csAcceptsFrxComponents] + [csObjectsContainer];
|
|
FPageControl.SetSubComponent(True);
|
|
FBaseName := FBaseName + 'Control';
|
|
Width := 185;
|
|
Height := 105;
|
|
end;
|
|
|
|
procedure TfrxPageControl.Draw(Canvas: TCanvas; ScaleX, ScaleY, OffsetX,
|
|
OffsetY: Extended);
|
|
begin
|
|
{$IFDEF FPC}
|
|
UpdateSize;
|
|
{$ENDIF}
|
|
inherited Draw(Canvas, ScaleX, ScaleY, OffsetX, OffsetY);
|
|
end;
|
|
|
|
function TfrxPageControl.DoMouseDown(X, Y: Integer; Button: TMouseButton;
|
|
Shift: TShiftState; var EventParams: TfrxInteractiveEventsParams): Boolean;
|
|
begin
|
|
Result := False;
|
|
if FPageControl = nil then Exit;
|
|
{ send message to the control window }
|
|
SendMessage(FPageControl.Handle, {$IFNDEF FPC}WM_LBUTTONDOWN{$ELSE}LM_LBUTTONDOWN{$ENDIF}, MK_LBUTTON, MakeLong(X - Round(AbsLeft), Y - round(AbsTop)));
|
|
SendMessage(FPageControl.Handle, {$IFNDEF FPC}WM_LBUTTONUP{$ELSE}LM_LBUTTONUP{$ENDIF}, MK_LBUTTON, MakeLong(X - Round(AbsLeft), Y - round(AbsTop)));
|
|
EventParams.Refresh := True;
|
|
end;
|
|
|
|
procedure TfrxPageControl.DoOnChange(Sender: TObject);
|
|
{$IFDEF LCLGTK2}
|
|
var
|
|
i: Integer;
|
|
c, cc: TfrxComponent;
|
|
{$ENDIF}
|
|
begin
|
|
if Report <> nil then
|
|
Report.DoNotifyEvent(Self, FOnChange, True);
|
|
// correct invisible widgets bound
|
|
{$IFDEF LCLGTK2}
|
|
c := nil;
|
|
for i := 0 to Objects.Count - 1 do
|
|
if TObject(Objects[i]) is TfrxTabSheet then
|
|
if TfrxTabSheet(Objects[i]).FTabSheet = FPageControl.ActivePage then
|
|
c := TfrxComponent(Objects[i]);
|
|
if Assigned(c) then
|
|
for i := 0 to c.AllObjects.Count - 1 do
|
|
begin
|
|
cc := TfrxComponent(c.AllObjects[i]);
|
|
cc.SetBounds(cc.Left, cc.Top, cc.Width, cc.Height);
|
|
end;
|
|
{$ENDIF}
|
|
end;
|
|
|
|
procedure TfrxPageControl.DoOnChanging(Sender: TObject; var AllowChange: Boolean);
|
|
var
|
|
arr: Variant;
|
|
begin
|
|
if FOnChanging <> '' then
|
|
begin
|
|
arr := VarArrayOf([frxInteger(Sender), AllowChange]);
|
|
if Report <> nil then
|
|
Report.DoParamEvent(FOnChanging, arr, True);
|
|
AllowChange := arr[1];
|
|
end;
|
|
end;
|
|
|
|
{$IFNDEF FPC}
|
|
function TfrxPageControl.GetHotTrack: Boolean;
|
|
begin
|
|
Result := FPageControl.HotTrack;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function TfrxPageControl.GetMultiLine: Boolean;
|
|
begin
|
|
Result := FPageControl.MultiLine;
|
|
end;
|
|
|
|
function TfrxPageControl.GetPageCount: Integer;
|
|
begin
|
|
Result := FPageControl.PageCount;
|
|
end;
|
|
|
|
{$IFNDEF FPC}
|
|
function TfrxPageControl.GetRaggedRight: Boolean;
|
|
begin
|
|
Result := FPageControl.RaggedRight;
|
|
end;
|
|
|
|
function TfrxPageControl.GetScrollOpposite: Boolean;
|
|
begin
|
|
Result := FPageControl.ScrollOpposite;
|
|
end;
|
|
|
|
function TfrxPageControl.GetStyle: TTabStyle;
|
|
begin
|
|
Result := FPageControl.Style;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function TfrxPageControl.GetTabHeight: Smallint;
|
|
begin
|
|
Result := FPageControl.TabHeight;
|
|
end;
|
|
|
|
function TfrxPageControl.GetTabIndex: Integer;
|
|
begin
|
|
Result := FPageControl.TabIndex;
|
|
end;
|
|
|
|
function TfrxPageControl.GetTabOrder: Integer;
|
|
begin
|
|
Result := FPageControl.TabOrder;
|
|
end;
|
|
|
|
function TfrxPageControl.GetTabPosition: TTabPosition;
|
|
begin
|
|
Result := FPageControl.TabPosition;
|
|
end;
|
|
|
|
function TfrxPageControl.GetTabWidth: Smallint;
|
|
begin
|
|
Result := FPageControl.TabWidth;
|
|
end;
|
|
|
|
function TfrxPageControl.IsAcceptControl(aControl: TfrxComponent): Boolean;
|
|
begin
|
|
Result := (aControl = nil) or (aControl is TfrxTabSheet);
|
|
end;
|
|
|
|
procedure TfrxPageControl.SetHeight(Value: Extended);
|
|
begin
|
|
inherited;
|
|
UpdateSize;
|
|
end;
|
|
|
|
{$IFNDEF FPC}
|
|
procedure TfrxPageControl.SetHotTrack(const Value: Boolean);
|
|
begin
|
|
FPageControl.HotTrack := Value;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
procedure TfrxPageControl.SetMultiLine(const Value: Boolean);
|
|
begin
|
|
FPageControl.MultiLine := Value;
|
|
UpdateSize;
|
|
end;
|
|
|
|
|
|
procedure TfrxPageControl.SetParent(AParent: TfrxComponent);
|
|
begin
|
|
inherited;
|
|
end;
|
|
|
|
{$IFNDEF FPC}
|
|
procedure TfrxPageControl.SetRaggedRight(const Value: Boolean);
|
|
begin
|
|
FPageControl.RaggedRight := Value;
|
|
end;
|
|
|
|
procedure TfrxPageControl.SetScrollOpposite(const Value: Boolean);
|
|
begin
|
|
FPageControl.ScrollOpposite := Value;
|
|
end;
|
|
|
|
procedure TfrxPageControl.SetStyle(const Value: TTabStyle);
|
|
begin
|
|
FPageControl.Style := Value;
|
|
UpdateSize;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
procedure TfrxPageControl.SetTabHeight(const Value: Smallint);
|
|
begin
|
|
FPageControl.TabHeight := Value;
|
|
UpdateSize;
|
|
end;
|
|
|
|
procedure TfrxPageControl.SetTabIndex(const Value: Integer);
|
|
begin
|
|
FPageControl.TabIndex := Value;
|
|
end;
|
|
|
|
procedure TfrxPageControl.SetTabOrder(const Value: Integer);
|
|
begin
|
|
FPageControl.TabOrder := Value;
|
|
end;
|
|
|
|
procedure TfrxPageControl.SetTabPosition(const Value: TTabPosition);
|
|
begin
|
|
FPageControl.TabPosition := Value;
|
|
UpdateSize;
|
|
end;
|
|
|
|
procedure TfrxPageControl.SetTabWidth(const Value: Smallint);
|
|
begin
|
|
FPageControl.TabWidth := Value;
|
|
UpdateSize;
|
|
end;
|
|
|
|
procedure TfrxPageControl.SetWidth(Value: Extended);
|
|
begin
|
|
inherited;
|
|
UpdateSize;
|
|
end;
|
|
|
|
procedure TfrxPageControl.UpdateSize;
|
|
var
|
|
i: Integer;
|
|
begin
|
|
for i := 0 to Objects.Count - 1 do
|
|
if TObject(Objects[i]) is TfrxTabSheet then
|
|
TfrxTabSheet(Objects[i]).UpdateSize;
|
|
end;
|
|
|
|
{ TfrxTabSheet }
|
|
|
|
constructor TfrxTabSheet.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FTabSheet := TTabSheet.Create(nil);
|
|
InitControl(FTabSheet);
|
|
{ component may accept others }
|
|
frComponentStyle := frComponentStyle + [csAcceptsFrxComponents];
|
|
end;
|
|
|
|
procedure TfrxTabSheet.DoSetParent;
|
|
begin
|
|
{ link tabs with PageControl }
|
|
if (Parent is TfrxPageControl) and Assigned(FTabSheet) then
|
|
begin
|
|
FTabSheet.PageControl := TfrxPageControl(Parent).FPageControl;
|
|
UpdateSize;
|
|
end;
|
|
if Parent = nil then
|
|
FTabSheet.PageControl := nil;
|
|
end;
|
|
|
|
function TfrxTabSheet.GetBorderWidth: Integer;
|
|
begin
|
|
Result := FTabSheet.BorderWidth;
|
|
end;
|
|
|
|
function TfrxTabSheet.GetContainedComponent(X, Y: Extended;
|
|
IsCanContain: TfrxComponent): TfrxComponent;
|
|
begin
|
|
Result := nil;
|
|
{ check only active tab }
|
|
if (FTabSheet = nil) or (FTabSheet.PageControl = nil) or
|
|
not(FTabSheet.PageControl.ActivePage = FTabSheet) then Exit;
|
|
Result := inherited GetContainedComponent(X, Y, IsCanContain);
|
|
end;
|
|
|
|
{$IFNDEF FPC}
|
|
function TfrxTabSheet.GetHighlighted: Boolean;
|
|
begin
|
|
Result := FTabSheet.Highlighted;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function TfrxTabSheet.GetImageIndex: Integer;
|
|
begin
|
|
Result := FTabSheet.ImageIndex;
|
|
end;
|
|
|
|
function TfrxTabSheet.GetPageIndex: Integer;
|
|
begin
|
|
Result := FTabSheet.PageIndex;
|
|
end;
|
|
|
|
function TfrxTabSheet.GetTabVisible: Boolean;
|
|
begin
|
|
Result := FTabSheet.TabVisible;
|
|
end;
|
|
|
|
function TfrxTabSheet.IsAcceptAsChild(aParent: TfrxComponent): Boolean;
|
|
begin
|
|
{ do not accept TfrxTabSheet class as parent }
|
|
Result := inherited IsAcceptAsChild(aParent) and (aParent is TfrxPageControl);
|
|
end;
|
|
|
|
function TfrxTabSheet.IsContain(X, Y: Extended): Boolean;
|
|
begin
|
|
Result := False;
|
|
{ check only active tab }
|
|
if (FTabSheet = nil) or (FTabSheet.PageControl = nil) or
|
|
not(FTabSheet.PageControl.ActivePage = FTabSheet) then
|
|
Exit;
|
|
Result := inherited IsContain(X, Y);
|
|
end;
|
|
|
|
function TfrxTabSheet.IsOwnerDraw: Boolean;
|
|
begin
|
|
{ do not draw components from invisible tabs in the report designer }
|
|
Result := (FTabSheet = nil) or (FTabSheet.PageControl = nil) or
|
|
not(FTabSheet.PageControl.ActivePage = FTabSheet);
|
|
end;
|
|
|
|
procedure TfrxTabSheet.SetBorderWidth(const Value: Integer);
|
|
begin
|
|
FTabSheet.BorderWidth := Value;
|
|
end;
|
|
|
|
procedure TfrxTabSheet.SetHeight(Value: Extended);
|
|
begin
|
|
// do not resize
|
|
end;
|
|
|
|
{$IFNDEF FPC}
|
|
procedure TfrxTabSheet.SetHighlighted(const Value: Boolean);
|
|
begin
|
|
FTabSheet.Highlighted := Value;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
procedure TfrxTabSheet.SetImageIndex(const Value: Integer);
|
|
begin
|
|
FTabSheet.ImageIndex := Value;
|
|
end;
|
|
|
|
procedure TfrxTabSheet.SetLeft(Value: Extended);
|
|
begin
|
|
// do not resize
|
|
end;
|
|
|
|
procedure TfrxTabSheet.SetPageIndex(const Value: Integer);
|
|
begin
|
|
FTabSheet.PageIndex := Value;
|
|
end;
|
|
|
|
procedure TfrxTabSheet.SetParent(AParent: TfrxComponent);
|
|
begin
|
|
inherited;
|
|
ThreadSynchronize(DoSetParent);
|
|
end;
|
|
|
|
procedure TfrxTabSheet.SetTabVisible(const Value: Boolean);
|
|
begin
|
|
FTabSheet.TabVisible := Value;
|
|
end;
|
|
|
|
procedure TfrxTabSheet.CorrectControlCoordinates;
|
|
begin
|
|
//
|
|
end;
|
|
|
|
procedure TfrxTabSheet.SetTop(Value: Extended);
|
|
begin
|
|
// do not resize
|
|
end;
|
|
|
|
procedure TfrxTabSheet.SetWidth(Value: Extended);
|
|
begin
|
|
// do not resize
|
|
end;
|
|
|
|
procedure TfrxTabSheet.UpdateSize;
|
|
{$IFDEF FPC}
|
|
var
|
|
pt: TPoint;
|
|
{$ENDIF}
|
|
begin
|
|
if Assigned(FTabSheet) then
|
|
begin
|
|
{$IFDEF FPC}
|
|
pt := GetCoordinateOffset;
|
|
inherited SetLeft(Abs(pt.x));
|
|
inherited SetTop(Abs(pt.y));
|
|
{$ELSE}
|
|
inherited SetLeft(GetScaledControlLeft);
|
|
inherited SetTop(GetScaledControlTop);
|
|
{$ENDIF}
|
|
inherited SetWidth(GetScaledControlWidth);
|
|
inherited SetHeight(GetScaledControlHeight);
|
|
end;
|
|
end;
|
|
|
|
{ TfrxPageControlEditor }
|
|
|
|
function TfrxPageControlEditor.Execute(Tag: Integer; Checked: Boolean): Boolean;
|
|
var
|
|
Tab: TfrxTabSheet;
|
|
PageCtrl: TfrxPageControl;
|
|
Index: Integer;
|
|
begin
|
|
Result := inherited Execute(Tag, Checked);
|
|
PageCtrl := TfrxPageControl(Component);
|
|
case Tag of
|
|
0:
|
|
begin
|
|
Tab := TfrxTabSheet.Create(Component);
|
|
Tab.CreateUniqueName;
|
|
Tab.FTabSheet.PageControl := PageCtrl.FPageControl;
|
|
Result := True;
|
|
end;
|
|
1, 2:
|
|
begin
|
|
Index := PageCtrl.TabIndex;
|
|
if Tag = 1 then
|
|
Inc(Index)
|
|
else if Tag = 2 then
|
|
Dec(Index);
|
|
if Index > PageCtrl.PageCount - 1 then
|
|
Index := 0
|
|
else if Index < 0 then
|
|
Index := PageCtrl.PageCount - 1;
|
|
PageCtrl.TabIndex := Index;
|
|
Result := True;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TfrxPageControlEditor.GetMenuItems;
|
|
begin
|
|
inherited;
|
|
AddItem(frxResources.Get('6372'), 0);
|
|
AddItem(frxResources.Get('139'), 1);
|
|
AddItem(frxResources.Get('137'), 2);
|
|
end;
|
|
|
|
initialization
|
|
{$IFDEF DELPHI16}
|
|
StartClassGroup(TControl);
|
|
ActivateClassGroup(TControl);
|
|
GroupDescendentsWith(TfrxDialogControls, TControl);
|
|
{$ENDIF}
|
|
frxObjects.RegisterObject1(TfrxLabelControl, nil, '', '', 0, 12);
|
|
frxObjects.RegisterObject1(TfrxEditControl, nil, '', '', 0, 13);
|
|
frxObjects.RegisterObject1(TfrxMemoControl, nil, '', '', 0, 14);
|
|
frxObjects.RegisterObject1(TfrxButtonControl, nil, '', '', 0, 15);
|
|
frxObjects.RegisterObject1(TfrxCheckBoxControl, nil, '', '', 0, 16);
|
|
frxObjects.RegisterObject1(TfrxRadioButtonControl, nil, '', '', 0, 17);
|
|
frxObjects.RegisterObject1(TfrxListBoxControl, nil, '', '', 0, 18);
|
|
frxObjects.RegisterObject1(TfrxComboBoxControl, nil, '', '', 0, 19);
|
|
frxObjects.RegisterObject1(TfrxPanelControl, nil, '', '', 0, 44);
|
|
frxObjects.RegisterObject1(TfrxGroupBoxControl, nil, '', '', 0, 43);
|
|
|
|
frxObjects.RegisterObject1(TfrxPageControl, nil, '', '', 0, 75);
|
|
frxObjects.RegisterObject1(TfrxTabSheet, nil, '', '', 0, 76, [ctNone]);
|
|
|
|
frxObjects.RegisterObject1(TfrxDateEditControl, nil, '', '', 0, 20);
|
|
frxObjects.RegisterObject1(TfrxImageControl, nil, '', '', 0, 3);
|
|
frxObjects.RegisterObject1(TfrxBevelControl, nil, '', '', 0, 33);
|
|
frxObjects.RegisterObject1(TfrxBitBtnControl, nil, '', '', 0, 45);
|
|
frxObjects.RegisterObject1(TfrxSpeedButtonControl, nil, '', '', 0, 46);
|
|
frxObjects.RegisterObject1(TfrxMaskEditControl, nil, '', '', 0, 47);
|
|
frxObjects.RegisterObject1(TfrxCheckListBoxControl, nil, '', '', 0, 48);
|
|
|
|
frxComponentEditors.Register(TfrxPageControl, TfrxPageControlEditor);
|
|
frxResources.Add('TfrxOnChangingEvent',
|
|
'PascalScript=(Sender: TObject; var AllowChange: Boolean);' + #13#10 +
|
|
'C++Script=(int RowIndex, bool &AllowChange)' + #13#10 +
|
|
'BasicScript=(RowIndex, byref AllowChange)' + #13#10 +
|
|
'JScript=(RowIndex, &AllowChange)');
|
|
|
|
end.
|