roberto
f040ff20cd
git-svn-id: https://192.168.0.254/svn/Componentes.Terceros.DevExpressVCL@63 05c56307-c608-d34a-929d-697000501d7a
6818 lines
218 KiB
ObjectPascal
6818 lines
218 KiB
ObjectPascal
{*******************************************************************}
|
|
{ }
|
|
{ Developer Express Visual Component Library }
|
|
{ ExpressPrinting System(tm) COMPONENT SUITE }
|
|
{ }
|
|
{ Copyright (C) 1998-2009 Developer Express Inc. }
|
|
{ ALL RIGHTS RESERVED }
|
|
{ }
|
|
{ The entire contents of this file is protected by U.S. and }
|
|
{ International Copyright Laws. Unauthorized reproduction, }
|
|
{ reverse-engineering, and distribution of all or any portion of }
|
|
{ the code contained in this file is strictly prohibited and may }
|
|
{ result in severe civil and criminal penalties and will be }
|
|
{ prosecuted to the maximum extent possible under the law. }
|
|
{ }
|
|
{ RESTRICTIONS }
|
|
{ }
|
|
{ THIS SOURCE CODE AND ALL RESULTING INTERMEDIATE FILES }
|
|
{ (DCU, OBJ, DLL, ETC.) ARE CONFIDENTIAL AND PROPRIETARY TRADE }
|
|
{ SECRETS OF DEVELOPER EXPRESS INC. THE REGISTERED DEVELOPER IS }
|
|
{ LICENSED TO DISTRIBUTE THE EXPRESSPRINTINGSYSTEM AND }
|
|
{ ALL ACCOMPANYING VCL CONTROLS AS PART OF AN }
|
|
{ EXECUTABLE PROGRAM ONLY. }
|
|
{ }
|
|
{ THE SOURCE CODE CONTAINED WITHIN THIS FILE AND ALL RELATED }
|
|
{ FILES OR ANY PORTION OF ITS CONTENTS SHALL AT NO TIME BE }
|
|
{ COPIED, TRANSFERRED, SOLD, DISTRIBUTED, OR OTHERWISE MADE }
|
|
{ AVAILABLE TO OTHER INDIVIDUALS WITHOUT EXPRESS WRITTEN CONSENT }
|
|
{ AND PERMISSION FROM DEVELOPER EXPRESS INC. }
|
|
{ }
|
|
{ CONSULT THE END USER LICENSE AGREEMENT FOR INFORMATION ON }
|
|
{ ADDITIONAL RESTRICTIONS. }
|
|
{ }
|
|
{*******************************************************************}
|
|
|
|
unit dxPSContainerLnk;
|
|
|
|
interface
|
|
|
|
{$I cxVer.inc}
|
|
|
|
uses
|
|
Windows, Messages, Classes, Controls, Graphics, StdCtrls, ExtCtrls, ComCtrls,
|
|
TabNotBk, Forms, ImgList, Menus, dxBase, dxPSCore, dxPSSngltn, dxPSShapes,
|
|
dxPSForm, dxPSFillPatterns, dxPSStandardFillPatterns, Buttons, cxDrawTextUtils;
|
|
|
|
type
|
|
TdxCustomContainerReportLink = class;
|
|
TdxCustomContainerReportLinkOptionsItemPlaceClass = class of TdxCustomContainerReportLinkOptionsItemPlace;
|
|
TdxCustomContainerReportLinkOptionsItemPlace = class;
|
|
TdxCustomContainerReportLinkOptionsPaginationClass = class of TdxCustomContainerReportLinkOptionsPagination;
|
|
TdxCustomContainerReportLinkOptionsPagination = class;
|
|
TdxCustomContainerReportLinkOptionsTransparentClass = class of TdxCustomContainerReportLinkOptionsTransparent;
|
|
TdxCustomContainerReportLinkOptionsTransparent = class;
|
|
TdxfmCustomContainerDesignWindow = class;
|
|
|
|
{ Report Items }
|
|
|
|
TdxReportWinControlHost = class(TdxReportCell)
|
|
private
|
|
function GetHasControlItem: Boolean;
|
|
protected
|
|
procedure BoundsChanged; override;
|
|
function GetControlItem: TdxReportVisualItem; virtual;
|
|
public
|
|
function MeasureHeight(DC: HDC): Integer; override;
|
|
function MeasureWidth(DC: HDC): Integer; override;
|
|
|
|
property ControlItem: TdxReportVisualItem read GetControlItem;
|
|
property HasControlItem: Boolean read GetHasControlItem;
|
|
end;
|
|
|
|
TdxReportNativePrintableControlHost = class(TdxReportWinControlHost)
|
|
protected
|
|
function GetControlItem: TdxReportVisualItem; override;
|
|
procedure BoundsChanged; override;
|
|
end;
|
|
|
|
{ Definitions }
|
|
|
|
TdxPSCustomContainerItemDefinitionClass = class of TdxPSCustomContainerItemDefinition;
|
|
|
|
TdxPSCustomContainerItemDefinition = class(TPersistent)
|
|
private
|
|
FComponent: TComponent;
|
|
FOptionsPlace: TdxCustomContainerReportLinkOptionsItemPlace;
|
|
FReportItem: TdxReportVisualItem;
|
|
FReportLink: TdxCustomContainerReportLink;
|
|
function GetRootContainer: TWinControl;
|
|
function GetTopLevelRootContainer: TWinControl;
|
|
protected
|
|
procedure AddDelimitersHorz(AList: TList); virtual;
|
|
procedure AddDelimitersVert(AList: TList); virtual;
|
|
procedure AddReportItemToDelimitersHorz(AList: TList);
|
|
procedure AddReportItemToDelimitersVert(AList: TList);
|
|
|
|
function GetSizeChangeReportItem: TdxReportVisualItem; virtual;
|
|
function GetSizeMeasureReportItem: TdxReportVisualItem; virtual;
|
|
public
|
|
constructor Create(AReportLink: TdxCustomContainerReportLink; AComponent: TComponent; AReportItem: TdxReportVisualItem); virtual;
|
|
destructor Destroy; override;
|
|
|
|
function OptionsPagination: TdxCustomContainerReportLinkOptionsPagination; overload; virtual;
|
|
|
|
property Component: TComponent read FComponent write FComponent;
|
|
property OptionsPlace: TdxCustomContainerReportLinkOptionsItemPlace read FOptionsPlace;
|
|
property ReportItem: TdxReportVisualItem read FReportItem write FReportItem;
|
|
property ReportLink: TdxCustomContainerReportLink read FReportLink;
|
|
property RootContainer: TWinControl read GetRootContainer;
|
|
property TopLevelRootContainer: TWinControl read GetTopLevelRootContainer;
|
|
property SizeChangeReportItem: TdxReportVisualItem read GetSizeChangeReportItem;
|
|
property SizeMeasureReportItem: TdxReportVisualItem read GetSizeMeasureReportItem;
|
|
end;
|
|
|
|
TdxPSContainerControlDefinition = class(TdxPSCustomContainerItemDefinition)
|
|
private
|
|
function GetControl: TControl;
|
|
procedure SetControl(Value: TControl);
|
|
protected
|
|
procedure AddDelimitersHorz(AList: TList); override;
|
|
procedure AddDelimitersVert(AList: TList); override;
|
|
public
|
|
property Control: TControl read GetControl write SetControl;
|
|
end;
|
|
|
|
TdxPSNativePrintableControlDefinition = class(TdxPSContainerControlDefinition)
|
|
private
|
|
FDelimitersHorz: TList;
|
|
FDelimitersVert: TList;
|
|
FReportDimension: TPoint;
|
|
function GetDelimitersOffset: TPoint;
|
|
protected
|
|
procedure AddDelimitersHorz(AList: TList); override;
|
|
procedure AddDelimitersVert(AList: TList); override;
|
|
procedure GetData(AReportLink: TBasedxReportLink);
|
|
procedure ShiftDelimiters;
|
|
|
|
function GetSizeChangeReportItem: TdxReportVisualItem; override;
|
|
|
|
property DelimitersOffset: Tpoint read GetDelimitersOffset;
|
|
property DelimitersHorz: TList read FDelimitersHorz;
|
|
property DelimitersVert: TList read FDelimitersVert;
|
|
property ReportDimension: TPoint read FReportDimension;
|
|
public
|
|
constructor Create(AReportLink: TdxCustomContainerReportLink; AComponent: TComponent; AReportItem: TdxReportVisualItem); override;
|
|
destructor Destroy; override;
|
|
end;
|
|
|
|
TdxPSContainerWinControlDefinition = class(TdxPSContainerControlDefinition)
|
|
protected
|
|
function GetSizeChangeReportItem: TdxReportVisualItem; override;
|
|
end;
|
|
|
|
TdxPSContainerDefinition = class(TdxPSContainerWinControlDefinition)
|
|
protected
|
|
function GetSizeMeasureReportItem: TdxReportVisualItem; override;
|
|
end;
|
|
|
|
{ Iterators }
|
|
|
|
IdxPSContainerIterator = interface
|
|
['{B18A68C0-5505-42AC-9B8D-B96C79A2725E}']
|
|
function GetControl(Index: Integer): TControl;
|
|
function GetControlCount: Integer;
|
|
procedure GoBeforeBOF;
|
|
procedure GoBeyondEOF;
|
|
function IsBOF: Boolean;
|
|
function IsEOF: Boolean;
|
|
function Next: TControl;
|
|
function Prev: TControl;
|
|
|
|
property ControlCount: Integer read GetControlCount;
|
|
property Controls[Index: Integer]: TControl read GetControl;
|
|
end;
|
|
|
|
TdxPSWinControlIteratorClass = class of TdxPSWinControlIterator;
|
|
|
|
TdxPSWinControlIterator = class(TInterfacedObject, IdxPSContainerIterator)
|
|
private
|
|
FControl: TWinControl;
|
|
FCounter: Integer;
|
|
protected
|
|
{ IdxPSContainerIterator }
|
|
function GetControl(Index: Integer): TControl; virtual;
|
|
function GetControlCount: Integer; virtual;
|
|
procedure GoBeforeBOF; virtual;
|
|
procedure GoBeyondEOF; virtual;
|
|
function IsBOF: Boolean; virtual;
|
|
function IsEOF: Boolean; virtual;
|
|
function Next: TControl; virtual;
|
|
function Prev: TControl; virtual;
|
|
|
|
property ControlCount: Integer read GetControlCount;
|
|
property Controls[Index: Integer]: TControl read GetControl;
|
|
public
|
|
constructor Create(AControl: TWinControl); virtual;
|
|
class function ContainerClass: TWinControlClass; virtual;
|
|
property Control: TWinControl read FControl;
|
|
end;
|
|
|
|
{ Producers }
|
|
|
|
TdxPSCustomProducerClass = class of TdxPSCustomProducer;
|
|
|
|
TdxPSCustomProducer = class(TdxCustomClassMapItem)
|
|
private
|
|
FProducingObject: TComponent;
|
|
FReportLink: TdxCustomContainerReportLink;
|
|
function GetDC: HDC;
|
|
function GetDefinition(Component: TComponent): TdxPSCustomContainerItemDefinition;
|
|
function GetIsDesigning: Boolean;
|
|
function GetProducer(Component: TComponent): TdxPSCustomProducer;
|
|
protected
|
|
class function BuddyClass: TdxPSCustomProducerClass; virtual;
|
|
class function HelperProducer: TdxPSCustomProducerClass; virtual;
|
|
|
|
function CanProcessChild(AChildControl: TControl): Boolean; virtual;
|
|
|
|
function GetScrollPosLeft: Integer; virtual;
|
|
function GetScrollPosTop: Integer; virtual;
|
|
procedure GetImageLists(AProc: TdxPSGetImageListProc); virtual;
|
|
procedure InitializeOptionsPlace(AnOptions: TdxCustomContainerReportLinkOptionsItemPlace); virtual;
|
|
|
|
procedure DoReposition; virtual;
|
|
function MeasureItemHeight(AnItem: TdxReportVisualItem): Integer; virtual;
|
|
function MeasureItemWidth(AnItem: TdxReportVisualItem): Integer; virtual;
|
|
function ObjectExpandHeight: Boolean; virtual;
|
|
function ObjectExpandWidth: Boolean; virtual;
|
|
function ObjectShrinkHeight: Boolean; virtual;
|
|
function ObjectShrinkWidth: Boolean; virtual;
|
|
|
|
function OptionsTransparent: TdxCustomContainerReportLinkOptionsTransparent; overload; virtual;
|
|
|
|
property DC: HDC read GetDC;
|
|
property Definitions[Component: TComponent]: TdxPSCustomContainerItemDefinition read GetDefinition;
|
|
property IsDesigning: Boolean read GetIsDesigning;
|
|
property Producers[Component: TComponent]: TdxPSCustomProducer read GetProducer;
|
|
property ScrollPosLeft: Integer read GetScrollPosLeft;
|
|
property ScrollPosTop: Integer read GetScrollPosTop;
|
|
public
|
|
constructor Create(AReportLink: TdxCustomContainerReportLink; AnObject: TComponent); virtual;
|
|
|
|
class function CanHasAvailableChildren: Boolean; virtual;
|
|
class function HasNativeSupportForBorders: Boolean; virtual;
|
|
class function Reenterable: Boolean; virtual;
|
|
|
|
function Definition: TdxPSCustomContainerItemDefinition; overload; virtual;
|
|
class function DefinitionClass: TdxPSCustomContainerItemDefinitionClass; virtual; // must be overriden
|
|
|
|
procedure Initialize(AnObject: TComponent); virtual;
|
|
|
|
function ProducingObject: TComponent; overload; virtual;
|
|
function ProducingObjectFriendlyName: string; virtual;
|
|
|
|
function ReportLink: TdxCustomContainerReportLink; overload; virtual;
|
|
procedure Reposition; virtual;
|
|
function RootContainer: TWinControl; overload; virtual;
|
|
function TopLevelRootContainer: TWinControl; overload; virtual;
|
|
|
|
class procedure Register; virtual;
|
|
class procedure Unregister; virtual;
|
|
end;
|
|
|
|
TdxPSCustomContainerItemProducerClass = class of TdxPSCustomContainerItemProducer;
|
|
|
|
TdxPSCustomContainerItemProducer = class(TdxPSCustomProducer)
|
|
private
|
|
function GetControlBounds: TRect;
|
|
protected
|
|
function CanProcessChild(AChildControl: TControl): Boolean; override;
|
|
function CreateIterator: IdxPSContainerIterator; virtual;
|
|
|
|
function GetContentColor: TColor; virtual;
|
|
function GetControlBoundsRect: TRect; virtual;
|
|
function GetFont: TFont; virtual;
|
|
function GetFontColor: TColor; virtual;
|
|
function GetFontIndex: Integer; virtual;
|
|
function GetFontName: string; virtual;
|
|
function GetFontStyle: TFontStyles; virtual;
|
|
function IsFontSubstitutable: Boolean; virtual;
|
|
|
|
function HostClass: TdxReportCellClass; virtual;
|
|
procedure InitializeHost(ACell: TdxReportCell); virtual;
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); virtual;
|
|
function ItemClass: TdxReportVisualItemClass; virtual;
|
|
public
|
|
function Control: TControl; overload; virtual;
|
|
class function ControlClass: TControlClass; virtual;
|
|
|
|
function Definition: TdxPSContainerControlDefinition; reintroduce; overload;
|
|
class function DefinitionClass: TdxPSCustomContainerItemDefinitionClass; override;
|
|
|
|
class function PairClass: TClass; override;
|
|
|
|
function ProducingObject: TControl; reintroduce; overload;
|
|
function ProducingObjectFriendlyName: string; override;
|
|
|
|
property ContentColor: TColor read GetContentColor;
|
|
property ControlBounds: TRect read GetControlBounds;
|
|
property Font: TFont read GetFont;
|
|
property FontColor: TColor read GetFontColor;
|
|
property FontIndex: Integer read GetFontIndex;
|
|
property FontName: string read GetFontName;
|
|
property FontStyle: TFontStyles read GetFontStyle;
|
|
end;
|
|
|
|
TdxPSCustomDelegateProducer = class(TdxPSCustomContainerItemProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
function ItemClass: TdxReportVisualItemClass; override;
|
|
function Producer: TdxPSCustomContainerItemProducer; virtual; abstract;
|
|
end;
|
|
|
|
TdxPSNativePrintableControlProducerClass = class of TdxPSNativePrintableControlProducer;
|
|
|
|
TdxPSNativePrintableControlProducer = class(TdxPSCustomContainerItemProducer)
|
|
private
|
|
FIsOuterLinkUsed: Boolean;
|
|
protected
|
|
procedure AdjustItemBounds(AnItem: TdxReportVisualItem); virtual;
|
|
|
|
function CreateControlReportLink: TBasedxReportLink;
|
|
procedure CreateNativePrintableControlData(AnItem: TdxReportVisualItem);
|
|
procedure DeinitializeReportLink(AControlReportLink: TBasedxReportLink); virtual;
|
|
class function GetLinkClass(AClass: TClass): TdxReportLinkClass;
|
|
class function HasReportLink(AComponent: TComponent): Boolean;
|
|
procedure InitializeReportLink(AControlReportLink: TBasedxReportLink); virtual;
|
|
|
|
function HostClass: TdxReportCellClass; override;
|
|
procedure InitializeHost(ACell: TdxReportCell); override;
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
procedure InitializeNativePrintableControlHost(AnItem: TdxReportVisualItem); virtual;
|
|
function ItemClass: TdxReportVisualItemClass; override;
|
|
|
|
function MeasureItemHeight(AnItem: TdxReportVisualItem): Integer; override;
|
|
function MeasureItemWidth(AnItem: TdxReportVisualItem): Integer; override;
|
|
function ObjectExpandHeight: Boolean; override;
|
|
function ObjectExpandWidth: Boolean; override;
|
|
|
|
property IsOuterLinkUsed: Boolean read FIsOuterLinkUsed;
|
|
public
|
|
class function Reenterable: Boolean; override;
|
|
function Definition: TdxPSNativePrintableControlDefinition; reintroduce; overload;
|
|
class function DefinitionClass: TdxPSCustomContainerItemDefinitionClass; override;
|
|
|
|
class function HasNativeSupportForBorders: Boolean; override;
|
|
|
|
class procedure Register; override;
|
|
class procedure Unregister; override;
|
|
end;
|
|
|
|
TdxPSContainerControlProducer = class(TdxPSCustomContainerItemProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
end;
|
|
|
|
TdxPSControlAsMetafileProducer = class(TdxPSContainerControlProducer)
|
|
protected
|
|
class function BuddyClass: TdxPSCustomProducerClass; override;
|
|
function CreateControlImage(AnItem: TdxReportVisualItem): TGraphic; virtual;
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
function ItemClass: TdxReportVisualItemClass; override;
|
|
public
|
|
class function PairClass: TClass; override;
|
|
class procedure Register; override;
|
|
class procedure Unregister; override;
|
|
|
|
procedure Reposition; override;
|
|
end;
|
|
|
|
TdxPSBevelProducer = class(TdxPSContainerControlProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
function ItemClass: TdxReportVisualItemClass; override;
|
|
public
|
|
function Control: TBevel; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSPaintBoxProducer = class(TdxPSContainerControlProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
function ItemClass: TdxReportVisualItemClass; override;
|
|
public
|
|
function Control: TPaintBox; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSShapeProducer = class(TdxPSContainerControlProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
function ItemClass: TdxReportVisualItemClass; override;
|
|
public
|
|
function Control: TShape; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSCustomLabelProducer = class(TdxPSContainerControlProducer)
|
|
protected
|
|
function GetControlBoundsRect: TRect; override;
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
function ItemClass: TdxReportVisualItemClass; override;
|
|
function ObjectExpandHeight: Boolean; override;
|
|
function ObjectExpandWidth: Boolean; override;
|
|
public
|
|
function Control: TCustomLabel; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSContainerCustomWinControlProducer = class(TdxPSContainerControlProducer)
|
|
protected
|
|
function CreateIterator: IdxPSContainerIterator; override;
|
|
function HostClass: TdxReportCellClass; override;
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
class function IteratorClass: TdxPSWinControlIteratorClass; virtual;
|
|
public
|
|
function Control: TWinControl; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
class function DefinitionClass: TdxPSCustomContainerItemDefinitionClass; override;
|
|
end;
|
|
|
|
TdxPSWinControlAsMetafileProducer = class(TdxPSContainerCustomWinControlProducer)
|
|
protected
|
|
class function BuddyClass: TdxPSCustomProducerClass; override;
|
|
function CreateControlImage(AnItem: TdxReportVisualItem): TGraphic; virtual;
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
function ItemClass: TdxReportVisualItemClass; override;
|
|
public
|
|
class function PairClass: TClass; override;
|
|
procedure Reposition; override;
|
|
class procedure Register; override;
|
|
class procedure Unregister; override;
|
|
end;
|
|
|
|
TdxPSContainerWinControlProducer = class(TdxPSContainerCustomWinControlProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
function ItemClass: TdxReportVisualItemClass; override;
|
|
function ObjectExpandHeight: Boolean; override;
|
|
end;
|
|
|
|
TdxPSDateTimePickerProducer = class(TdxPSContainerWinControlProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
function ItemClass: TdxReportVisualItemClass; override;
|
|
public
|
|
function Control: TDateTimePicker; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSCustomHotKeyProducer = class(TdxPSContainerWinControlProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
public
|
|
function Control: TCustomHotKey; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSCustomStaticTextProducer = class(TdxPSContainerWinControlProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
public
|
|
function Control: TCustomStaticText; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSCustomEditProducer = class(TdxPSContainerWinControlProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
public
|
|
function Control: TCustomEdit; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSCustomMemoProducer = class(TdxPSCustomEditProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
function ObjectExpandHeight: Boolean; override;
|
|
public
|
|
function Control: TCustomMemo; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
|
|
function ProducingObjectFriendlyName: string; override;
|
|
end;
|
|
|
|
TdxPSCustomComboBoxProducer = class(TdxPSContainerWinControlProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
public
|
|
function Control: TCustomComboBox; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
{$IFDEF DELPHI6}
|
|
TdxPSCustomComboBoxExProducer = class(TdxPSContainerWinControlProducer)
|
|
protected
|
|
procedure GetImageLists(AProc: TdxPSGetImageListProc); override;
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
function ItemClass: TdxReportVisualItemClass; override;
|
|
public
|
|
function Control: TCustomComboBoxEx; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
TdxPSCustomCheckBoxProducer = class(TdxPSContainerWinControlProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
function ItemClass: TdxReportVisualItemClass; override;
|
|
public
|
|
function Control: TCustomCheckBox; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSRadioButtonProducer = class(TdxPSContainerWinControlProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
function ItemClass: TdxReportVisualItemClass; override;
|
|
public
|
|
function Control: TRadioButton; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSCustomContainerProducerClass = class of TdxPSCustomContainerProducer;
|
|
|
|
TdxPSCustomContainerProducer = class(TdxPSContainerCustomWinControlProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
function ObjectExpandHeight: Boolean; override;
|
|
function ObjectExpandWidth: Boolean; override;
|
|
function ObjectShrinkHeight: Boolean; override;
|
|
function ObjectShrinkWidth: Boolean; override;
|
|
public
|
|
class function CanHasAvailableChildren: Boolean; override;
|
|
class function DefinitionClass: TdxPSCustomContainerItemDefinitionClass; override;
|
|
end;
|
|
|
|
TdxPSCustomPanelProducer = class(TdxPSCustomContainerProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
function ItemClass: TdxReportVisualItemClass; override;
|
|
function ObjectExpandHeight: Boolean; override;
|
|
function ObjectExpandWidth: Boolean; override;
|
|
public
|
|
function Control: TCustomPanel; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
|
|
class function HasNativeSupportForBorders: Boolean; override;
|
|
end;
|
|
|
|
TdxPSCustomGroupBoxProducer = class(TdxPSCustomContainerProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
procedure InitializeLookAndFeel(AnItem: TdxReportVisualItem; ALookAndFeel: TdxPSReportGroupLookAndFeel);
|
|
function ItemClass: TdxReportVisualItemClass; override;
|
|
class function LookAndFeelClass: TdxPSReportGroupLookAndFeelClass; virtual;
|
|
public
|
|
function Control: TCustomGroupBox; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
|
|
class function HasNativeSupportForBorders: Boolean; override;
|
|
end;
|
|
|
|
TdxPSCustomRadioGroupProducer = class(TdxPSCustomGroupBoxProducer)
|
|
protected
|
|
function CanProcessChild(AChildControl: TControl): Boolean; override;
|
|
procedure CreateItems(AReportRadioGroup: TdxReportRadioGroup);
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
procedure InitializeRadioItem(AnItem: TdxCustomReportCellRadio; AnIndex: Integer); virtual;
|
|
function ItemClass: TdxReportVisualItemClass; override;
|
|
public
|
|
function Control: TCustomRadioGroup; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSRootContainerProducer = class(TdxPSCustomContainerProducer)
|
|
protected
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); override;
|
|
end;
|
|
|
|
TdxPSTabControlProducer = class(TdxPSRootContainerProducer)
|
|
public
|
|
function Control: TTabControl; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSPageControlIterator = class(TdxPSWinControlIterator)
|
|
private
|
|
function GetPageControl: TPageControl;
|
|
protected
|
|
function GetControl(Index: Integer): TControl; override;
|
|
function GetControlCount: Integer; override;
|
|
public
|
|
property PageControl: TPageControl read GetPageControl;
|
|
end;
|
|
|
|
TdxPSTabSheetProducer = class(TdxPSRootContainerProducer)
|
|
public
|
|
function Control: TTabSheet; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSPageControlProducer = class(TdxPSRootContainerProducer)//TdxPSCustomDelegateProducer)
|
|
protected
|
|
function CanProcessChild(AChildControl: TControl): Boolean; override;
|
|
class function IteratorClass: TdxPSWinControlIteratorClass; override;
|
|
public
|
|
function Control: TPageControl; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSNotebookIterator = class(TdxPSWinControlIterator)
|
|
private
|
|
function GetNotebook: TNotebook;
|
|
protected
|
|
function GetControl(Index: Integer): TControl; override;
|
|
function GetControlCount: Integer; override;
|
|
public
|
|
property Notebook: TNotebook read GetNotebook;
|
|
end;
|
|
|
|
TdxPSNotebookPageProducer = class(TdxPSRootContainerProducer)
|
|
public
|
|
function Control: TPage; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSNotebookProducer = class(TdxPSRootContainerProducer)
|
|
protected
|
|
function CanProcessChild(AChildControl: TControl): Boolean; override;
|
|
class function IteratorClass: TdxPSWinControlIteratorClass; override;
|
|
public
|
|
function Control: TNoteBook; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSTabbedNotebookIterator = class(TdxPSWinControlIterator)
|
|
private
|
|
function GetTabbedNotebook: TTabbedNotebook;
|
|
protected
|
|
function GetControl(Index: Integer): TControl; override;
|
|
function GetControlCount: Integer; override;
|
|
public
|
|
property TabbedNotebook: TTabbedNotebook read GetTabbedNotebook;
|
|
end;
|
|
|
|
TdxPSTabbedNotebookPageProducer = class(TdxPSRootContainerProducer)
|
|
public
|
|
function Control: TTabPage; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSTabbedNotebookProducer = class(TdxPSRootContainerProducer)
|
|
protected
|
|
function CanProcessChild(AChildControl: TControl): Boolean; override;
|
|
class function IteratorClass: TdxPSWinControlIteratorClass; override;
|
|
public
|
|
function Control: TTabbedNotebook; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
TdxPSScrollingWinControlProducer = class(TdxPSRootContainerProducer)
|
|
protected
|
|
function GetScrollBarPos(AScrollBar: TControlScrollBar): Integer; virtual;
|
|
function GetScrollPosLeft: Integer; override;
|
|
function GetScrollPosTop: Integer; override;
|
|
|
|
procedure InitializeHost(ACell: TdxReportCell); override;
|
|
|
|
function ObjectExpandHeight: Boolean; override;
|
|
function ObjectExpandWidth: Boolean; override;
|
|
public
|
|
function Control: TScrollingWinControl; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
{$IFDEF DELPHI5}
|
|
TdxPSCustomFrameProducer = class(TdxPSScrollingWinControlProducer)
|
|
public
|
|
function Control: TCustomFrame; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
TdxPSCustomFormProducer = class(TdxPSScrollingWinControlProducer)
|
|
public
|
|
function Control: TCustomForm; reintroduce; overload;
|
|
class function ControlClass: TControlClass; override;
|
|
end;
|
|
|
|
{ container builder }
|
|
|
|
TdxPSContainerBuilderClass = class of TdxPSContainerBuilder;
|
|
|
|
TdxPSContainerBuilder = class(TdxCustomClassMapItem)
|
|
private
|
|
FContainer: TWinControl;
|
|
FCurrentControl: TControl;
|
|
FHost: TdxReportCell;
|
|
FParentBuilder: TdxPSContainerBuilder;
|
|
FParentHost: TdxReportCell;
|
|
FReportLink: TdxCustomContainerReportLink;
|
|
function GetDC: HDC;
|
|
function GetIsRoot: Boolean;
|
|
function GetProducer(AControl: TControl): TdxPSCustomContainerItemProducer;
|
|
protected
|
|
procedure BuildNestedControls;
|
|
function CreateHost: TdxReportCell; virtual;
|
|
function CreateItemDefinition(AComponent: TComponent; AnItem: TdxReportVisualItem): TdxPSCustomContainerItemDefinition;
|
|
function CreateNestedControlsIterator: IdxPSContainerIterator; virtual;
|
|
function GetParentHost: TdxReportCell; virtual;
|
|
function HasAvailableChildren(AControl: TControl): Boolean; virtual;
|
|
procedure InitializeHost; virtual;
|
|
procedure InitializeItem(AnItem: TdxReportVisualItem); virtual;
|
|
|
|
function IsAborted: Boolean;
|
|
procedure Progress(const APercentDone: Double);
|
|
|
|
property CurrentControl: TControl read FCurrentControl;
|
|
property DC: HDC read GetDC;
|
|
property Producers[AControl: TControl]: TdxPSCustomContainerItemProducer read GetProducer;
|
|
public
|
|
constructor Create(AReportLink: TdxCustomContainerReportLink; AContainer: TWinControl;
|
|
AParentBuilder: TdxPSContainerBuilder; AParentHost: TdxReportCell = nil); virtual;
|
|
destructor Destroy; override;
|
|
|
|
function Build: TdxReportCell; virtual;
|
|
function BuildControl(AControl: TControl; AParentHost: TdxReportCell = nil): TdxReportVisualItem;
|
|
function BuildNestedContainer(AContainer: TWinControl; AParentHost: TdxReportCell = nil): TdxReportCell;
|
|
|
|
class function ContainerClass: TWinControlClass; virtual;
|
|
class function PairClass: TClass; override;
|
|
class procedure Register;
|
|
class procedure Unregister;
|
|
|
|
property Container: TWinControl read FContainer;
|
|
property Host: TdxReportCell read FHost;
|
|
property IsRoot: Boolean read GetIsRoot;
|
|
property ParentBuilder: TdxPSContainerBuilder read FParentBuilder;
|
|
property ParentHost: TdxReportCell read GetParentHost;
|
|
property ReportLink: TdxCustomContainerReportLink read FReportLink;
|
|
end;
|
|
|
|
TdxPSContainerReportLinkCustomCache = class(TdxCustomCache)
|
|
private
|
|
FReportLink: TdxCustomContainerReportLink;
|
|
public
|
|
constructor Create(AReportLink: TdxCustomContainerReportLink); virtual;
|
|
function ReportLink: TdxCustomContainerReportLink; overload; virtual;
|
|
end;
|
|
|
|
TdxPSCustomProducerCache = class(TdxPSContainerReportLinkCustomCache)
|
|
private
|
|
function GetItem(Index: Integer): TdxPSCustomProducer;
|
|
function GetProducer(ProducerClass: TdxPSCustomProducerClass; Component: TComponent): TdxPSCustomProducer;
|
|
protected
|
|
property Items[Index: Integer]: TdxPSCustomProducer read GetItem;
|
|
public
|
|
property Producers[ProducerClass: TdxPSCustomProducerClass; Component: TComponent]: TdxPSCustomProducer read GetProducer; default;
|
|
end;
|
|
|
|
{ Options }
|
|
|
|
TdxCustomContainerReportLinkOptionsClass = class of TdxCustomContainerReportLinkOptions;
|
|
|
|
TdxCustomContainerReportLinkOptions = class(TPersistent)
|
|
private
|
|
FReportLink: TdxCustomContainerReportLink;
|
|
protected
|
|
procedure Changed; dynamic;
|
|
public
|
|
constructor Create(AReportLink: TdxCustomContainerReportLink); virtual;
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; virtual;
|
|
|
|
property ReportLink: TdxCustomContainerReportLink read FReportLink;
|
|
end;
|
|
|
|
TdxCustomContainerReportLinkOptionsBehaviorClass = class of TdxCustomContainerReportLinkOptionsBehavior;
|
|
|
|
TdxCustomContainerReportLinkOptionsBehavior = class(TdxCustomContainerReportLinkOptions)
|
|
private
|
|
FConsumeExistingLinks: Boolean;
|
|
procedure SetConsumeExistingLinks(Value: Boolean);
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
published
|
|
property ConsumeExistingLinks: Boolean read FConsumeExistingLinks write SetConsumeExistingLinks default True; // obsolete - Aggregated Links always consumed
|
|
end;
|
|
|
|
TdxCustomContainerReportLinkOptionsDesignerTabsClass = class of TdxCustomContainerReportLinkOptionsDesignerTabs;
|
|
|
|
TdxCustomContainerReportLinkOptionsDesignerTabs = class(TdxCustomContainerReportLinkOptions)
|
|
private
|
|
FAutoHideReportLinksIfEmpty: Boolean;
|
|
FControls: Boolean;
|
|
FReportLinks: Boolean;
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
published
|
|
property AutoHideReportLinksIfEmpty: Boolean read FAutoHideReportLinksIfEmpty write FAutoHideReportLinksIfEmpty default True;
|
|
property Controls: Boolean read FControls write FControls default True;
|
|
property ReportLinks: Boolean read FReportLinks write FReportLinks default True;
|
|
end;
|
|
|
|
TdxCustomContainerReportLinkOptionsItemPlace = class(TdxCustomContainerReportLinkOptions)
|
|
private
|
|
FExpandHeight: Boolean;
|
|
FExpandWidth: Boolean;
|
|
FShrinkHeight: Boolean;
|
|
FShrinkWidth: Boolean;
|
|
protected
|
|
function GetData: Integer; virtual;
|
|
procedure SetData(Value: Integer); virtual;
|
|
|
|
procedure ReadData(AStream: TStream); virtual;
|
|
procedure WriteData(AStream: TStream); virtual;
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
|
|
function HasHorzResizing: Boolean;
|
|
function HasVertResizing: Boolean;
|
|
|
|
procedure SetAll;
|
|
procedure UnsetAll;
|
|
published
|
|
property ExpandHeight: Boolean read FExpandHeight write FExpandHeight default False;
|
|
property ExpandWidth: Boolean read FExpandWidth write FExpandWidth default False;
|
|
property ShrinkHeight: Boolean read FShrinkHeight write FShrinkHeight default False;
|
|
property ShrinkWidth: Boolean read FShrinkWidth write FShrinkWidth default False;
|
|
end;
|
|
|
|
TdxCustomContainerReportLinkOptionsPagination = class(TdxCustomContainerReportLinkOptions)
|
|
private
|
|
FControlDetails: Boolean;
|
|
FControls: Boolean;
|
|
procedure SetControlDetails(Value: Boolean);
|
|
procedure SetControls(Value: Boolean);
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
published
|
|
property ControlDetails: Boolean read FControlDetails write SetControlDetails default True;
|
|
property Controls: Boolean read FControls write SetControls default True;
|
|
end;
|
|
|
|
TdxCustomContainerReportLinkOptionsRefinementsClass = class of TdxCustomContainerReportLinkOptionsRefinements;
|
|
|
|
TdxCustomContainerReportLinkOptionsRefinements = class(TdxCustomContainerReportLinkOptions)
|
|
private
|
|
FRootBorders: Boolean;
|
|
procedure SetRootBorders(Value: Boolean);
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
published
|
|
property RootBorders: Boolean read FRootBorders write SetRootBorders default False;
|
|
end;
|
|
|
|
TdxCustomContainerReportLinkOptionsTransparent = class(TdxCustomContainerReportLinkOptions)
|
|
private
|
|
FContainers: Boolean;
|
|
FControls: Boolean;
|
|
FGraphics: Boolean;
|
|
FRoot: Boolean;
|
|
procedure SetContainters(Value: Boolean);
|
|
procedure SetControls(Value: Boolean);
|
|
procedure SetGraphics(Value: Boolean);
|
|
procedure SetRoot(Value: Boolean);
|
|
public
|
|
procedure Assign(Source: TPersistent); override;
|
|
procedure RestoreDefaults; override;
|
|
published
|
|
property Containers: Boolean read FContainers write SetContainters default True;
|
|
property Controls: Boolean read FControls write SetControls default True;
|
|
property Graphics: Boolean read FGraphics write SetGraphics default False;
|
|
property Root: Boolean read FRoot write SetRoot default True;
|
|
end;
|
|
|
|
TdxNodeObject = class
|
|
public
|
|
Caption: string;
|
|
Component: TComponent;
|
|
State: TCheckBoxState;
|
|
end;
|
|
|
|
TdxPSReportLinkProcessingStage = (psBefore, psAfter);
|
|
|
|
TdxContainerReportLinkCustomDrawItemEvent = procedure(Sender: TdxCustomContainerReportLink;
|
|
ACanvas: TCanvas; AnItem: TAbstractdxReportCellData; AComponent: TComponent; var ADone: Boolean) of object;
|
|
|
|
TdxContainerReportLinkGetComponentReportLinkEvent = procedure(Sender: TdxCustomContainerReportLink;
|
|
AComponent: TComponent; var AReportLink: TBasedxReportLink) of object;
|
|
|
|
TdxContainerReportLinkGetComponentCaptionEvent = procedure(Sender: TdxCustomContainerReportLink;
|
|
AComponent: TComponent; var ACaption: string) of object;
|
|
|
|
TdxContainerReportLinkInitializeItemEvent = procedure(Sender: TdxCustomContainerReportLink;
|
|
AnItem: TdxReportVisualItem; AComponent: TComponent) of object;
|
|
|
|
TdxContainerReportLinkInitializeItemOptionsPlaceEvent = procedure(Sender: TdxCustomContainerReportLink;
|
|
AnItem: TdxReportVisualItem; AComponent: TComponent; AOptionsPlace: TdxCustomContainerReportLinkOptionsItemPlace) of object;
|
|
|
|
TdxContainerReportLinkInitializeReportLinkEvent = procedure(Sender: TdxCustomContainerReportLink;
|
|
AReportLink: TBasedxReportLink; AStage: TdxPSReportLinkProcessingStage) of object;
|
|
|
|
TdxContainerReportLinkIsComponentProcessedEvent = procedure(Sender: TdxCustomContainerReportLink;
|
|
AComponent: TComponent; var AIsProcessed: Boolean) of object;
|
|
|
|
TdxCustomContainerReportLink = class(TBasedxReportLink)
|
|
private
|
|
FActiveBuilder: TdxPSContainerBuilder;
|
|
FAggregatedReportLinks: TStrings;
|
|
FDefinitions: TList;
|
|
FDelimitersHorz: TList;
|
|
FDelimitersVert: TList;
|
|
FExcludedComponents: TStrings;
|
|
FHiddenComponents: TStrings;
|
|
FOptionsBehavior: TdxCustomContainerReportLinkOptionsBehavior;
|
|
FOptionsDesignerTabs: TdxCustomContainerReportLinkOptionsDesignerTabs;
|
|
//FOptionsItemPlace: TdxCustomContainerReportLinkOptionsItemPlace; {.2}
|
|
FOptionsPagination: TdxCustomContainerReportLinkOptionsPagination;
|
|
FOptionsRefinements: TdxCustomContainerReportLinkOptionsRefinements;
|
|
FOptionsTransparent: TdxCustomContainerReportLinkOptionsTransparent;
|
|
FPreparationFont: TFont;
|
|
FProducerCache: TdxPSCustomProducerCache;
|
|
FScreenDC: HDC;
|
|
FSupportedCustomDraw: Boolean;
|
|
FOnCustomDrawItem: TdxContainerReportLinkCustomDrawItemEvent;
|
|
FOnGetComponentCaption: TdxContainerReportLinkGetComponentCaptionEvent;
|
|
FOnGetComponentReportLink: TdxContainerReportLinkGetComponentReportLinkEvent;
|
|
FOnInitializeItem: TdxContainerReportLinkInitializeItemEvent;
|
|
FOnInitializeItemOptionsPlace: TdxContainerReportLinkInitializeItemOptionsPlaceEvent;
|
|
FOnInitializeReportLink: TdxContainerReportLinkInitializeReportLinkEvent;
|
|
FOnIsComponentProcessed: TdxContainerReportLinkIsComponentProcessedEvent;
|
|
function GetAggregatedReportLink(Index: Integer): TBasedxReportLink;
|
|
function GetAggregatedReportLinkCount: Integer;
|
|
function GetContainer: TWinControl;
|
|
function GetController: TdxCustomContainerReportLink;
|
|
function GetDefinition(Index: Integer): TdxPSCustomContainerItemDefinition;
|
|
function GetDefinitionByContainerItem(Component: TComponent): TdxPSCustomContainerItemDefinition;
|
|
function GetDefinitionByReportItem(Item: TdxReportVisualItem): TdxPSCustomContainerItemDefinition;
|
|
function GetDefinitionCount: Integer;
|
|
function GetDelimitersHorzCount: Integer;
|
|
function GetDelimitersHorzItem(Index: Integer): Integer;
|
|
function GetDelimitersVertCount: Integer;
|
|
function GetDelimitersVertItem(Index: Integer): Integer;
|
|
function GetDesignWindow: TdxfmCustomContainerDesignWindow;
|
|
function GetExcludedComponent(Index: Integer): TComponent;
|
|
function GetExcludedComponentCount: Integer;
|
|
function GetHiddenComponent(Index: Integer): TComponent;
|
|
function GetHiddenComponentCount: Integer;
|
|
function GetProducerByClass(ProducerClass: TdxPSCustomProducerClass; Component: TComponent): TdxPSCustomProducer;
|
|
function GetRootCell: TdxReportCell;
|
|
function GetTopLevelContainer: TWinControl;
|
|
procedure SetController(Value: TdxCustomContainerReportLink);
|
|
procedure SetOnCustomDrawItem(Value: TdxContainerReportLinkCustomDrawItemEvent);
|
|
procedure SetOptionsBehavior(Value: TdxCustomContainerReportLinkOptionsBehavior);
|
|
procedure SetOptionsDesignerTabs(Value: TdxCustomContainerReportLinkOptionsDesignerTabs);
|
|
//procedure SetOptionsItemPlace(Value: TdxCustomContainerReportLinkOptionsItemPlace); {.2}
|
|
procedure SetOptionsPagination(Value: TdxCustomContainerReportLinkOptionsPagination);
|
|
procedure SetOptionsRefinements(Value: TdxCustomContainerReportLinkOptionsRefinements);
|
|
procedure SetOptionsTransparent(Value: TdxCustomContainerReportLinkOptionsTransparent);
|
|
procedure SetSupportedCustomDraw(Value: Boolean);
|
|
|
|
procedure LoadAggregatedReportLinks;
|
|
procedure ReadAggregatedReportLinks(Stream: TStream);
|
|
procedure WriteAggregatedReportLinks(Stream: TStream);
|
|
|
|
procedure LoadExcludedComponents;
|
|
procedure ReadExcludedComponents(Stream: TStream);
|
|
procedure WriteExcludedComponents(Stream: TStream);
|
|
|
|
procedure LoadHiddenComponents;
|
|
procedure ReadHiddenComponents(Stream: TStream);
|
|
procedure WriteHiddenComponents(Stream: TStream);
|
|
protected
|
|
procedure DefineProperties(Filer: TFiler); override;
|
|
procedure Loaded; override;
|
|
procedure Notification(AComponent: TComponent; Operation: TOperation); override;
|
|
|
|
procedure AfterDesignReport(ADone: Boolean); override;
|
|
procedure BeforeDesignReport; override;
|
|
procedure ConstructReport(AReportCells: TdxReportCells); override;
|
|
procedure ConvertCoords; override;
|
|
procedure CustomDraw(AItem: TAbstractdxReportCellData; ACanvas: TCanvas; ABoundsRect, AClientRect: TRect; var ADone: Boolean); override;
|
|
procedure DoApplyInDesigner; override;
|
|
procedure DoChangeComponent; override;
|
|
function GetDesignerClass: TdxReportLinkDesignWindowClass; override;
|
|
function GetEmptyPagesCanExist: Boolean; override;
|
|
procedure GetImageLists(AProc: TdxPSGetImageListProc); override;
|
|
procedure InternalRestoreDefaults; override;
|
|
|
|
function IsSupportedCustomDraw(Item: TAbstractdxReportCellData): Boolean; override;
|
|
procedure MakeDelimiters(AReportCells: TdxReportCells; AHorzDelimiters, AVertDelimiters: TList); override;
|
|
|
|
function BuildContainer(AContainer: TWinControl; AParentBuilder: TdxPSContainerBuilder; AParentHost: TdxReportCell = nil): TdxReportCell;
|
|
function CreateBuilder(AContainer: TWinControl; AParentBuilder: TdxPSContainerBuilder; AParentHost: TdxReportCell = nil): TdxPSContainerBuilder;
|
|
function CreateItemDefinition(AComponent: TComponent; AnItem: TdxReportVisualItem): TdxPSCustomContainerItemDefinition;
|
|
|
|
function GetProducer(Component: TComponent): TdxPSCustomProducer;
|
|
|
|
procedure DoCustomDrawItem(ACanvas: TCanvas; AnItem: TAbstractdxReportCellData; var ADone: Boolean); dynamic;
|
|
procedure DoGetComponentCaption(AComponent: TComponent; var ACaption: string); dynamic;
|
|
function DoGetReportLink(AComponent: TComponent): TBasedxReportLink; dynamic;
|
|
procedure DoInitializeItem(AnItem: TdxReportVisualItem); dynamic;
|
|
procedure DoInitializeItemOptionsPlace(AnItem: TdxReportVisualItem); dynamic;
|
|
procedure DoInitializeReportLink(AReportLink: TBasedxReportLink; AStage: TdxPSReportLinkProcessingStage); dynamic;
|
|
function DoIsComponentProcessed(AComponent: TComponent): Boolean; dynamic;
|
|
|
|
procedure PrepareConstruct; virtual;
|
|
procedure UnprepareConstruct; virtual;
|
|
|
|
procedure CreateOptions; virtual;
|
|
procedure DestroyOptions; virtual;
|
|
function GetOptionsBehaviorClass: TdxCustomContainerReportLinkOptionsBehaviorClass; dynamic;
|
|
function GetOptionsDesignerTabsClass: TdxCustomContainerReportLinkOptionsDesignerTabsClass; dynamic;
|
|
function GetOptionsItemPlaceClass: TdxCustomContainerReportLinkOptionsItemPlaceClass; dynamic;
|
|
function GetOptionsPaginationClass: TdxCustomContainerReportLinkOptionsPaginationClass; dynamic;
|
|
function GetOptionsRefinementsClass: TdxCustomContainerReportLinkOptionsRefinementsClass; dynamic;
|
|
function GetOptionsTransparentClass: TdxCustomContainerReportLinkOptionsTransparentClass; dynamic;
|
|
procedure OptionsModified(AnOptions: TdxCustomContainerReportLinkOptions); dynamic;
|
|
|
|
procedure AddDefinition(ADefinition: TdxPSCustomContainerItemDefinition);
|
|
procedure ClearDefinitions;
|
|
procedure DeleteDefinition(Index: Integer);
|
|
function FindDefinition(AComponent: TComponent; out AnIndex: Integer): Boolean; overload;
|
|
function FindDefinition(AnItem: TdxReportVisualItem; out AnIndex: Integer): Boolean; overload;
|
|
procedure FreeAndNilDefinitions;
|
|
|
|
procedure AddControl(ATreeView: TTreeView; AParent: TTreeNode; AControl: TControl);
|
|
procedure AddHiddenControl(ATreeView: TTreeView; AParent: TTreeNode; AControl: TControl);
|
|
function AddNode(ATreeView: TTreeView; AParent: TTreeNode; AComponent: TComponent; AChecked: Boolean): TTreeNode;
|
|
function CreateNodeObject(AComponent: TComponent; AChecked: Boolean): TdxNodeObject; virtual;
|
|
function IsComponentEditable(AComponent: TComponent): Boolean; virtual;
|
|
procedure LoadControlsTree(ATreeView: TTreeView); virtual;
|
|
procedure LoadHiddenControlsTree(ATreeView: TTreeView); virtual;
|
|
|
|
procedure InstallAggregatedReportLinksController(AnInstall: Boolean);
|
|
|
|
function GetComponentByName(const AName: string): TComponent;
|
|
function GetPreparedFontIndex(AFont: TFont): Integer; overload;
|
|
function GetPreparedFontIndex(AFont: TFont; AnIsFontSubstitutable: Boolean;
|
|
const AFontName: string; AFontColor: TColor; AFontStyle: TFontStyles): Integer; overload;
|
|
function IsComponentProcessed(AComponent: TComponent): Boolean;
|
|
|
|
procedure AddDelimiters; virtual;
|
|
procedure CreateRootLookAndFeel; virtual;
|
|
procedure HideDesignerTabs(ADesignWindow: TdxfmCustomContainerDesignWindow); virtual;
|
|
procedure PullReportItems; virtual;
|
|
procedure RepositionControls; virtual;
|
|
//
|
|
function NeedTwoPassRendering: Boolean; override;
|
|
function IsScaleGridLines: Boolean; override;
|
|
|
|
property ActiveBuilder: TdxPSContainerBuilder read FActiveBuilder;
|
|
property Controller: TdxCustomContainerReportLink read GetController write SetController;
|
|
property DefinitionCount: Integer read GetDefinitionCount;
|
|
property Definitions[Index: Integer]: TdxPSCustomContainerItemDefinition read GetDefinition;
|
|
property DefinitionsByContainerItem[Component: TComponent]: TdxPSCustomContainerItemDefinition read GetDefinitionByContainerItem;
|
|
property DefinitionsByReportItem[Item: TdxReportVisualItem]: TdxPSCustomContainerItemDefinition read GetDefinitionByReportItem;
|
|
property DelimitersHorz: TList read FDelimitersHorz;
|
|
property DelimitersHorzCount: Integer read GetDelimitersHorzCount;
|
|
property DelimitersHorzItems[Index: Integer]: Integer read GetDelimitersHorzItem;
|
|
property DelimitersVert: TList read FDelimitersVert;
|
|
property DelimitersVertCount: Integer read GetDelimitersVertCount;
|
|
property DelimitersVertItems[Index: Integer]: Integer read GetDelimitersVertItem;
|
|
property PreparationFont: TFont read FPreparationFont;
|
|
property ProducerCache: TdxPSCustomProducerCache read FProducerCache;
|
|
property Producers[Component: TComponent]: TdxPSCustomProducer read GetProducer;
|
|
property RootCell: TdxReportCell read GetRootCell;
|
|
property ScreenDC: HDC read FScreenDC;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TPersistent); override;
|
|
|
|
class function Aggregable: Boolean; override;
|
|
|
|
function CanHideComponent(AComponent: TComponent): Boolean;
|
|
function CanHideComponentByName(const AName: string): Boolean;
|
|
procedure HideComponent(AComponent: TComponent);
|
|
procedure HideComponentByName(const AName: string);
|
|
procedure HideComponents(const AComponents: array of TComponent);
|
|
procedure HideComponentsByName(const ANames: array of string);
|
|
function FindHiddenComponent(AComponent: TComponent; out AnIndex: Integer): Boolean; overload;
|
|
function FindHiddenComponent(AComponent: TComponent): Boolean; overload;
|
|
function FindHiddenComponentByName(const AName: string; out AnIndex: Integer): Boolean; overload;
|
|
function FindHiddenComponentByName(const AName: string): Boolean; overload;
|
|
procedure UnhideAllComponents;
|
|
procedure UnhideComponent(AComponent: TComponent);
|
|
procedure UnhideComponentByName(const AName: string);
|
|
procedure UnhideComponents(const AComponents: array of TComponent);
|
|
procedure UnhideComponentsByName(const ANames: array of string);
|
|
|
|
procedure HideStandardControls;
|
|
procedure UnhideStandardControls;
|
|
|
|
function CanExcludeComponent(AComponent: TComponent): Boolean;
|
|
function CanExcludeComponentByName(const AName: string): Boolean;
|
|
procedure ExcludeComponent(AComponent: TComponent);
|
|
procedure ExcludeComponentByName(const AName: string);
|
|
procedure ExcludeComponents(const AComponents: array of TComponent);
|
|
procedure ExcludeComponentsByName(const ANames: array of string);
|
|
function FindExcludedComponent(AComponent: TComponent; out AnIndex: Integer): Boolean; overload;
|
|
function FindExcludedComponent(AComponent: TComponent): Boolean; overload;
|
|
function FindExcludedComponentByName(const AName: string; out AnIndex: Integer): Boolean; overload;
|
|
function FindExcludedComponentByName(const AName: string): Boolean; overload;
|
|
procedure UnexcludeAllComponents;
|
|
procedure UnexcludeComponent(AComponent: TComponent);
|
|
procedure UnexcludeComponentByName(const AName: string);
|
|
procedure UnexcludeComponents(const AComponents: array of TComponent);
|
|
procedure UnexcludeComponentsByName(const ANames: array of string);
|
|
|
|
procedure AggregateLink(AReportLink: TBasedxReportLink);
|
|
procedure DisaggregateAllLinks;
|
|
procedure DisaggregateInconsistentLinks;
|
|
procedure DisaggregateLink(AReportLink: TBasedxReportLink);
|
|
function FindAggregatedLinkByComponent(AComponent: TComponent): TBasedxReportLink;
|
|
function HasInconsistentlyAggregatedLinks: Boolean;
|
|
function IsLinkAggregable(AReportLink: TBasedxReportLink): Boolean;
|
|
function IsLinkAggregated(AReportLink: TBasedxReportLink): Boolean;
|
|
function IsLinkAggregatedConsistently(AReportLink: TBasedxReportLink): Boolean;
|
|
|
|
property AggregatedReportLinkCount: Integer read GetAggregatedReportLinkCount;
|
|
property AggregatedReportLinks[Index: Integer]: TBasedxReportLink read GetAggregatedReportLink;
|
|
property Container: TWinControl read GetContainer;
|
|
property DesignWindow: TdxfmCustomContainerDesignWindow read GetDesignWindow;
|
|
property ExcludedComponentCount: Integer read GetExcludedComponentCount;
|
|
property ExcludedComponents[Index: Integer]: TComponent read GetExcludedComponent;
|
|
property HiddenComponentCount: Integer read GetHiddenComponentCount;
|
|
property HiddenComponents[Index: Integer]: TComponent read GetHiddenComponent;
|
|
property ProducersByClass[ProducerClass: TdxPSCustomProducerClass; Component: TComponent]: TdxPSCustomProducer read GetProducerByClass;
|
|
property TopLevelContainer: TWinControl read GetTopLevelContainer;
|
|
published
|
|
property Color;
|
|
property Font;
|
|
property OptionsBehavior: TdxCustomContainerReportLinkOptionsBehavior read FOptionsBehavior write SetOptionsBehavior;
|
|
property OptionsDesignerTabs: TdxCustomContainerReportLinkOptionsDesignerTabs read FOptionsDesignerTabs write SetOptionsDesignerTabs;
|
|
//property OptionsItemPlace: TdxCustomContainerReportLinkOptionsItemPlace read FOptionsItemPlace write SetOptionsItemPlace; {.2}
|
|
property OptionsPagination: TdxCustomContainerReportLinkOptionsPagination read FOptionsPagination write SetOptionsPagination;
|
|
property OptionsRefinements: TdxCustomContainerReportLinkOptionsRefinements read FOptionsRefinements write SetOptionsRefinements;
|
|
property OptionsTransparent: TdxCustomContainerReportLinkOptionsTransparent read FOptionsTransparent write SetOptionsTransparent;
|
|
property ScaleFonts;
|
|
property SupportedCustomDraw: Boolean read FSupportedCustomDraw write SetSupportedCustomDraw default False;
|
|
|
|
property OnCustomDrawItem: TdxContainerReportLinkCustomDrawItemEvent read FOnCustomDrawItem write SetOnCustomDrawItem;
|
|
property OnGetComponentCaption: TdxContainerReportLinkGetComponentCaptionEvent read FOnGetComponentCaption write FOnGetComponentCaption;
|
|
property OnGetComponentReportLink: TdxContainerReportLinkGetComponentReportLinkEvent read FOnGetComponentReportLink write FOnGetComponentReportLink;
|
|
property OnInitializeItem: TdxContainerReportLinkInitializeItemEvent read FOnInitializeItem write FOnInitializeItem;
|
|
property OnInitializeItemOptionsPlace: TdxContainerReportLinkInitializeItemOptionsPlaceEvent read FOnInitializeItemOptionsPlace write FOnInitializeItemOptionsPlace;
|
|
property OnInitializeReportLink: TdxContainerReportLinkInitializeReportLinkEvent read FOnInitializeReportLink write FOnInitializeReportLink;
|
|
property OnIsComponentProcessed: TdxContainerReportLinkIsComponentProcessedEvent read FOnIsComponentProcessed write FOnIsComponentProcessed;
|
|
end;
|
|
|
|
{$IFDEF DELPHI5}
|
|
{$IFNDEF DELPHI6}
|
|
{$DEFINE WMCONTEXTMENU}
|
|
{$ENDIF}
|
|
{$ENDIF}
|
|
|
|
TdxfmCustomContainerDesignWindow = class(TStandarddxReportLinkDesignWindow)
|
|
PageControl1: TPageControl;
|
|
tshOptions: TTabSheet;
|
|
tshReportLinks: TTabSheet;
|
|
tshControls: TTabSheet;
|
|
pmControls: TPopupMenu;
|
|
miControlsCheckAll: TMenuItem;
|
|
miLine1: TMenuItem;
|
|
miControlsCheckAllChildren: TMenuItem;
|
|
miControlsUncheckAllChildren: TMenuItem;
|
|
miLine2: TMenuItem;
|
|
miControlsExpandAll: TMenuItem;
|
|
lblTransparents: TLabel;
|
|
imgExpanding: TImage;
|
|
bvlTransparents: TBevel;
|
|
chbxTransparentRoot: TCheckBox;
|
|
chbxTransparentControls: TCheckBox;
|
|
chbxTransparentContainers: TCheckBox;
|
|
btnControlsCheckAll: TButton;
|
|
btnControlsExpandAll: TButton;
|
|
chbxTransparentGraphics: TCheckBox;
|
|
chbxTransparentGroups: TCheckBox;
|
|
chbxTransparentItems: TCheckBox;
|
|
lblPagination: TLabel;
|
|
imgPagination: TImage;
|
|
Bevel1: TBevel;
|
|
chbxPaginateByControlDetails: TCheckBox;
|
|
chbxPaginateByControls: TCheckBox;
|
|
chbxPaginateByGroups: TCheckBox;
|
|
chbxPaginateByItems: TCheckBox;
|
|
ilControls: TImageList;
|
|
tvControls: TTreeView;
|
|
ilControlsPopup: TImageList;
|
|
tshHiddenControls: TTabSheet;
|
|
tvHiddenControls: TTreeView;
|
|
btnHiddenControlsCheckAll: TButton;
|
|
btnHiddenControlsExpandAll: TButton;
|
|
miControlsUncheckStandardControls: TMenuItem;
|
|
miControlsCheckStandardControls: TMenuItem;
|
|
miLine3: TMenuItem;
|
|
lblSize: TLabel;
|
|
bvlSize: TBevel;
|
|
imgSize: TImage;
|
|
chbxAutoWidth: TCheckBox;
|
|
pnlBtnSite: TPanel;
|
|
btnLinksDesign: TButton;
|
|
pnlLinkListsSite: TPanel;
|
|
pnlAvailableLinksSite: TPanel;
|
|
lblAvailableLinks: TLabel;
|
|
lbxAvailableLinks: TListBox;
|
|
pnlMoveButtonsSite: TPanel;
|
|
sbtnRemove: TSpeedButton;
|
|
sbtnAdd: TSpeedButton;
|
|
pnlAggregatedLinksSite: TPanel;
|
|
lbxAggregatedLinks: TListBox;
|
|
lblAggregatedLinks: TLabel;
|
|
btnLinksRemoveInconsistents: TButton;
|
|
procedure TreeViewClick(Sender: TObject);
|
|
procedure TreeViewKeyDown(Sender: TObject; var Key: Word;
|
|
Shift: TShiftState);
|
|
procedure TreeViewKeyPress(Sender: TObject; var Key: Char);
|
|
procedure TreeViewCheckAllChildrenClick(Sender: TObject);
|
|
procedure TreeViewCheckAllClick(Sender: TObject);
|
|
procedure TreeViewUncheckAllChildrenClick(Sender: TObject);
|
|
procedure TreeViewExpandAllClick(Sender: TObject);
|
|
procedure pmControlsPopup(Sender: TObject);
|
|
procedure TreeViewCustomDrawItem(Sender: TCustomTreeView;
|
|
Node: TTreeNode; State: TCustomDrawState; var DefaultDraw: Boolean);
|
|
procedure DesignClick(Sender: TObject);
|
|
procedure lbxAggregatedLinksClick(Sender: TObject);
|
|
procedure TreeViewChange(Sender: TObject; Node: TTreeNode);
|
|
procedure TransparentClick(Sender: TObject);
|
|
procedure lbxAggregatedLinksDrawItem(Control: TWinControl; Index: Integer;
|
|
Rect: TRect; State: TOwnerDrawState);
|
|
procedure PaginationClick(Sender: TObject);
|
|
procedure TreeViewMouseUp(Sender: TObject; Button: TMouseButton;
|
|
Shift: TShiftState; X, Y: Integer);
|
|
procedure PageControl1Change(Sender: TObject);
|
|
procedure PageControl1Changing(Sender: TObject;
|
|
var AllowChange: Boolean);
|
|
procedure HideStandardControlsClick(Sender: TObject);
|
|
procedure UnhideStandardControlsClick(Sender: TObject);
|
|
procedure SizeClick(Sender: TObject);
|
|
procedure sbtnAddClick(Sender: TObject);
|
|
procedure sbtnRemoveClick(Sender: TObject);
|
|
procedure tshReportLinksResize(Sender: TObject);
|
|
procedure lbxAvailableLinksKeyDown(Sender: TObject; var Key: Word;
|
|
Shift: TShiftState);
|
|
procedure lbxAggregatedLinksKeyDown(Sender: TObject; var Key: Word;
|
|
Shift: TShiftState);
|
|
procedure lbxAvailableLinksDragOver(Sender, Source: TObject; X,
|
|
Y: Integer; State: TDragState; var Accept: Boolean);
|
|
procedure lbxAvailableLinksDragDrop(Sender, Source: TObject; X,
|
|
Y: Integer);
|
|
procedure lbxAggregatedLinksDragOver(Sender, Source: TObject; X,
|
|
Y: Integer; State: TDragState; var Accept: Boolean);
|
|
procedure lbxAggregatedLinksDragDrop(Sender, Source: TObject; X,
|
|
Y: Integer);
|
|
procedure lbxAggregatedLinksDblClick(Sender: TObject);
|
|
procedure lbxAvailableLinksDblClick(Sender: TObject);
|
|
procedure btnLinksRemoveInconsistentsClick(Sender: TObject);
|
|
private
|
|
FAreHiddenControlsChanged: Boolean;
|
|
{$IFDEF WMCONTEXTMENU}
|
|
FControlsTreeViewWndProc: TWndMethod;
|
|
FHiddenControlsTreeViewWndProc: TWndMethod;
|
|
{$ENDIF}
|
|
FLastActiveTab: TTabSheet;
|
|
function GetAggregatedLink(Index: Integer): TBasedxReportLink;
|
|
function GetAggregatedLinkCount: Integer;
|
|
function GetAggregatedLinkSelected(Index: Integer): Boolean;
|
|
function GetAvailableLink(Index: Integer): TBasedxReportLink;
|
|
function GetAvailableLinkCount: Integer;
|
|
function GetAvailableLinkSelected(Index: Integer): Boolean;
|
|
function GetControlsTab: TTabSheet;
|
|
function GetHiddenControlsTab: TTabSheet;
|
|
function GetReportLink: TdxCustomContainerReportLink;
|
|
function GetReportLinksTab: TTabSheet;
|
|
function GetSelectedReportLink: TBasedxReportLink;
|
|
|
|
procedure DoCheckAllChildren(ANode: TTreeNode; AChecked: Boolean);
|
|
procedure DoToggleNodeState(ANode: TTreeNode);
|
|
|
|
function CanAggregate: Boolean;
|
|
function CanDesign: Boolean;
|
|
function CanDisaggregate: Boolean;
|
|
function CanRemoveInconsistents: Boolean;
|
|
//function CanSelectAll(AListBox: TListBox): Boolean;
|
|
procedure DoAggregateSelectedLinks;
|
|
procedure DoDisaggregateSelectedLinks;
|
|
procedure DoSelectAll(AListBox: TListBox);
|
|
procedure RefreshAggregatedLinks;
|
|
procedure RefreshAvailableLinks;
|
|
|
|
{$IFDEF WMCONTEXTMENU}
|
|
procedure ControlsTreeViewWndProc(var Message: TMessage);
|
|
procedure HiddenControlsTreeViewWndProc(var Message: TMessage);
|
|
procedure ProcessContextMenu(AMessage: TWMContextMenu; ATreeView: TTreeView);
|
|
procedure RestoreTreeViewsWndProc;
|
|
procedure SubstituteTreeViewsWndProc;
|
|
{$ENDIF}
|
|
protected
|
|
procedure BeforeConstruction; override;
|
|
procedure DoInitialize; override;
|
|
procedure LoadStrings; override;
|
|
procedure UpdateControlsState; override;
|
|
|
|
function GetActiveTreeView: TTreeView; virtual;
|
|
procedure InitializeControlsTree; virtual;
|
|
procedure InitializeHiddenControlsTree; virtual;
|
|
function IsBoldNode(ANode: TTreeNode): Boolean; virtual;
|
|
procedure RefreshControlsTree;
|
|
procedure RefreshHiddenControlsTree;
|
|
procedure RefreshReportLinksList;
|
|
|
|
procedure SetOptionsPaginationByIndex(AnIndex: Integer; AValue: Boolean); virtual;
|
|
//procedure SetOptionsPlaceByIndex(AnIndex: Integer; AValue: Boolean); virtual; {.2}
|
|
procedure SetOptionsSizeByIndex(AnIndex: Integer; AValue: Boolean); virtual;
|
|
procedure SetOptionsTransparentByIndex(AnIndex: Integer; AValue: Boolean); virtual;
|
|
|
|
{$IFDEF DELPHI5}
|
|
procedure TreeView_AdvancedCustomDrawItem(Sender: TCustomTreeView;
|
|
Node: TTreeNode; State: TCustomDrawState; Stage: TCustomDrawStage;
|
|
var PaintImages, DefaultDraw: Boolean);
|
|
{$ENDIF}
|
|
procedure TreeView_BeginUpdate;
|
|
procedure TreeView_CheckAllChildren(ANode: TTreeNode; AChecked: Boolean);
|
|
procedure TreeView_EndUpdate;
|
|
procedure TreeView_FreeNodeObjects(ATreeView: TTreeView);
|
|
function TreeView_HasCheckedChildren(ANode: TTreeNode): Boolean;
|
|
function TreeView_HasRoot(ATreeView: TTreeView): Boolean;
|
|
function TreeView_HasUncheckedChildren(ANode: TTreeNode): Boolean;
|
|
function TreeView_GetNodeObject(ANode: TTreeNode): TdxNodeObject;
|
|
function TreeView_getRoot(ATreeView: TTreeView): TTreeNode; // API function TreeView_GetRoot already exists
|
|
function TreeView_IsNodeEditable(ANode: TTreeNode): Boolean;
|
|
procedure TreeView_NormalizeNode(ANode: TTreeNode);
|
|
procedure TreeView_SetNodeState(ANode: TTreeNode; AState: TCheckBoxState);
|
|
procedure TreeView_ToggleNodeState(ANode: TTreeNode);
|
|
procedure TreeView_UpdateNodeImage(ANode: TTreeNode);
|
|
procedure TreeView_UpdateNodesState(ANode: TTreeNode);
|
|
|
|
property ActiveTreeView: TTreeView read GetActiveTreeView;
|
|
property ControlsTab: TTabSheet read GetControlsTab;
|
|
property HiddenControlsTab: TTabSheet read GetHiddenControlsTab;
|
|
property ReportLinksTab: TTabSheet read GetReportLinksTab;
|
|
property SelectedReportLink: TBasedxReportLink read GetSelectedReportLink;
|
|
|
|
property AggregatedLinkCount: Integer read GetAggregatedLinkCount;
|
|
property AggregatedLinks[Index: Integer]: TBasedxReportLink read GetAggregatedLink;
|
|
property AggregatedLinkSelected[Index: Integer]: Boolean read GetAggregatedLinkSelected;
|
|
property AvailableLinkCount: Integer read GetAvailableLinkCount;
|
|
property AvailableLinks[Index: Integer]: TBasedxReportLink read GetAvailableLink;
|
|
property AvailableLinkSelected[Index: Integer]: Boolean read GetAvailableLinkSelected;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
destructor Destroy; override;
|
|
|
|
property ReportLink: TdxCustomContainerReportLink read GetReportLink;
|
|
end;
|
|
|
|
function dxPSIsComponentContainer(AComponentClass: TClass): Boolean; overload;
|
|
function dxPSIsComponentContainer(AComponent: TObject{TComponent}): Boolean; overload;
|
|
procedure dxPSRegisterContainer(AContainerClass: TWinControlClass;
|
|
ADesignerClass: TdxReportLinkDesignWindowClass = nil{TdxfmCustomContainerDesignWindow});
|
|
procedure dxPSRegisterContainers(const AContainerClasses: array of TWinControlClass;
|
|
ADesignerClass: TdxReportLinkDesignWindowClass = nil{TdxfmCustomContainerDesignWindow});
|
|
procedure dxPSUnregisterContainer(AContainerClass: TWinControlClass;
|
|
ADesignerClass: TdxReportLinkDesignWindowClass = nil{TdxfmCustomContainerDesignWindow});
|
|
procedure dxPSUnregisterContainers(const AContainerClasses: array of TWinControlClass;
|
|
ADesignerClass: TdxReportLinkDesignWindowClass = nil{TdxfmCustomContainerDesignWindow});
|
|
|
|
function dxPSMakeFriendlyNameFromStrings(AStrings: TStrings): string;
|
|
|
|
const
|
|
BevelShapeMap: array[TBevelShape] of TdxCellSides =
|
|
(csAll, csAll, [csTop], [csBottom], [csLeft], [csRight], []);
|
|
BevelStyleMap: array[TBevelStyle, TBevelShape] of TdxPSCellBorderClass =
|
|
((TdxPSCellSunkenSoftBorder, TdxPSCellEtchedBorder, TdxPSCellRaisedSoftBorder,
|
|
TdxPSCellRaisedSoftBorder, TdxPSCellRaisedSoftBorder, TdxPSCellRaisedSoftBorder, TdxPSCellNullBorder),
|
|
(TdxPSCellRaisedSoftBorder, TdxPSCellBumpedBorder, TdxPSCellRaisedBorder,
|
|
TdxPSCellRaisedBorder, TdxPSCellRaisedBorder, TdxPSCellRaisedBorder, TdxPSCellNullBorder));
|
|
BorderStyleMap: array[TBorderStyle] of TdxCellSides = ([], csAll);
|
|
BrushStyleMap: array[TBrushStyle] of TdxPSFillPatternClass =
|
|
(TdxPSSolidFillPattern, nil, TdxPSHorizontalFillPattern, TdxPSVerticalFillPattern,
|
|
TdxPSFDiagonalFillPattern, TdxPSBDiagonalFillPattern, TdxPSCrossFillPattern,
|
|
TdxPSDiagCrossFillPattern);
|
|
CheckAlignmentMap: array[TLeftRight] of TdxCellCheckPos = (ccpRight, ccpLeft);
|
|
Ctl3DBorderClassMap: array[Boolean] of TdxPSCellBorderClass = (TdxPSCellUltraFlatBorder, TdxPSCellSunkenBorder);
|
|
PanelBevelsMap: array[TPanelBevel, TPanelBevel] of TdxPSCellBorderClass =
|
|
((TdxPSCellNullBorder, TdxPSCellSunkenSoftBorder, TdxPSCellRaisedSoftBorder, TdxPSCellRaisedSoftBorder),
|
|
(TdxPSCellSunkenSoftBorder, TdxPSCellSunkenBorder, TdxPSCellBumpedBorder, TdxPSCellBumpedBorder),
|
|
(TdxPSCellRaisedSoftBorder, TdxPSCellEtchedBorder, TdxPSCellRaisedBorder, TdxPSCellRaisedBorder),
|
|
(TdxPSCellRaisedSoftBorder, TdxPSCellEtchedBorder, TdxPSCellRaisedBorder, TdxPSCellRaisedBorder));
|
|
PanelSingleBorderMap: array[Boolean] of TdxPSCellBorderClass = (TdxPSCellRaisedBorder, TdxPSCellEtchedBorder);
|
|
ShapeTypeMap: array[TShapeType] of TdxReportCellShapeClass =
|
|
(TdxReportCellRectangle, TdxReportCellSquare, TdxReportCellRoundRect,
|
|
TdxReportCellRoundSquare, TdxReportCellEllipse, TdxReportCellCircle);
|
|
|
|
MaxCaptionLength: Integer = 64;
|
|
|
|
ExpandHeightBit = $00000001;
|
|
ExpandHeightOffset = $00000000;
|
|
ExpandWidthBit = $00000002;
|
|
ExpandWidthOffset = $00000001;
|
|
ShrinkHeightBit = $00000004;
|
|
ShrinkHeightOffset = $00000002;
|
|
ShrinkWidthBit = $00000008;
|
|
ShrinkWidthOffset = $00000003;
|
|
|
|
StandardHiddenControlCount = 6;
|
|
StandardHiddenControls: array[0..StandardHiddenControlCount - 1] of string =
|
|
('TScrollBar', 'TSplitter', 'TControlBar', 'TToolBar', 'TCoolBar', 'TPageScroller');
|
|
|
|
implementation
|
|
|
|
{$R *.dfm}
|
|
|
|
uses
|
|
SysUtils, dxCore, cxClasses, cxControls, dxPSGlbl, dxPSUtl, dxPSRes, dxPSPopupMan;
|
|
|
|
const
|
|
StandardContainerCount = {$IFDEF DELPHI5} 11 {$ELSE} 10 {$ENDIF};
|
|
StandardContainers: array[0..StandardContainerCount - 1] of TWinControlClass =
|
|
(TPanel, TScrollBox, TTabControl, TTabSheet, TPageControl, TTabPage,
|
|
TTabbedNotebook, TPage, TNotebook, TCustomForm {$IFDEF DELPHI5}, TCustomFrame{$ENDIF});
|
|
|
|
DefaultControlDisabledContentColor: TColor = clBtnFace;
|
|
DefaultControlDisabledTextColor: TColor = clGrayText;
|
|
|
|
//{.1} - RootDesigner
|
|
//{.2} - ItemOptionsPlace
|
|
|
|
type
|
|
TBasedxReportLinkAccess = class(TBasedxReportLink);
|
|
|
|
|
|
TCustomCheckBoxAccess = class(TCustomCheckBox);
|
|
TCustomComboBoxAccess = class(TCustomComboBox);
|
|
{$IFDEF DELPHI6}
|
|
TCustomComboBoxExAccess = class(TCustomComboBoxEx);
|
|
{$ENDIF}
|
|
TCustomEditAccess = class(TCustomEdit);
|
|
TCustomGroupBoxAccess = class(TCustomGroupBox);
|
|
TCustomHotKeyAccess = class(TCustomHotKey);
|
|
TCustomLabelAccess = class(TCustomLabel);
|
|
TCustomMemoAccess = class(TCustomMemo);
|
|
TCustomPanelAccess = class(TCustomPanel);
|
|
TCustomRadioGroupAccess = class(TCustomRadioGroup);
|
|
TCustomStaticTextAccess = class(TCustomStaticText);
|
|
|
|
TdxPSNativePrintableControlProducerFactory = class(TdxCustomClassMaps)
|
|
private
|
|
function GetProducerClass(Component: TComponent): TdxPSNativePrintableControlProducerClass;
|
|
public
|
|
class function Instance: TdxPSNativePrintableControlProducerFactory; reintroduce; overload;
|
|
class procedure ReleaseInstance; override;
|
|
property ProducerClasses[Component: TComponent]: TdxPSNativePrintableControlProducerClass read GetProducerClass; default;
|
|
end;
|
|
|
|
TdxPSContainerItemProducerFactory = class(TdxCustomClassMaps)
|
|
private
|
|
function GetProducerClass(Component: TComponent; IsRoot: Boolean): TdxPSCustomProducerClass;
|
|
public
|
|
class function Instance: TdxPSContainerItemProducerFactory; reintroduce; overload;
|
|
class procedure ReleaseInstance; override;
|
|
property ProducerClasses[Component: TComponent; IsRoot: Boolean]: TdxPSCustomProducerClass read GetProducerClass; default;
|
|
end;
|
|
|
|
TdxPSProducerHelperFactory = class(TdxCustomClassMaps)
|
|
private
|
|
function GetItem(Index: Integer): TdxPSCustomProducerClass;
|
|
function GetProducerClass(ProducerClass: TdxPSCustomProducerClass): TdxPSCustomProducerClass;
|
|
public
|
|
class function Instance: TdxPSProducerHelperFactory; reintroduce; overload;
|
|
property Items[Index: Integer]: TdxPSCustomProducerClass read GetItem;
|
|
property ProducerClasses[ProducerClass: TdxPSCustomProducerClass]: TdxPSCustomProducerClass read GetProducerClass; default;
|
|
end;
|
|
|
|
TdxPSContainerBuilderFactory = class(TdxCustomClassMaps)
|
|
private
|
|
function GetBuilderClass(Control: TWinControl): TdxPSContainerBuilderClass;
|
|
protected
|
|
function CreateBuilder(AReportLink: TdxCustomContainerReportLink; AContainer: TWinControl;
|
|
AParentBuilder: TdxPSContainerBuilder; AParentHost: TdxReportCell = nil): TdxPSContainerBuilder;
|
|
public
|
|
class function Instance: TdxPSContainerBuilderFactory; reintroduce; overload;
|
|
class procedure ReleaseInstance; override;
|
|
property BuilderClasses[Control: TWinControl]: TdxPSContainerBuilderClass read GetBuilderClass; default;
|
|
end;
|
|
|
|
var
|
|
FInternalComponentPrinter: TdxComponentPrinter;
|
|
FIsNativePrintableControlProducerFactoryReleased: Boolean = False;
|
|
FIsContainerItemProducerFactoryReleased: Boolean = False;
|
|
FIsContainerBuilderFactoryReleased: Boolean = False;
|
|
|
|
function InternalComponentPrinter: TdxComponentPrinter;
|
|
begin
|
|
if FInternalComponentPrinter = nil then
|
|
FInternalComponentPrinter := TdxComponentPrinter.Create(nil);
|
|
Result := FInternalComponentPrinter;
|
|
end;
|
|
|
|
{ utility routines }
|
|
|
|
function dxPSMakeFriendlyNameFromStrings(AStrings: TStrings): string;
|
|
const
|
|
CR = #13;
|
|
LF = #10;
|
|
var
|
|
P: Integer;
|
|
begin
|
|
Result := AStrings[0];
|
|
if Length(Result) > MaxCaptionLength then
|
|
begin
|
|
Delete(Result, MaxCaptionLength, Length(Result) - MaxCaptionLength);
|
|
Result := Result + '...';
|
|
end;
|
|
|
|
repeat
|
|
P := Pos(LF, Result);
|
|
if P <> 0 then
|
|
Delete(Result, P, 1);
|
|
|
|
P := Pos(CR, Result);
|
|
if P <> 0 then
|
|
Delete(Result, P, 1);
|
|
|
|
if P <> 0 then
|
|
Insert(' ', Result, P);
|
|
until P = 0;
|
|
end;
|
|
|
|
{ Registration routines }
|
|
|
|
function dxPSIsComponentContainer(AComponentClass: TClass): Boolean;
|
|
begin
|
|
Result := TdxCustomContainerReportLink.Supports(AComponentClass);
|
|
end;
|
|
|
|
function dxPSIsComponentContainer(AComponent: TObject{TComponent}): Boolean;
|
|
begin
|
|
Result := TdxCustomContainerReportLink.Supports(AComponent);
|
|
end;
|
|
|
|
procedure dxPSRegisterContainer(AContainerClass: TWinControlClass;
|
|
ADesignerClass: TdxReportLinkDesignWindowClass = nil);
|
|
begin
|
|
if ADesignerClass = nil then
|
|
ADesignerClass := TdxfmCustomContainerDesignWindow;
|
|
dxPSRegisterReportLink(TdxCustomContainerReportLink, AContainerClass, ADesignerClass);
|
|
end;
|
|
|
|
procedure dxPSRegisterContainers(const AContainerClasses: array of TWinControlClass;
|
|
ADesignerClass: TdxReportLinkDesignWindowClass = nil);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
if ADesignerClass = nil then
|
|
ADesignerClass := TdxfmCustomContainerDesignWindow;
|
|
for I := 0 to High(AContainerClasses) do
|
|
dxPSRegisterContainer(AContainerClasses[I], ADesignerClass);
|
|
end;
|
|
|
|
procedure dxPSUnregisterContainer(AContainerClass: TWinControlClass;
|
|
ADesignerClass: TdxReportLinkDesignWindowClass = nil);
|
|
begin
|
|
if ADesignerClass = nil then
|
|
ADesignerClass := TdxfmCustomContainerDesignWindow;
|
|
dxPSUnregisterReportLink(TdxCustomContainerReportLink, AContainerClass, ADesignerClass);
|
|
end;
|
|
|
|
procedure dxPSUnregisterContainers(const AContainerClasses: array of TWinControlClass;
|
|
ADesignerClass: TdxReportLinkDesignWindowClass = nil);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
if ADesignerClass = nil then
|
|
ADesignerClass := TdxfmCustomContainerDesignWindow;
|
|
for I := 0 to High(AContainerClasses) do
|
|
dxPSUnregisterContainer(AContainerClasses[I], ADesignerClass);
|
|
end;
|
|
|
|
{ Helpers }
|
|
|
|
{ CheckBox Helpers }
|
|
|
|
function CheckBox_GetAlignment(AControl: TCustomCheckBox): TAlignment;
|
|
begin
|
|
Result := TCustomCheckBoxAccess(AControl).Alignment;
|
|
end;
|
|
|
|
function CheckBox_GetState(AControl: TCustomCheckBox): TCheckBoxState;
|
|
begin
|
|
Result := TCustomCheckBoxAccess(AControl).State;
|
|
end;
|
|
|
|
{ ComboBox Helpers }
|
|
|
|
function ComboBox_GetStyle(AControl: TCustomComboBox): TComboBoxStyle;
|
|
begin
|
|
Result := TCustomComboBoxAccess(AControl).Style;
|
|
end;
|
|
|
|
function ComboBox_GetCurrentText(AControl: TCustomComboBox): string;
|
|
begin
|
|
if ComboBox_GetStyle(AControl) = csDropDown then
|
|
Result := Control_GetText(AControl)
|
|
else
|
|
if AControl.ItemIndex <> -1 then
|
|
Result := AControl.Items[AControl.ItemIndex]
|
|
else
|
|
Result := ''
|
|
end;
|
|
|
|
{ Edit Helpers }
|
|
|
|
function Edit_GetBorderStyle(AControl: TCustomEdit): TBorderStyle;
|
|
begin
|
|
Result := TCustomEditAccess(AControl).BorderStyle;
|
|
end;
|
|
|
|
{ HotKey Helpers }
|
|
|
|
function HotKey_GetHotKey(AControl: TCustomHotKey): TShortCut;
|
|
begin
|
|
Result := TCustomHotKeyAccess(AControl).HotKey;
|
|
end;
|
|
|
|
{ Label Helpers }
|
|
|
|
function Label_GetAlignment(AControl: TCustomLabel): TAlignment;
|
|
begin
|
|
Result := TCustomLabelAccess(AControl).Alignment;
|
|
end;
|
|
|
|
function Label_GetAutoSize(AControl: TCustomLabel): Boolean;
|
|
begin
|
|
Result := TCustomLabelAccess(AControl).AutoSize;
|
|
end;
|
|
|
|
function Label_GetText(AControl: TCustomLabel): string;
|
|
begin
|
|
Result := TCustomLabelAccess(AControl).GetLabelText;
|
|
end;
|
|
|
|
function Label_GetLayout(AControl: TCustomLabel): TTextLayout;
|
|
begin
|
|
Result := TCustomLabelAccess(AControl).Layout;
|
|
end;
|
|
|
|
function Label_GetWordWrap(AControl: TCustomLabel): Boolean;
|
|
begin
|
|
Result := TCustomLabelAccess(AControl).WordWrap;
|
|
end;
|
|
|
|
{ Memo Helpers }
|
|
|
|
function Memo_GetAlignment(AControl: TCustomMemo): TAlignment;
|
|
begin
|
|
Result := TCustomMemoAccess(AControl).Alignment;
|
|
end;
|
|
|
|
function Memo_GetLines(AControl: TCustomMemo): TStrings;
|
|
begin
|
|
Result := TCustomMemoAccess(AControl).Lines;
|
|
end;
|
|
|
|
{ Panel Helpers }
|
|
|
|
function Panel_GetAlignment(AControl: TCustomPanel): TAlignment;
|
|
begin
|
|
Result := TCustomPanelAccess(AControl).Alignment;
|
|
end;
|
|
|
|
function Panel_GetBorderStyle(AControl: TCustomPanel): TBorderStyle;
|
|
begin
|
|
Result := TCustomPanelAccess(AControl).BorderStyle;
|
|
end;
|
|
|
|
function Panel_GetBevelInner(AControl: TCustomPanel): TPanelBevel;
|
|
begin
|
|
Result := TCustomPanelAccess(AControl).BevelInner;
|
|
end;
|
|
|
|
function Panel_GetBevelOuter(AControl: TCustomPanel): TPanelBevel;
|
|
begin
|
|
Result := TCustomPanelAccess(AControl).BevelOuter;
|
|
end;
|
|
|
|
{ RadioGroup Helpers }
|
|
|
|
function RadioGroup_GetColumns(AControl: TCustomRadioGroup): Integer;
|
|
begin
|
|
Result := TCustomRadioGroupAccess(AControl).Columns;
|
|
end;
|
|
|
|
function RadioGroup_GetItemIndex(AControl: TCustomRadioGroup): Integer;
|
|
begin
|
|
Result := TCustomRadioGroupAccess(AControl).ItemIndex;
|
|
end;
|
|
|
|
function RadioGroup_GetItems(AControl: TCustomRadioGroup): TStrings;
|
|
begin
|
|
Result := TCustomRadioGroupAccess(AControl).Items;
|
|
end;
|
|
|
|
{ StaticText Helpers }
|
|
|
|
function StaticText_GetAlignment(AControl: TCustomStaticText): TAlignment;
|
|
begin
|
|
Result := TCustomStaticTextAccess(AControl).Alignment;
|
|
end;
|
|
|
|
function StaticText_GetBorderStyle(AControl: TCustomStaticText): TStaticBorderStyle;
|
|
begin
|
|
Result := TCustomStaticTextAccess(AControl).BorderStyle
|
|
end;
|
|
|
|
{ TdxPSNativePrintableControlProducerFactory }
|
|
|
|
function dxPSNativePrintableControlProducerFactory: TdxPSNativePrintableControlProducerFactory;
|
|
begin
|
|
Result := TdxPSNativePrintableControlProducerFactory.Instance;
|
|
end;
|
|
|
|
class function TdxPSNativePrintableControlProducerFactory.Instance: TdxPSNativePrintableControlProducerFactory;
|
|
begin
|
|
Result := inherited Instance as TdxPSNativePrintableControlProducerFactory;
|
|
end;
|
|
|
|
class procedure TdxPSNativePrintableControlProducerFactory.ReleaseInstance;
|
|
begin
|
|
inherited;
|
|
FIsNativePrintableControlProducerFactoryReleased := True;
|
|
end;
|
|
|
|
function TdxPSNativePrintableControlProducerFactory.GetProducerClass(
|
|
Component: TComponent): TdxPSNativePrintableControlProducerClass;
|
|
begin
|
|
Result := TdxPSNativePrintableControlProducerClass(PairClasses[Component.ClassType]);
|
|
end;
|
|
|
|
{ TdxProducersFactory }
|
|
|
|
function dxPSContainerItemProducerFactory: TdxPSContainerItemProducerFactory;
|
|
begin
|
|
Result := TdxPSContainerItemProducerFactory.Instance;
|
|
end;
|
|
|
|
class function TdxPSContainerItemProducerFactory.Instance: TdxPSContainerItemProducerFactory;
|
|
begin
|
|
Result := inherited Instance as TdxPSContainerItemProducerFactory;
|
|
end;
|
|
|
|
class procedure TdxPSContainerItemProducerFactory.ReleaseInstance;
|
|
begin
|
|
inherited;
|
|
FIsContainerBuilderFactoryReleased := True;
|
|
end;
|
|
|
|
function TdxPSContainerItemProducerFactory.GetProducerClass(Component: TComponent;
|
|
IsRoot: Boolean): TdxPSCustomProducerClass;
|
|
begin
|
|
if not IsRoot then
|
|
Result := dxPSNativePrintableControlProducerFactory.ProducerClasses[Component]
|
|
else
|
|
Result := nil;
|
|
|
|
if (Result = nil) or not TdxPSNativePrintableControlProducerClass(Result).HasReportLink(Component) then
|
|
begin
|
|
Result := TdxPSCustomProducerClass(PairClasses[Component.ClassType]);
|
|
if Result.HelperProducer <> nil then
|
|
Result := Result.HelperProducer;
|
|
end;
|
|
end;
|
|
|
|
{ TdxPSProducerHelperFactory }
|
|
|
|
function dxPSProducerHelperFactory: TdxPSProducerHelperFactory;
|
|
begin
|
|
Result := TdxPSProducerHelperFactory.Instance;
|
|
end;
|
|
|
|
class function TdxPSProducerHelperFactory.Instance: TdxPSProducerHelperFactory;
|
|
begin
|
|
Result := inherited Instance as TdxPSProducerHelperFactory;
|
|
end;
|
|
|
|
function TdxPSProducerHelperFactory.GetItem(Index: Integer): TdxPSCustomProducerClass;
|
|
begin
|
|
Result := TdxPSCustomProducerClass(inherited Items[Index]);
|
|
end;
|
|
|
|
function TdxPSProducerHelperFactory.GetProducerClass(ProducerClass: TdxPSCustomProducerClass): TdxPSCustomProducerClass;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to Count - 1 do
|
|
begin
|
|
Result := Items[I];
|
|
if ProducerClass = Result.BuddyClass then Exit;
|
|
end;
|
|
Result := nil;
|
|
end;
|
|
|
|
{ TdxPSContainerBuilderFactory }
|
|
|
|
function dxContainerBuilderFactory: TdxPSContainerBuilderFactory;
|
|
begin
|
|
Result := TdxPSContainerBuilderFactory.Instance;
|
|
end;
|
|
|
|
class function TdxPSContainerBuilderFactory.Instance: TdxPSContainerBuilderFactory;
|
|
begin
|
|
Result := inherited Instance as TdxPSContainerBuilderFactory;
|
|
end;
|
|
|
|
class procedure TdxPSContainerBuilderFactory.ReleaseInstance;
|
|
begin
|
|
inherited;
|
|
FIsContainerBuilderFactoryReleased := True;
|
|
end;
|
|
|
|
function TdxPSContainerBuilderFactory.CreateBuilder(AReportLink: TdxCustomContainerReportLink;
|
|
AContainer: TWinControl; AParentBuilder: TdxPSContainerBuilder;
|
|
AParentHost: TdxReportCell = nil): TdxPSContainerBuilder;
|
|
begin
|
|
Result := BuilderClasses[AContainer].Create(AReportLink, AContainer, AParentBuilder, AParentHost);
|
|
end;
|
|
|
|
function TdxPSContainerBuilderFactory.GetBuilderClass(Control: TWinControl): TdxPSContainerBuilderClass;
|
|
begin
|
|
Result := TdxPSContainerBuilderClass(PairClasses[Control.ClassType]);
|
|
end;
|
|
|
|
{ TdxReportWinControlHost }
|
|
|
|
function TdxReportWinControlHost.MeasureHeight(DC: HDC): Integer;
|
|
|
|
procedure MeasureItem(AnItem: TdxReportVisualItem; var AValue: Integer);
|
|
var
|
|
V: Integer;
|
|
begin
|
|
if AnItem.Visible then
|
|
begin
|
|
V := AnItem.Top + AnItem.Height;
|
|
if AValue < V then AValue := V;
|
|
end;
|
|
end;
|
|
|
|
function MeasureNestedCells: Integer;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := 0;
|
|
for I := 0 to CellCount - 1 do
|
|
MeasureItem(Cells[I], Result);
|
|
end;
|
|
|
|
function MeasureNestedDataItems: Integer;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := 0;
|
|
for I := 0 to DataItemCount - 1 do
|
|
MeasureItem(DataItems[I], Result);
|
|
end;
|
|
|
|
begin
|
|
Result := Max(MeasureNestedDataItems, MeasureNestedCells);
|
|
if Result <> 0 then Inc(Result, 2);
|
|
end;
|
|
|
|
function TdxReportWinControlHost.MeasureWidth(DC: HDC): Integer;
|
|
|
|
procedure MeasureItem(AnItem: TdxReportVisualItem; var AValue: Integer);
|
|
var
|
|
V: Integer;
|
|
begin
|
|
if AnItem.Visible then
|
|
begin
|
|
V := AnItem.Left + AnItem.Width;
|
|
if AValue < V then AValue := V;
|
|
end;
|
|
end;
|
|
|
|
function MeasureNestedCells: Integer;
|
|
var
|
|
I: Integer;
|
|
Item: TdxReportVisualItem;
|
|
begin
|
|
Result := 0;
|
|
for I := 0 to CellCount - 1 do
|
|
begin
|
|
Item := Cells[I];
|
|
if Item <> ControlItem then MeasureItem(Item, Result);
|
|
end;
|
|
end;
|
|
|
|
function MeasureNestedDataItems: Integer;
|
|
var
|
|
I: Integer;
|
|
Item: TdxReportVisualItem;
|
|
begin
|
|
Result := 0;
|
|
for I := 0 to DataItemCount - 1 do
|
|
begin
|
|
Item := DataItems[I];
|
|
{if Item <> ControlItem then }MeasureItem(Item, Result);
|
|
end;
|
|
end;
|
|
|
|
begin
|
|
Result := Max(MeasureNestedDataItems, MeasureNestedCells);
|
|
if Result <> 0 then Inc(Result, 2);
|
|
end;
|
|
|
|
function TdxReportWinControlHost.GetControlItem: TdxReportVisualItem;
|
|
begin
|
|
if (DataItemCount <> 0) and (DataItems[0].Data <> 0) then
|
|
Result := DataItems[0]
|
|
else
|
|
if (CellCount <> 0) and (Cells[0].Data <> 0) then
|
|
Result := Cells[0]
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
procedure TdxReportWinControlHost.BoundsChanged;
|
|
begin
|
|
if HasControlItem then
|
|
begin
|
|
ControlItem.Width := Width;
|
|
ControlItem.Height := Height;
|
|
end;
|
|
end;
|
|
|
|
function TdxReportWinControlHost.GetHasControlItem: Boolean;
|
|
begin
|
|
Result := ControlItem <> nil;
|
|
end;
|
|
|
|
{ TdxReportNativePrintableControlHost }
|
|
|
|
function TdxReportNativePrintableControlHost.GetControlItem: TdxReportVisualItem;
|
|
begin
|
|
if CellCount <> 0 then
|
|
Result := Cells[0]
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
procedure TdxReportNativePrintableControlHost.BoundsChanged;
|
|
begin
|
|
inherited;
|
|
end;
|
|
|
|
{ TdxPSCustomContainerItemDefinition }
|
|
|
|
constructor TdxPSCustomContainerItemDefinition.Create(AReportLink: TdxCustomContainerReportLink;
|
|
AComponent: TComponent; AReportItem: TdxReportVisualItem);
|
|
begin
|
|
inherited Create;
|
|
FReportLink := AReportLink;
|
|
FComponent := AComponent;
|
|
FReportItem := AReportItem;
|
|
FOptionsPlace := AReportLink.GetOptionsItemPlaceClass.Create(AReportLink);
|
|
// FOptionsPlace.Assign(AReportLink.OptionsItemPlace); {.2}
|
|
end;
|
|
|
|
destructor TdxPSCustomContainerItemDefinition.Destroy;
|
|
begin
|
|
FreeAndNil(FOptionsPlace);
|
|
inherited;
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemDefinition.OptionsPagination: TdxCustomContainerReportLinkOptionsPagination;
|
|
begin
|
|
Result := ReportLink.OptionsPagination;
|
|
end;
|
|
|
|
procedure TdxPSCustomContainerItemDefinition.AddDelimitersHorz(AList: TList);
|
|
begin
|
|
end;
|
|
|
|
procedure TdxPSCustomContainerItemDefinition.AddDelimitersVert(AList: TList);
|
|
begin
|
|
end;
|
|
|
|
procedure TdxPSCustomContainerItemDefinition.AddReportItemToDelimitersHorz(AList: TList);
|
|
begin
|
|
with ReportItem do
|
|
begin
|
|
AList.Add(TObject(Integer(AbsoluteOrigin.X)));
|
|
AList.Add(TObject(Integer(AbsoluteOrigin.X + Width)));
|
|
end;
|
|
end;
|
|
|
|
procedure TdxPSCustomContainerItemDefinition.AddReportItemToDelimitersVert(AList: TList);
|
|
begin
|
|
with ReportItem do
|
|
begin
|
|
AList.Add(TObject(Integer(AbsoluteOrigin.Y)));
|
|
AList.Add(TObject(Integer(AbsoluteOrigin.Y + Height)));
|
|
end;
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemDefinition.GetSizeChangeReportItem: TdxReportVisualItem;
|
|
begin
|
|
Result := ReportItem;
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemDefinition.GetSizeMeasureReportItem: TdxReportVisualItem;
|
|
begin
|
|
Result := ReportItem;
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemDefinition.GetRootContainer: TWinControl;
|
|
begin
|
|
Result := ReportLink.Container;
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemDefinition.GetTopLevelRootContainer: TWinControl;
|
|
begin
|
|
Result := ReportLink.TopLevelContainer;
|
|
end;
|
|
|
|
{ TdxPSContainerControlDefinition }
|
|
|
|
procedure TdxPSContainerControlDefinition.AddDelimitersHorz(AList: TList);
|
|
begin
|
|
if OptionsPagination.Controls then AddReportItemToDelimitersHorz(AList);
|
|
end;
|
|
|
|
procedure TdxPSContainerControlDefinition.AddDelimitersVert(AList: TList);
|
|
begin
|
|
if OptionsPagination.Controls then AddReportItemToDelimitersVert(AList);
|
|
end;
|
|
|
|
function TdxPSContainerControlDefinition.GetControl: TControl;
|
|
begin
|
|
Result := TControl(Component);
|
|
end;
|
|
|
|
procedure TdxPSContainerControlDefinition.SetControl(Value: TControl);
|
|
begin
|
|
Component := Value;
|
|
end;
|
|
|
|
{ TdxPSNativePrintableControlDefinition }
|
|
|
|
constructor TdxPSNativePrintableControlDefinition.Create(AReportLink: TdxCustomContainerReportLink;
|
|
AComponent: TComponent; AReportItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
FDelimitersHorz := TList.Create;
|
|
FDelimitersVert := TList.Create;
|
|
end;
|
|
|
|
destructor TdxPSNativePrintableControlDefinition.Destroy;
|
|
begin
|
|
FreeAndNil(FDelimitersVert);
|
|
FreeAndNil(FDelimitersHorz);
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxPSNativePrintableControlDefinition.AddDelimitersHorz(AList: TList);
|
|
begin
|
|
with OptionsPagination do
|
|
begin
|
|
if Controls then
|
|
AddReportItemToDelimitersHorz(AList);
|
|
if ControlDetails then
|
|
dxPSUtl.dxAppendList(DelimitersHorz, AList);
|
|
end
|
|
end;
|
|
|
|
procedure TdxPSNativePrintableControlDefinition.AddDelimitersVert(AList: TList);
|
|
begin
|
|
with OptionsPagination do
|
|
begin
|
|
if Controls then
|
|
AddReportItemToDelimitersVert(AList);
|
|
if ControlDetails then
|
|
dxPSUtl.dxAppendList(DelimitersVert, AList);
|
|
end
|
|
end;
|
|
|
|
procedure TdxPSNativePrintableControlDefinition.GetData(AReportLink: TBasedxReportLink);
|
|
begin
|
|
with TBasedxReportLinkAccess(AReportLink) do
|
|
begin
|
|
InternalGetDelimiters(DelimitersHorz, DelimitersVert);
|
|
FReportDimension := MakePoint(ReportWidth, ReportHeight);
|
|
end;
|
|
ShiftDelimiters;
|
|
end;
|
|
|
|
procedure TdxPSNativePrintableControlDefinition.ShiftDelimiters;
|
|
var
|
|
Offset: TPoint;
|
|
begin
|
|
Offset := DelimitersOffset;
|
|
dxPSUtl.dxShiftIntegerListValues(DelimitersHorz, Offset.X);
|
|
dxPSUtl.dxShiftIntegerListValues(DelimitersVert, Offset.Y);
|
|
end;
|
|
|
|
function TdxPSNativePrintableControlDefinition.GetSizeChangeReportItem: TdxReportVisualItem;
|
|
begin
|
|
Result := ReportItem.Parent;
|
|
end;
|
|
|
|
function TdxPSNativePrintableControlDefinition.GetDelimitersOffset: TPoint;
|
|
var
|
|
Parent: TWinControl;
|
|
begin
|
|
Result := MakePoint(Control.Left, Control.Top);
|
|
Parent := Control.Parent;
|
|
while Parent <> TopLevelRootContainer do
|
|
begin
|
|
Inc(Result.X, Parent.Left);
|
|
Inc(Result.Y, Parent.Top);
|
|
Parent := Parent.Parent;
|
|
end;
|
|
end;
|
|
|
|
{ TdxPSContainerWinControlDefinition }
|
|
|
|
function TdxPSContainerWinControlDefinition.GetSizeChangeReportItem: TdxReportVisualItem;
|
|
begin
|
|
Result := ReportItem.Parent;
|
|
end;
|
|
|
|
{ TdxPSContainerDefinition }
|
|
|
|
function TdxPSContainerDefinition.GetSizeMeasureReportItem: TdxReportVisualItem;
|
|
begin
|
|
Result := ReportItem.Parent;
|
|
end;
|
|
|
|
{ TdxPSWinControlIterator }
|
|
|
|
constructor TdxPSWinControlIterator.Create(AControl: TWinControl);
|
|
begin
|
|
inherited Create;
|
|
FControl := AControl;
|
|
FCounter := -1;
|
|
end;
|
|
|
|
class function TdxPSWinControlIterator.ContainerClass: TWinControlClass;
|
|
begin
|
|
Result := TWinControl;
|
|
end;
|
|
|
|
function TdxPSWinControlIterator.GetControl(Index: Integer): TControl;
|
|
begin
|
|
Result := Control.Controls[Index];
|
|
end;
|
|
|
|
function TdxPSWinControlIterator.GetControlCount: Integer;
|
|
begin
|
|
Result := Control.ControlCount;
|
|
end;
|
|
|
|
procedure TdxPSWinControlIterator.GoBeforeBOF;
|
|
begin
|
|
FCounter := -1;
|
|
end;
|
|
|
|
procedure TdxPSWinControlIterator.GoBeyondEOF;
|
|
begin
|
|
FCounter := ControlCount;
|
|
end;
|
|
|
|
function TdxPSWinControlIterator.IsBOF: Boolean;
|
|
begin
|
|
Result := FCounter < 1;
|
|
end;
|
|
|
|
function TdxPSWinControlIterator.IsEOF: Boolean;
|
|
begin
|
|
Result := FCounter + 1 = ControlCount;
|
|
end;
|
|
|
|
function TdxPSWinControlIterator.Next: TControl;
|
|
begin
|
|
if not IsEOF then
|
|
begin
|
|
Inc(FCounter);
|
|
Result := Controls[FCounter];
|
|
end
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
function TdxPSWinControlIterator.Prev: TControl;
|
|
begin
|
|
if not IsBOF then
|
|
begin
|
|
Dec(FCounter);
|
|
Result := Controls[FCounter];
|
|
end
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
{ TdxPSCustomProducer }
|
|
|
|
constructor TdxPSCustomProducer.Create(AReportLink: TdxCustomContainerReportLink;
|
|
AnObject: TComponent);
|
|
begin
|
|
inherited Create;
|
|
FReportLink := AReportLink;
|
|
Initialize(AnObject);
|
|
end;
|
|
|
|
class function TdxPSCustomProducer.CanHasAvailableChildren: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
class function TdxPSCustomProducer.HasNativeSupportForBorders: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
class function TdxPSCustomProducer.Reenterable: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TdxPSCustomProducer.Definition: TdxPSCustomContainerItemDefinition;
|
|
begin
|
|
Result := ReportLink.DefinitionsByContainerItem[ProducingObject];
|
|
end;
|
|
|
|
class function TdxPSCustomProducer.DefinitionClass: TdxPSCustomContainerItemDefinitionClass;
|
|
begin
|
|
Result := TdxPSCustomContainerItemDefinition;
|
|
end;
|
|
|
|
procedure TdxPSCustomProducer.Initialize(AnObject: TComponent);
|
|
begin
|
|
FProducingObject := AnObject;
|
|
end;
|
|
|
|
function TdxPSCustomProducer.ProducingObject: TComponent;
|
|
begin
|
|
Result := FProducingObject;
|
|
end;
|
|
|
|
function TdxPSCustomProducer.ProducingObjectFriendlyName: string;
|
|
begin
|
|
Result := ProducingObject.Name;
|
|
end;
|
|
|
|
function TdxPSCustomProducer.ReportLink: TdxCustomContainerReportLink;
|
|
begin
|
|
Result := FReportLink;
|
|
end;
|
|
|
|
procedure TdxPSCustomProducer.Reposition;
|
|
begin
|
|
DoReposition;
|
|
end;
|
|
|
|
function TdxPSCustomProducer.RootContainer: TWinControl;
|
|
begin
|
|
Result := ReportLink.Container;
|
|
end;
|
|
|
|
function TdxPSCustomProducer.TopLevelRootContainer: TWinControl;
|
|
begin
|
|
Result := ReportLink.TopLevelContainer;
|
|
end;
|
|
|
|
class procedure TdxPSCustomProducer.Register;
|
|
begin
|
|
dxPSContainerItemProducerFactory.Register(Self);
|
|
end;
|
|
|
|
class procedure TdxPSCustomProducer.Unregister;
|
|
begin
|
|
if not FIsContainerItemProducerFactoryReleased then dxPSContainerItemProducerFactory.Unregister(Self);
|
|
end;
|
|
|
|
class function TdxPSCustomProducer.HelperProducer: TdxPSCustomProducerClass;
|
|
begin
|
|
Result := dxPSProducerHelperFactory[Self];
|
|
end;
|
|
|
|
class function TdxPSCustomProducer.BuddyClass: TdxPSCustomProducerClass;
|
|
begin
|
|
Result := nil;
|
|
end;
|
|
|
|
function TdxPSCustomProducer.CanProcessChild(AChildControl: TControl): Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TdxPSCustomProducer.GetScrollPosLeft: Integer;
|
|
begin
|
|
Result := 0;
|
|
end;
|
|
|
|
function TdxPSCustomProducer.GetScrollPosTop: Integer;
|
|
begin
|
|
Result := 0;
|
|
end;
|
|
|
|
procedure TdxPSCustomProducer.GetImageLists(AProc: TdxPSGetImageListProc);
|
|
begin
|
|
end;
|
|
|
|
procedure TdxPSCustomProducer.InitializeOptionsPlace(AnOptions: TdxCustomContainerReportLinkOptionsItemPlace);
|
|
begin
|
|
with AnOptions do
|
|
begin
|
|
ExpandHeight := ObjectExpandHeight;
|
|
ExpandWidth := ObjectExpandWidth;
|
|
ShrinkHeight := ObjectShrinkHeight;
|
|
ShrinkWidth := ObjectShrinkWidth;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxPSCustomProducer.DoReposition;
|
|
var
|
|
ItemHeight, ItemWidth: Integer;
|
|
begin
|
|
with Definition do
|
|
begin
|
|
if OptionsPlace.HasVertResizing then
|
|
begin
|
|
ItemHeight := MeasureItemHeight(SizeMeasureReportItem);
|
|
if OptionsPlace.ExpandHeight and (SizeChangeReportItem.Height < ItemHeight) then
|
|
SizeChangeReportItem.Height := ItemHeight;
|
|
if OptionsPlace.ShrinkHeight and (SizeChangeReportItem.Height > ItemHeight) and (ItemHeight <> 0) then
|
|
SizeChangeReportItem.Height := ItemHeight;
|
|
end;
|
|
|
|
if OptionsPlace.HasHorzResizing then
|
|
begin
|
|
ItemWidth := MeasureItemWidth(SizeMeasureReportItem);
|
|
if OptionsPlace.ExpandWidth and (SizeChangeReportItem.Width < ItemWidth) then
|
|
SizeChangeReportItem.Width := ItemWidth;
|
|
if OptionsPlace.ShrinkWidth and (SizeChangeReportItem.Width > ItemWidth) then
|
|
SizeChangeReportItem.Width := ItemWidth;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TdxPSCustomProducer.MeasureItemHeight(AnItem: TdxReportVisualItem): Integer;
|
|
begin
|
|
Result := AnItem.MeasureHeight(DC);
|
|
end;
|
|
|
|
function TdxPSCustomProducer.MeasureItemWidth(AnItem: TdxReportVisualItem): Integer;
|
|
begin
|
|
Result := AnItem.MeasureWidth(DC);
|
|
end;
|
|
|
|
function TdxPSCustomProducer.ObjectExpandHeight: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxPSCustomProducer.ObjectExpandWidth: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxPSCustomProducer.ObjectShrinkHeight: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxPSCustomProducer.ObjectShrinkWidth: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxPSCustomProducer.OptionsTransparent: TdxCustomContainerReportLinkOptionsTransparent;
|
|
begin
|
|
Result := ReportLink.OptionsTransparent;
|
|
end;
|
|
|
|
function TdxPSCustomProducer.GetDC: HDC;
|
|
begin
|
|
Result := ReportLink.ScreenDC;
|
|
end;
|
|
|
|
function TdxPSCustomProducer.GetDefinition(Component: TComponent): TdxPSCustomContainerItemDefinition;
|
|
begin
|
|
Result := ReportLink.DefinitionsByContainerItem[Component];
|
|
end;
|
|
|
|
function TdxPSCustomProducer.GetIsDesigning: Boolean;
|
|
begin
|
|
Result := csDesigning in ReportLink.ComponentState;
|
|
end;
|
|
|
|
function TdxPSCustomProducer.GetProducer(Component: TComponent): TdxPSCustomProducer;
|
|
begin
|
|
Result := ReportLink.Producers[Component];
|
|
end;
|
|
|
|
{ TdxPSCustomContainerItemProducer }
|
|
|
|
function TdxPSCustomContainerItemProducer.Control: TControl;
|
|
begin
|
|
Result := ProducingObject;
|
|
end;
|
|
|
|
class function TdxPSCustomContainerItemProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TControl;
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemProducer.Definition: TdxPSContainerControlDefinition;
|
|
begin
|
|
Result := inherited Definition as TdxPSContainerControlDefinition;
|
|
end;
|
|
|
|
class function TdxPSCustomContainerItemProducer.DefinitionClass: TdxPSCustomContainerItemDefinitionClass;
|
|
begin
|
|
Result := TdxPSContainerControlDefinition;
|
|
end;
|
|
|
|
class function TdxPSCustomContainerItemProducer.PairClass: TClass;
|
|
begin
|
|
Result := ControlClass;
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemProducer.ProducingObject: TControl;
|
|
begin
|
|
Result := TControl(inherited ProducingObject);
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemProducer.ProducingObjectFriendlyName: string;
|
|
begin
|
|
Result := '';
|
|
if not IsDesigning then
|
|
Result := Control_GetText(Control);
|
|
if Result = '' then
|
|
Result := inherited ProducingObjectFriendlyName;
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemProducer.CanProcessChild(AChildControl: TControl): Boolean;
|
|
begin
|
|
Result := ((csAcceptsControls in Control_GetControlStyle(Control)) and
|
|
((AChildControl.Owner <> Control)) or
|
|
(Control is TCustomForm) {$IFDEF DELPHI5} or (Control is TCustomFrame){$ENDIF});
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemProducer.CreateIterator: IdxPSContainerIterator;
|
|
begin
|
|
Result := nil;
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemProducer.GetContentColor: TColor;
|
|
begin
|
|
if Control.Enabled then
|
|
Result := Control_GetColor(Control)
|
|
else
|
|
Result := DefaultControlDisabledContentColor;
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemProducer.GetControlBoundsRect: TRect;
|
|
begin
|
|
Result := Control.ClientRect;
|
|
OffsetRect(Result, Control.Left, Control.Top);
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemProducer.GetFont: TFont;
|
|
begin
|
|
Result := Control_GetFont(Control);
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemProducer.GetFontColor: TColor;
|
|
begin
|
|
if Control.Enabled then
|
|
Result := Font.Color
|
|
else
|
|
Result := DefaultControlDisabledTextColor;
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemProducer.GetFontIndex: Integer;
|
|
begin
|
|
Result := ReportLink.GetPreparedFontIndex(Font, IsFontSubstitutable, FontName, FontColor, FontStyle);
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemProducer.GetFontName: string;
|
|
begin
|
|
Result := Font.Name;
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemProducer.GetFontStyle: TFontStyles;
|
|
begin
|
|
Result := Font.Style;
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemProducer.IsFontSubstitutable: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemProducer.HostClass: TdxReportCellClass;
|
|
begin
|
|
Result := TdxReportCell;
|
|
end;
|
|
|
|
procedure TdxPSCustomContainerItemProducer.InitializeHost(ACell: TdxReportCell);
|
|
begin
|
|
with ACell do
|
|
begin
|
|
BoundsRect := ControlBounds;
|
|
Color := ContentColor;
|
|
CellSides := [];
|
|
ExcludeFromClipRgn := True;
|
|
Transparent := True;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxPSCustomContainerItemProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
with AnItem do
|
|
begin
|
|
BoundsRect := GetControlBoundsRect;
|
|
Color := ContentColor;
|
|
Data := Integer(TObject(Control));
|
|
FontIndex := Self.FontIndex;
|
|
Transparent := OptionsTransparent.Controls;
|
|
end;
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemProducer.ItemClass: TdxReportVisualItemClass;
|
|
begin
|
|
Result := TAbstractdxReportCellData;
|
|
end;
|
|
|
|
function TdxPSCustomContainerItemProducer.GetControlBounds: TRect;
|
|
begin
|
|
Result := GetControlBoundsRect;
|
|
if Control <> RootContainer then {.1}
|
|
with Producers[Control.Parent] do
|
|
OffsetRect(Result, ScrollPosLeft, ScrollPosTop);
|
|
end;
|
|
|
|
{ TdxPSCustomDelegateProducer }
|
|
|
|
procedure TdxPSCustomDelegateProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
Producer.InitializeItem(AnItem);
|
|
end;
|
|
|
|
function TdxPSCustomDelegateProducer.ItemClass: TdxReportVisualItemClass;
|
|
begin
|
|
Result := Producer.ItemClass;
|
|
end;
|
|
|
|
{ TdxPSNativePrintableControlProducer }
|
|
|
|
class function TdxPSNativePrintableControlProducer.Reenterable: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxPSNativePrintableControlProducer.Definition: TdxPSNativePrintableControlDefinition;
|
|
begin
|
|
Result := inherited Definition as TdxPSNativePrintableControlDefinition;
|
|
end;
|
|
|
|
class function TdxPSNativePrintableControlProducer.DefinitionClass: TdxPSCustomContainerItemDefinitionClass;
|
|
begin
|
|
Result := TdxPSNativePrintableControlDefinition;
|
|
end;
|
|
|
|
class function TdxPSNativePrintableControlProducer.HasNativeSupportForBorders: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
class procedure TdxPSNativePrintableControlProducer.Register;
|
|
begin
|
|
dxPSNativePrintableControlProducerFactory.Register(Self);
|
|
end;
|
|
|
|
class procedure TdxPSNativePrintableControlProducer.Unregister;
|
|
begin
|
|
if not FIsNativePrintableControlProducerFactoryReleased then
|
|
dxPSNativePrintableControlProducerFactory.Unregister(Self);
|
|
end;
|
|
|
|
procedure TdxPSNativePrintableControlProducer.AdjustItemBounds(AnItem: TdxReportVisualItem);
|
|
var
|
|
R: TRect;
|
|
begin
|
|
with AnItem do
|
|
begin
|
|
R := BoundsRect;
|
|
InflateRect(R, AnItem.BorderClass.Thickness - 1, AnItem.BorderClass.Thickness - 1);
|
|
if ShowShadow then
|
|
begin
|
|
Inc(R.Right, ShadowDepth);
|
|
Inc(R.Bottom, ShadowDepth);
|
|
end;
|
|
|
|
if not (Control is TWinControl) then
|
|
begin
|
|
OffsetRect(R, Control.Left, Control.Top);
|
|
with Producers[Control.Parent] do
|
|
OffsetRect(R, ScrollPosLeft, ScrollPosTop);
|
|
end;
|
|
|
|
BoundsRect := R;
|
|
|
|
with Definition.OptionsPlace do
|
|
begin
|
|
if not ShrinkWidth and not ExpandWidth and (Width < Parent.Width) then
|
|
Width := Parent.Width;
|
|
if not ShrinkHeight and not ExpandHeight and (Height < Parent.Height) then
|
|
Height := Parent.Height;
|
|
end;
|
|
|
|
if not Parent.ClipChildren then
|
|
begin
|
|
Parent.Height := Height;
|
|
Parent.Width := Width;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TdxPSNativePrintableControlProducer.CreateControlReportLink: TBasedxReportLink;
|
|
begin
|
|
Result := ReportLink.DoGetReportLink(Control);
|
|
FIsOuterLinkUsed := Result <> nil;
|
|
if not FIsOuterLinkUsed then
|
|
Result := GetLinkClass(Control.ClassType).Create(nil);
|
|
InitializeReportLink(Result);
|
|
end;
|
|
|
|
procedure TdxPSNativePrintableControlProducer.CreateNativePrintableControlData(AnItem: TdxReportVisualItem);
|
|
var
|
|
Link: TBasedxReportLinkAccess;
|
|
Pt: TPoint;
|
|
begin
|
|
Link := TBasedxReportLinkAccess(CreateControlReportLink);
|
|
try
|
|
if Link.DataProviderPresent then
|
|
begin
|
|
if not IsOuterLinkUsed then Link.RestoreFromOriginal;
|
|
Link.RebuildReport;
|
|
AnItem.Assign(Link.ReportCells.Cells);
|
|
|
|
Pt := Control.ClientToScreen(NullPoint);
|
|
Pt := TopLevelRootContainer.ScreenToClient(Pt);
|
|
AnItem.ReportCells.AppendOverlays(Link.ReportCells, Pt.X, Pt.Y);
|
|
|
|
Definition.GetData(Link);
|
|
end
|
|
else
|
|
AnItem.CellSides := [];
|
|
finally
|
|
DeinitializeReportLink(Link);
|
|
if not IsOuterLinkUsed then Link.Free;
|
|
FIsOuterLinkUsed := False;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxPSNativePrintableControlProducer.DeinitializeReportLink(AControlReportLink: TBasedxReportLink);
|
|
begin
|
|
with TBasedxReportLinkAccess(AControlReportLink) do
|
|
begin
|
|
if ComponentPrinter = InternalComponentPrinter then ComponentPrinter := nil;
|
|
Controller := nil;
|
|
ReportLink.DoInitializeReportLink(AControlReportLink, psAfter);
|
|
end;
|
|
end;
|
|
|
|
class function TdxPSNativePrintableControlProducer.GetLinkClass(AClass: TClass): TdxReportLinkClass;
|
|
begin
|
|
Result := dxPSLinkClassByCompClass(TComponentClass(AClass));
|
|
end;
|
|
|
|
procedure TdxPSNativePrintableControlProducer.InitializeReportLink(AControlReportLink: TBasedxReportLink);
|
|
begin
|
|
with TBasedxReportLinkAccess(AControlReportLink) do
|
|
begin
|
|
if ComponentPrinter = nil then ComponentPrinter := InternalComponentPrinter;
|
|
Controller := ReportLink;
|
|
Component := Control;
|
|
ReportLink.DoInitializeReportLink(AControlReportLink, psBefore);
|
|
end;
|
|
end;
|
|
|
|
class function TdxPSNativePrintableControlProducer.HasReportLink(AComponent: TComponent): Boolean;
|
|
var
|
|
LinkClass: TdxReportLinkClass;
|
|
begin
|
|
LinkClass := GetLinkClass(AComponent.ClassType);
|
|
Result := (LinkClass <> nil) and LinkClass.Aggregable;
|
|
end;
|
|
|
|
function TdxPSNativePrintableControlProducer.HostClass: TdxReportCellClass;
|
|
begin
|
|
Result := TdxReportNativePrintableControlHost;
|
|
end;
|
|
|
|
procedure TdxPSNativePrintableControlProducer.InitializeHost(ACell: TdxReportCell);
|
|
begin
|
|
inherited;
|
|
ACell.ClipChildren := not (ObjectExpandHeight and ObjectExpandWidth);
|
|
end;
|
|
|
|
procedure TdxPSNativePrintableControlProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
CreateNativePrintableControlData(AnItem);
|
|
InitializeNativePrintableControlHost(AnItem);
|
|
end;
|
|
|
|
procedure TdxPSNativePrintableControlProducer.InitializeNativePrintableControlHost(AnItem: TdxReportVisualItem);
|
|
begin
|
|
AnItem.Data := Integer(TObject(Control)); // should be copied as well !!!
|
|
AnItem.ExcludeFromClipRgn := True;
|
|
AnItem.Transparent := True;
|
|
AnItem.CellSides := []; //v.3.2
|
|
|
|
AdjustItemBounds(AnItem);
|
|
end;
|
|
|
|
function TdxPSNativePrintableControlProducer.ItemClass: TdxReportVisualItemClass;
|
|
begin
|
|
Result := TdxReportCell;
|
|
end;
|
|
|
|
function TdxPSNativePrintableControlProducer.MeasureItemHeight(AnItem: TdxReportVisualItem): Integer;
|
|
begin
|
|
Result := Definition.ReportDimension.Y;
|
|
end;
|
|
|
|
function TdxPSNativePrintableControlProducer.MeasureItemWidth(AnItem: TdxReportVisualItem): Integer;
|
|
begin
|
|
Result := Definition.ReportDimension.X;
|
|
end;
|
|
|
|
function TdxPSNativePrintableControlProducer.ObjectExpandHeight: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxPSNativePrintableControlProducer.ObjectExpandWidth: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
{ TdxPSContainerControlProducer }
|
|
|
|
procedure TdxPSContainerControlProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
AnItem.BoundsRect := GetControlBoundsRect;
|
|
AnItem.CellSides := csAll;
|
|
//AnItem.ExcludeFromClipRgn := True;
|
|
end;
|
|
|
|
{ TdxPSControlAsMetafileProducer }
|
|
|
|
class function TdxPSControlAsMetafileProducer.PairClass: TClass;
|
|
begin
|
|
Result := BuddyClass;
|
|
end;
|
|
|
|
class procedure TdxPSControlAsMetafileProducer.Register;
|
|
begin
|
|
dxPSProducerHelperFactory.Register(Self);
|
|
end;
|
|
|
|
class procedure TdxPSControlAsMetafileProducer.Unregister;
|
|
begin
|
|
dxPSProducerHelperFactory.Unregister(Self);
|
|
end;
|
|
|
|
procedure TdxPSControlAsMetafileProducer.Reposition;
|
|
begin
|
|
end;
|
|
|
|
class function TdxPSControlAsMetafileProducer.BuddyClass: TdxPSCustomProducerClass;
|
|
begin
|
|
Result := TdxPSContainerControlProducer;
|
|
end;
|
|
|
|
function TdxPSControlAsMetafileProducer.CreateControlImage(AnItem: TdxReportVisualItem): TGraphic;
|
|
var
|
|
Canvas: TMetafileCanvas;
|
|
begin
|
|
Result := TdxReportCellGraphic(AnItem).CreateImage(TMetafile);
|
|
try
|
|
Result.Height := AnItem.Height;
|
|
Result.Width := AnItem.Width;
|
|
Canvas := TMetafileCanvas.Create(TMetafile(Result), DC);
|
|
try
|
|
Control.Perform(WM_PAINT, Canvas.Handle, 0)
|
|
finally
|
|
Canvas.Free;
|
|
end;
|
|
except
|
|
Result.Free;
|
|
raise;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxPSControlAsMetafileProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
TdxReportCellGraphic(AnItem).CellSides := [];
|
|
TdxReportCellGraphic(AnItem).ImageTransparent := False;
|
|
CreateControlImage(AnItem);
|
|
end;
|
|
|
|
function TdxPSControlAsMetafileProducer.ItemClass: TdxReportVisualItemClass;
|
|
begin
|
|
Result := TdxReportCellGraphic;
|
|
end;
|
|
|
|
{ TdxPSBevelProducer }
|
|
|
|
function TdxPSBevelProducer.Control: TBevel;
|
|
begin
|
|
Result := inherited Control as TBevel;
|
|
end;
|
|
|
|
class function TdxPSBevelProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TBevel;
|
|
end;
|
|
|
|
procedure TdxPSBevelProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
AnItem.CellSides := BevelShapeMap[Control.Shape];
|
|
AnItem.BorderClass := BevelStyleMap[Control.Style, Control.Shape];
|
|
AnItem.Transparent := True;
|
|
end;
|
|
|
|
function TdxPSBevelProducer.ItemClass: TdxReportVisualItemClass;
|
|
begin
|
|
Result := TdxReportCellBox;
|
|
end;
|
|
|
|
{ TdxPSPaintBoxProducer }
|
|
|
|
function TdxPSPaintBoxProducer.Control: TPaintBox;
|
|
begin
|
|
Result := inherited Control as TPaintBox;
|
|
end;
|
|
|
|
class function TdxPSPaintBoxProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TPaintBox;
|
|
end;
|
|
|
|
procedure TdxPSPaintBoxProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
AnItem.CellSides := [];
|
|
AnItem.BorderClass := TdxPSCellNullBorder;
|
|
AnItem.Transparent := True;
|
|
end;
|
|
|
|
function TdxPSPaintBoxProducer.ItemClass: TdxReportVisualItemClass;
|
|
begin
|
|
Result := TdxReportCellBox;
|
|
end;
|
|
|
|
{ TdxPSShapeProducer }
|
|
|
|
function TdxPSShapeProducer.Control: TShape;
|
|
begin
|
|
Result := inherited Control as TShape;
|
|
end;
|
|
|
|
class function TdxPSShapeProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TShape;
|
|
end;
|
|
|
|
procedure TdxPSShapeProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
var
|
|
V: Integer;
|
|
begin
|
|
inherited;
|
|
with TCustomdxReportCellShape(AnItem) do
|
|
begin
|
|
CellSides := [];
|
|
ContentBkColor := Control_GetColor(Control.Parent);
|
|
ContentPattern := BrushStyleMap[Control.Brush.Style];
|
|
ShapeBorderColor := Control.Pen.Color;
|
|
ShapeBorderThickness := Control.Pen.Width;
|
|
if (Control.Pen.Style <> psSolid) and (ShapeBorderThickness > 1) then
|
|
ShapeBorderThickness := 1;
|
|
ShapeColor := Control.Brush.Color;
|
|
if Control.Pen.Style = psClear then
|
|
ShapeBorderColor := ShapeColor;
|
|
ShapeTransparent := Control.Brush.Style = bsClear;
|
|
if Control.Shape in [stRoundRect, stRoundSquare] then
|
|
begin
|
|
if ShapeHeight > ShapeWidth then
|
|
V := ShapeWidth
|
|
else
|
|
V := ShapeHeight;
|
|
TdxReportCellRoundRect(AnItem).EllipseHeight := V div 4;
|
|
TdxReportCellRoundRect(AnItem).EllipseWidth := V div 4;
|
|
end;
|
|
Transparent := True;
|
|
end;
|
|
end;
|
|
|
|
function TdxPSShapeProducer.ItemClass: TdxReportVisualItemClass;
|
|
begin
|
|
Result := ShapeTypeMap[Control.Shape];
|
|
end;
|
|
|
|
{ TdxPSCustomLabelProducer }
|
|
|
|
function TdxPSCustomLabelProducer.Control: TCustomLabel;
|
|
begin
|
|
Result := inherited Control as TCustomLabel;
|
|
end;
|
|
|
|
class function TdxPSCustomLabelProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TCustomLabel;
|
|
end;
|
|
|
|
function TdxPSCustomLabelProducer.GetControlBoundsRect: TRect;
|
|
begin
|
|
Result := inherited GetControlBoundsRect;
|
|
OffsetRect(Result, 0, -2);
|
|
end;
|
|
|
|
procedure TdxPSCustomLabelProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
with TdxReportCellString(AnItem) do
|
|
begin
|
|
CellSides := [];
|
|
Multiline := Label_GetWordWrap(Control);
|
|
HidePrefix := True;
|
|
Text := Label_GetText(Control);
|
|
TextAlignX := dxPSCore.dxTextAlignX[Label_GetAlignment(Control)];
|
|
TextAlignY := dxPSCore.dxTextAlignY[Label_GetLayout(Control)];
|
|
AdjustFont := Label_GetAutoSize(Control);
|
|
end;
|
|
end;
|
|
|
|
function TdxPSCustomLabelProducer.ItemClass: TdxReportVisualItemClass;
|
|
begin
|
|
Result := TdxReportCellString;
|
|
end;
|
|
|
|
function TdxPSCustomLabelProducer.ObjectExpandHeight: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TdxPSCustomLabelProducer.ObjectExpandWidth: Boolean;
|
|
begin
|
|
Result := Label_GetAutoSize(Control);
|
|
end;
|
|
|
|
{ TdxPSContainerCustomWinControlProducer }
|
|
|
|
function TdxPSContainerCustomWinControlProducer.Control: TWinControl;
|
|
begin
|
|
Result := inherited Control as TWinControl;
|
|
end;
|
|
|
|
class function TdxPSContainerCustomWinControlProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TWinControl;
|
|
end;
|
|
|
|
function TdxPSContainerCustomWinControlProducer.CreateIterator: IdxPSContainerIterator;
|
|
begin
|
|
IteratorClass.Create(Control).GetInterface(IdxPSContainerIterator, Result);
|
|
end;
|
|
|
|
class function TdxPSContainerCustomWinControlProducer.DefinitionClass: TdxPSCustomContainerItemDefinitionClass;
|
|
begin
|
|
Result := TdxPSContainerWinControlDefinition;
|
|
end;
|
|
|
|
function TdxPSContainerCustomWinControlProducer.HostClass: TdxReportCellClass;
|
|
begin
|
|
Result := TdxReportWinControlHost;
|
|
end;
|
|
|
|
procedure TdxPSContainerCustomWinControlProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
AnItem.Left := 0;
|
|
AnItem.Top := 0;
|
|
AnItem.BorderClass := Ctl3DBorderClassMap[Control_GetCtl3D(Control)];
|
|
//AnItem.ExcludeFromClipRgn := True;
|
|
end;
|
|
|
|
class function TdxPSContainerCustomWinControlProducer.IteratorClass: TdxPSWinControlIteratorClass;
|
|
begin
|
|
Result := TdxPSWinControlIterator;
|
|
end;
|
|
|
|
{ TdxPSWinControlAsMetafileProducer }
|
|
|
|
class function TdxPSWinControlAsMetafileProducer.PairClass: TClass;
|
|
begin
|
|
Result := BuddyClass;
|
|
end;
|
|
|
|
procedure TdxPSWinControlAsMetafileProducer.Reposition;
|
|
begin
|
|
end;
|
|
|
|
class procedure TdxPSWinControlAsMetafileProducer.Register;
|
|
begin
|
|
dxPSProducerHelperFactory.Register(Self);
|
|
end;
|
|
|
|
class procedure TdxPSWinControlAsMetafileProducer.Unregister;
|
|
begin
|
|
dxPSProducerHelperFactory.Unregister(Self);
|
|
end;
|
|
|
|
class function TdxPSWinControlAsMetafileProducer.BuddyClass: TdxPSCustomProducerClass;
|
|
begin
|
|
Result := TdxPSContainerWinControlProducer;
|
|
end;
|
|
|
|
function TdxPSWinControlAsMetafileProducer.CreateControlImage(AnItem: TdxReportVisualItem): TGraphic;
|
|
var
|
|
Canvas: TMetafileCanvas;
|
|
begin
|
|
Result := TdxReportCellGraphic(AnItem).CreateImage(TMetafile);
|
|
Result.Width := AnItem.Width;
|
|
Result.Height := AnItem.Height;
|
|
Canvas := TMetafileCanvas.Create(TMetafile(Result), DC);
|
|
try
|
|
Control.PaintTo(Canvas.Handle, 0, 0);
|
|
finally
|
|
Canvas.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxPSWinControlAsMetafileProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
TdxReportCellGraphic(AnItem).CellSides := [];
|
|
TdxReportCellGraphic(AnItem).ImageTransparent := False;
|
|
CreateControlImage(AnItem);
|
|
end;
|
|
|
|
function TdxPSWinControlAsMetafileProducer.ItemClass: TdxReportVisualItemClass;
|
|
begin
|
|
Result := TdxReportCellGraphic;
|
|
end;
|
|
|
|
{ TdxPSContainerWinControlProducer }
|
|
|
|
procedure TdxPSContainerWinControlProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
TdxReportCellString(AnItem).Text := Control_GetText(Control);
|
|
end;
|
|
|
|
function TdxPSContainerWinControlProducer.ItemClass: TdxReportVisualItemClass;
|
|
begin
|
|
Result := TdxReportCellString;
|
|
end;
|
|
|
|
function TdxPSContainerWinControlProducer.ObjectExpandHeight: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
{ TdxPSDateTimePickerProducer }
|
|
|
|
function TdxPSDateTimePickerProducer.Control: TDateTimePicker;
|
|
begin
|
|
Result := inherited Control as TDateTimePicker;
|
|
end;
|
|
|
|
class function TdxPSDateTimePickerProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TDateTimePicker;
|
|
end;
|
|
|
|
procedure TdxPSDateTimePickerProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
with TdxReportCellCheck(AnItem) do
|
|
begin
|
|
//AnItem.BorderClass := Ctl3DBorderClassMap[ControlGetCtl3D(Control)];
|
|
if Control.ShowCheckbox then
|
|
begin
|
|
ButtonEdgeStyle := cbes3D;
|
|
Checked := Control.Checked;
|
|
CheckPos := ccpLeft;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TdxPSDateTimePickerProducer.ItemClass: TdxReportVisualItemClass;
|
|
const
|
|
ItemClasses: array[Boolean] of TdxReportVisualItemClass = (TdxReportCellString, TdxReportCellCheck);
|
|
begin
|
|
Result := ItemClasses[Control.ShowCheckbox];
|
|
end;
|
|
|
|
{ TdxPSCustomHotKeyProducer }
|
|
|
|
function TdxPSCustomHotKeyProducer.Control: TCustomHotKey;
|
|
begin
|
|
Result := inherited Control as TCustomHotKey;
|
|
end;
|
|
|
|
class function TdxPSCustomHotKeyProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TCustomHotKey;
|
|
end;
|
|
|
|
procedure TdxPSCustomHotKeyProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
TdxReportCellString(AnItem).Text := Menus.ShortCutToText(HotKey_GetHotKey(Control));
|
|
end;
|
|
|
|
{ TdxPSCustomStaticTextProducer }
|
|
|
|
function TdxPSCustomStaticTextProducer.Control: TCustomStaticText;
|
|
begin
|
|
Result := inherited Control as TCustomStaticText;
|
|
end;
|
|
|
|
class function TdxPSCustomStaticTextProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TCustomStaticText;
|
|
end;
|
|
|
|
procedure TdxPSCustomStaticTextProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
const
|
|
BorderClassMap: array[TStaticBorderStyle] of TdxPSCellBorderClass =
|
|
(TdxPSCellNullBorder, TdxPSCellUltraFlatBorder, TdxPSCellSunkenSoftBorder);
|
|
CellSidesMap: array[TStaticBorderStyle] of TdxCellSides = ([], csAll, csAll);
|
|
begin
|
|
inherited;
|
|
TdxReportCellString(AnItem).BorderClass := BorderClassMap[StaticText_GetBorderStyle(Control)];
|
|
TdxReportCellString(AnItem).CellSides := CellSidesMap[StaticText_GetBorderStyle(Control)];
|
|
TdxReportCellString(AnItem).HidePrefix := True;
|
|
TdxReportCellString(AnItem).TextAlignX := dxPSCore.dxTextAlignX[StaticText_GetAlignment(Control)];
|
|
end;
|
|
|
|
{ TdxPSCustomEditProducer }
|
|
|
|
function TdxPSCustomEditProducer.Control: TCustomEdit;
|
|
begin
|
|
Result := inherited Control as TCustomEdit;
|
|
end;
|
|
|
|
class function TdxPSCustomEditProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TCustomEdit;
|
|
end;
|
|
|
|
procedure TdxPSCustomEditProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
TdxReportCellString(AnItem).CellSides := BorderStyleMap[Edit_GetBorderStyle(Control)];
|
|
//TdxReportCellString(AnItem).BorderClass := Ctl3DBorderClassMap[ControlGetCtl3D(Control)];
|
|
end;
|
|
|
|
{ TdxPSCustomMemoProducer }
|
|
|
|
function TdxPSCustomMemoProducer.Control: TCustomMemo;
|
|
begin
|
|
Result := inherited Control as TCustomMemo;
|
|
end;
|
|
|
|
class function TdxPSCustomMemoProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TCustomMemo;
|
|
end;
|
|
|
|
function TdxPSCustomMemoProducer.ProducingObjectFriendlyName: string;
|
|
var
|
|
Lines: TStrings;
|
|
begin
|
|
Result := '';
|
|
Lines := Memo_GetLines(Control);
|
|
if not IsDesigning and (Lines.Count <> 0) then
|
|
Result := dxPSMakeFriendlyNameFromStrings(Lines);
|
|
if Result = '' then
|
|
Result := inherited ProducingObjectFriendlyName;
|
|
end;
|
|
|
|
procedure TdxPSCustomMemoProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
TdxReportCellString(AnItem).TextAlignX := dxPSCore.dxTextAlignX[Memo_GetAlignment(Control)];
|
|
TdxReportCellString(AnItem).TextAlignY := taTop;
|
|
TdxReportCellString(AnItem).Multiline := True;
|
|
end;
|
|
|
|
function TdxPSCustomMemoProducer.ObjectExpandHeight: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
{ TdxPSCustomComboBoxProducer }
|
|
|
|
function TdxPSCustomComboBoxProducer.Control: TCustomComboBox;
|
|
begin
|
|
Result := inherited Control as TCustomComboBox;
|
|
end;
|
|
|
|
class function TdxPSCustomComboBoxProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TCustomComboBox;
|
|
end;
|
|
|
|
procedure TdxPSCustomComboBoxProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
//TdxReportCellString(AnItem).BorderClass := Ctl3DBorderClassMap[ControlGetCtl3D(Control)];
|
|
TdxReportCellString(AnItem).Text := ComboBox_GetCurrentText(Control);
|
|
end;
|
|
|
|
{$IFDEF DELPHI6}
|
|
|
|
{ TdxPSComboBoxExProducer }
|
|
|
|
function TdxPSCustomComboBoxExProducer.Control: TCustomComboBoxEx;
|
|
begin
|
|
Result := inherited Control as TCustomComboBoxEx;
|
|
end;
|
|
|
|
class function TdxPSCustomComboBoxExProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TCustomComboBoxEx;
|
|
end;
|
|
|
|
procedure TdxPSCustomComboBoxExProducer.GetImageLists(AProc: TdxPSGetImageListProc);
|
|
begin
|
|
inherited;
|
|
AProc(Control.Images);
|
|
end;
|
|
|
|
procedure TdxPSCustomComboBoxExProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
with TdxReportCellImage(AnItem) do
|
|
begin
|
|
if Control.ItemIndex <> -1 then
|
|
ImageIndex := Control.ItemsEx[Control.ItemIndex].ImageIndex;
|
|
ImageList := Control.Images;
|
|
MakeSpaceForEmptyImage := True;
|
|
if Control.Style in [csExSimple, csExDropDown] then
|
|
Text := Control_GetText(Control)
|
|
else
|
|
if Control.ItemIndex <> -1 then
|
|
Text := Control.ItemsEx[Control.ItemIndex].Caption
|
|
else
|
|
Text := '';
|
|
end;
|
|
end;
|
|
|
|
function TdxPSCustomComboBoxExProducer.ItemClass: TdxReportVisualItemClass;
|
|
begin
|
|
Result := TdxReportCellImage;
|
|
end;
|
|
|
|
{$ENDIF}
|
|
|
|
function TdxPSCustomCheckBoxProducer.Control: TCustomCheckBox;
|
|
begin
|
|
Result := inherited Control as TCustomCheckBox;
|
|
end;
|
|
|
|
class function TdxPSCustomCheckBoxProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TCustomCheckBox;
|
|
end;
|
|
|
|
procedure TdxPSCustomCheckBoxProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
var
|
|
CheckState: TCheckBoxState;
|
|
begin
|
|
inherited;
|
|
CheckState := CheckBox_GetState(Control);
|
|
with TdxReportCellCheck(AnItem) do
|
|
begin
|
|
ButtonEdgeStyle := cbes3D;
|
|
CellSides := [];
|
|
Checked := CheckState <> cbUnchecked;
|
|
CheckPos := CheckAlignmentMap[CheckBox_GetAlignment(Control)];
|
|
Enabled := CheckState <> cbGrayed;
|
|
HidePrefix := True;
|
|
TextAlignX := taLeft;
|
|
end;
|
|
end;
|
|
|
|
function TdxPSCustomCheckBoxProducer.ItemClass: TdxReportVisualItemClass;
|
|
begin
|
|
Result := TdxReportCellCheck;
|
|
end;
|
|
|
|
{ TdxPSRadioButtonProducer }
|
|
|
|
function TdxPSRadioButtonProducer.Control: TRadioButton;
|
|
begin
|
|
Result := inherited Control as TRadioButton;
|
|
end;
|
|
|
|
class function TdxPSRadioButtonProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TRadioButton;
|
|
end;
|
|
|
|
procedure TdxPSRadioButtonProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
with TdxReportCellRadio(AnItem) do
|
|
begin
|
|
ButtonEdgeStyle := cbes3D;
|
|
CellSides := [];
|
|
Checked := Control.Checked;
|
|
CheckPos := CheckAlignmentMap[Control.Alignment];
|
|
Enabled := Control.Enabled;
|
|
HidePrefix := True;
|
|
TextAlignX := taLeft;
|
|
end;
|
|
end;
|
|
|
|
function TdxPSRadioButtonProducer.ItemClass: TdxReportVisualItemClass;
|
|
begin
|
|
Result := TdxReportCellRadio;
|
|
end;
|
|
|
|
{ TdxPSCustomContainerProducer }
|
|
|
|
class function TdxPSCustomContainerProducer.CanHasAvailableChildren: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
class function TdxPSCustomContainerProducer.DefinitionClass: TdxPSCustomContainerItemDefinitionClass;
|
|
begin
|
|
Result := TdxPSContainerDefinition;
|
|
end;
|
|
|
|
procedure TdxPSCustomContainerProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
const
|
|
CellsSidesMap: array[Boolean] of TdxCellSides = ([], csAll);
|
|
begin
|
|
inherited;
|
|
//AnItem.ExcludeFromClipRgn := Control <> RootContainer;
|
|
if Control = RootContainer then
|
|
begin
|
|
AnItem.CellSides := CellsSidesMap[ReportLink.OptionsRefinements.RootBorders];
|
|
AnItem.Transparent := OptionsTransparent.Root;
|
|
end
|
|
else
|
|
AnItem.Transparent := OptionsTransparent.Containers;
|
|
end;
|
|
|
|
function TdxPSCustomContainerProducer.ObjectExpandHeight: Boolean;
|
|
begin
|
|
if Control = RootContainer then
|
|
Result := True
|
|
else
|
|
Result := inherited ObjectExpandHeight;
|
|
end;
|
|
|
|
function TdxPSCustomContainerProducer.ObjectExpandWidth: Boolean;
|
|
begin
|
|
if Control = RootContainer then
|
|
Result := True
|
|
else
|
|
Result := inherited ObjectExpandWidth;
|
|
end;
|
|
|
|
function TdxPSCustomContainerProducer.ObjectShrinkHeight: Boolean;
|
|
begin
|
|
if Control = RootContainer then
|
|
Result := True
|
|
else
|
|
Result := inherited ObjectShrinkHeight;
|
|
end;
|
|
|
|
function TdxPSCustomContainerProducer.ObjectShrinkWidth: Boolean;
|
|
begin
|
|
if Control = RootContainer then
|
|
Result := True
|
|
else
|
|
Result := inherited ObjectShrinkWidth;
|
|
end;
|
|
|
|
{ TdxPSCustomPanelProducer }
|
|
|
|
function TdxPSCustomPanelProducer.Control: TCustomPanel;
|
|
begin
|
|
Result := inherited Control as TCustomPanel;
|
|
end;
|
|
|
|
class function TdxPSCustomPanelProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TCustomPanel;
|
|
end;
|
|
|
|
class function TdxPSCustomPanelProducer.HasNativeSupportForBorders: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TdxPSCustomPanelProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
var
|
|
BevelInner, BevelOuter: TPanelBevel;
|
|
begin
|
|
inherited;
|
|
if Panel_GetBorderStyle(Control) <> bsSingle then
|
|
begin
|
|
BevelInner := Panel_GetBevelInner(Control);
|
|
BevelOuter := Panel_GetBevelOuter(Control);
|
|
if (BevelInner = bvNone) and (BevelOuter = bvNone) then
|
|
TdxReportCellString(AnItem).CellSides := []
|
|
else
|
|
TdxReportCellString(AnItem).BorderClass := PanelBevelsMap[BevelInner, BevelOuter];
|
|
end
|
|
else
|
|
TdxReportCellString(AnItem).BorderClass := PanelSingleBorderMap[Control_GetCtl3D(Control)];
|
|
|
|
TdxReportCellString(AnItem).Text := Control_GetText(Control);
|
|
TdxReportCellString(AnItem).TextAlignX := dxPSCore.dxTextAlignX[Panel_GetAlignment(Control)];
|
|
TdxReportCellString(AnItem).TextAlignY := taCenterY;
|
|
end;
|
|
|
|
function TdxPSCustomPanelProducer.ItemClass: TdxReportVisualItemClass;
|
|
begin
|
|
Result := TdxReportCellString;
|
|
end;
|
|
|
|
function TdxPSCustomPanelProducer.ObjectExpandHeight: Boolean;
|
|
begin
|
|
if Control <> RootContainer then
|
|
Result := True
|
|
else
|
|
Result := inherited ObjectExpandHeight;
|
|
end;
|
|
|
|
function TdxPSCustomPanelProducer.ObjectExpandWidth: Boolean;
|
|
begin
|
|
if Control <> RootContainer then
|
|
Result := True
|
|
else
|
|
Result := inherited ObjectExpandWidth;
|
|
end;
|
|
|
|
{ TdxPSCustomGroupBoxProducer }
|
|
|
|
function TdxPSCustomGroupBoxProducer.Control: TCustomGroupBox;
|
|
begin
|
|
Result := inherited Control as TCustomGroupBox;
|
|
end;
|
|
|
|
class function TdxPSCustomGroupBoxProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TCustomGroupBox;
|
|
end;
|
|
|
|
class function TdxPSCustomGroupBoxProducer.HasNativeSupportForBorders: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TdxPSCustomGroupBoxProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
const
|
|
BorderClasses: array[Boolean] of TdxPSCellBorderClass = (TdxPSCellUltraFlatBorder, TdxPSCellEtchedBorder);
|
|
begin
|
|
inherited;
|
|
with TdxReportGroup(AnItem) do
|
|
begin
|
|
BorderClass := BorderClasses[Control_GetCtl3D(Control)];
|
|
BorderColor := dxPSCore.dxDefaultGridLineColor;
|
|
CaptionAlignment := taLeft;
|
|
CaptionText := Control_GetText(Control);
|
|
CaptionTransparent := Transparent;
|
|
CellSides := csAll;
|
|
ShowCaption := True;
|
|
UseOwnBorderClass := True;
|
|
|
|
LookAndFeel := ReportLink.CreateGroupLookAndFeel(LookAndFeelClass);
|
|
InitializeLookAndFeel(AnItem, LookAndFeel);
|
|
LookAndFeel.Prepare(DC);
|
|
CalculateCaptionTextWidth(DC);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxPSCustomGroupBoxProducer.InitializeLookAndFeel(AnItem: TdxReportVisualItem;
|
|
ALookAndFeel: TdxPSReportGroupLookAndFeel);
|
|
begin
|
|
ALookAndFeel.FontIndex := AnItem.FontIndex;
|
|
ALookAndFeel.CaptionFontIndex := AnItem.FontIndex;
|
|
ALookAndFeel.Color := ContentColor;
|
|
end;
|
|
|
|
function TdxPSCustomGroupBoxProducer.ItemClass: TdxReportVisualItemClass;
|
|
begin
|
|
Result := TdxReportGroup;
|
|
end;
|
|
|
|
class function TdxPSCustomGroupBoxProducer.LookAndFeelClass: TdxPSReportGroupLookAndFeelClass;
|
|
begin
|
|
Result := TdxPSReportGroupStandardLookAndFeel;
|
|
end;
|
|
|
|
{ TdxPSCustomRadioGroupProducer }
|
|
|
|
function TdxPSCustomRadioGroupProducer.Control: TCustomRadioGroup;
|
|
begin
|
|
Result := inherited Control as TCustomRadioGroup;
|
|
end;
|
|
|
|
class function TdxPSCustomRadioGroupProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TCustomRadioGroup;
|
|
end;
|
|
|
|
function TdxPSCustomRadioGroupProducer.CanProcessChild(AChildControl: TControl): Boolean;
|
|
begin
|
|
Result := not AChildControl.ClassNameIs('TGroupButton'); // RadioGroup's buttons are processed inside
|
|
end;
|
|
|
|
procedure TdxPSCustomRadioGroupProducer.CreateItems(AReportRadioGroup: TdxReportRadioGroup);
|
|
var
|
|
Items: TStrings;
|
|
I: Integer;
|
|
Item: TdxCustomReportCellRadio;
|
|
begin
|
|
Items := RadioGroup_GetItems(Control);
|
|
for I := 0 to Items.Count - 1 do
|
|
begin
|
|
Item := AReportRadioGroup.Add(Items[I]);
|
|
InitializeRadioItem(Item, I);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxPSCustomRadioGroupProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
with TdxReportRadioGroup(AnItem) do
|
|
begin
|
|
ButtonEdgeStyle := cbes3D;
|
|
CheckPos := ccpLeft;
|
|
ColumnCount := RadioGroup_GetColumns(Control);
|
|
CreateItems(TdxReportRadioGroup(AnItem));
|
|
ItemIndex := RadioGroup_GetItemIndex(Control);
|
|
|
|
AdjustContent(DC);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxPSCustomRadioGroupProducer.InitializeRadioItem(AnItem: TdxCustomReportCellRadio; AnIndex: Integer);
|
|
begin
|
|
AnItem.Enabled := Control.Controls[AnIndex].Enabled;
|
|
end;
|
|
|
|
function TdxPSCustomRadioGroupProducer.ItemClass: TdxReportVisualItemClass;
|
|
begin
|
|
Result := TdxReportRadioGroup;
|
|
end;
|
|
|
|
{ TdxPSRootContainerProducer }
|
|
|
|
procedure TdxPSRootContainerProducer.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
inherited;
|
|
AnItem.Left := 0;
|
|
AnItem.Top := 0;
|
|
end;
|
|
|
|
{ TdxPSPageControlIterator }
|
|
|
|
function TdxPSPageControlIterator.GetControl(Index: Integer): TControl;
|
|
begin
|
|
Result := PageControl.ActivePage;
|
|
end;
|
|
|
|
function TdxPSPageControlIterator.GetControlCount: Integer;
|
|
begin
|
|
Result := Ord(PageControl.PageCount > 0);
|
|
end;
|
|
|
|
function TdxPSPageControlIterator.GetPageControl: TPageControl;
|
|
begin
|
|
Result := TPageControl(Control);
|
|
end;
|
|
|
|
{ TdxPSPageControlProducer }
|
|
|
|
function TdxPSPageControlProducer.Control: TPageControl;
|
|
begin
|
|
Result := inherited Control as TPageControl;
|
|
end;
|
|
|
|
class function TdxPSPageControlProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TPageControl;
|
|
end;
|
|
|
|
function TdxPSPageControlProducer.CanProcessChild(AChildControl: TControl): Boolean;
|
|
begin
|
|
Result := AChildControl = Control.ActivePage;
|
|
end;
|
|
|
|
class function TdxPSPageControlProducer.IteratorClass: TdxPSWinControlIteratorClass;
|
|
begin
|
|
Result := TdxPSPageControlIterator;
|
|
end;
|
|
|
|
{ TdxPSTabSheetProducer }
|
|
|
|
function TdxPSTabSheetProducer.Control: TTabSheet;
|
|
begin
|
|
Result := inherited Control as TTabSheet;
|
|
end;
|
|
|
|
class function TdxPSTabSheetProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TTabSheet;
|
|
end;
|
|
|
|
{ TdxPSTabControlProducer }
|
|
|
|
function TdxPSTabControlProducer.Control: TTabControl;
|
|
begin
|
|
Result := inherited Control as TTabControl;
|
|
end;
|
|
|
|
class function TdxPSTabControlProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TTabControl;
|
|
end;
|
|
|
|
{ TdxPSNotebookIterator }
|
|
|
|
function TdxPSNotebookIterator.GetControl(Index: Integer): TControl;
|
|
begin
|
|
with Notebook do
|
|
Result := TPage(Pages.Objects[PageIndex]);
|
|
end;
|
|
|
|
function TdxPSNotebookIterator.GetControlCount: Integer;
|
|
begin
|
|
Result := Ord(Notebook.Pages.Count <> 0);
|
|
end;
|
|
|
|
function TdxPSNotebookIterator.GetNotebook: TNotebook;
|
|
begin
|
|
Result := TNotebook(Control);
|
|
end;
|
|
|
|
{ TdxPSNotebookPageProducer }
|
|
|
|
function TdxPSNotebookPageProducer.Control: TPage;
|
|
begin
|
|
Result := inherited Control as TPage;
|
|
end;
|
|
|
|
class function TdxPSNotebookPageProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TPage;
|
|
end;
|
|
|
|
{ TdxPSNotebookProducer }
|
|
|
|
function TdxPSNotebookProducer.Control: TNotebook;
|
|
begin
|
|
Result := inherited Control as TNotebook;
|
|
end;
|
|
|
|
class function TdxPSNotebookProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TNotebook;
|
|
end;
|
|
|
|
function TdxPSNotebookProducer.CanProcessChild(AChildControl: TControl): Boolean;
|
|
begin
|
|
Result := AChildControl = Control.Pages.Objects[Control.PageIndex];
|
|
end;
|
|
|
|
class function TdxPSNotebookProducer.IteratorClass: TdxPSWinControlIteratorClass;
|
|
begin
|
|
Result := TdxPSNotebookIterator;
|
|
end;
|
|
|
|
{ TdxPSTabbedNotebookIterator }
|
|
|
|
function TdxPSTabbedNotebookIterator.GetControl(Index: Integer): TControl;
|
|
begin
|
|
with TabbedNotebook do
|
|
Result := TTabPage(Pages.Objects[PageIndex]);
|
|
end;
|
|
|
|
function TdxPSTabbedNotebookIterator.GetControlCount: Integer;
|
|
begin
|
|
Result := Ord(TabbedNotebook.Pages.Count <> 0);
|
|
end;
|
|
|
|
function TdxPSTabbedNotebookIterator.GetTabbedNotebook: TTabbedNotebook;
|
|
begin
|
|
Result := TTabbedNotebook(Control);
|
|
end;
|
|
|
|
{ TdxPSTabbedNotebookPageProducer }
|
|
|
|
function TdxPSTabbedNotebookPageProducer.Control: TTabPage;
|
|
begin
|
|
Result := inherited Control as TTabPage;
|
|
end;
|
|
|
|
class function TdxPSTabbedNotebookPageProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TTabPage;
|
|
end;
|
|
|
|
{ TdxPSTabbedNotebookProducer }
|
|
|
|
function TdxPSTabbedNotebookProducer.Control: TTabbedNotebook;
|
|
begin
|
|
Result := inherited Control as TTabbedNotebook;
|
|
end;
|
|
|
|
class function TdxPSTabbedNotebookProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TTabbedNotebook;
|
|
end;
|
|
|
|
function TdxPSTabbedNotebookProducer.CanProcessChild(AChildControl: TControl): Boolean;
|
|
begin
|
|
Result := AChildControl = Control.Pages.Objects[Control.PageIndex];
|
|
end;
|
|
|
|
class function TdxPSTabbedNotebookProducer.IteratorClass: TdxPSWinControlIteratorClass;
|
|
begin
|
|
Result := TdxPSTabbedNotebookIterator;
|
|
end;
|
|
|
|
{ TdxPSScrollingWinControlProducer }
|
|
|
|
function TdxPSScrollingWinControlProducer.Control: TScrollingWinControl;
|
|
begin
|
|
Result := inherited Control as TScrollingWinControl;
|
|
end;
|
|
|
|
class function TdxPSScrollingWinControlProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TScrollingWinControl;
|
|
end;
|
|
|
|
function TdxPSScrollingWinControlProducer.GetScrollBarPos(AScrollBar: TControlScrollBar): Integer;
|
|
begin
|
|
with AScrollBar do
|
|
if Visible then
|
|
Result := Position
|
|
else
|
|
Result := 0;
|
|
end;
|
|
|
|
function TdxPSScrollingWinControlProducer.GetScrollPosLeft: Integer;
|
|
begin
|
|
Result := GetScrollBarPos(Control.HorzScrollBar);
|
|
end;
|
|
|
|
function TdxPSScrollingWinControlProducer.GetScrollPosTop: Integer;
|
|
begin
|
|
Result := GetScrollBarPos(Control.VertScrollBar);
|
|
end;
|
|
|
|
procedure TdxPSScrollingWinControlProducer.InitializeHost(ACell: TdxReportCell);
|
|
|
|
function GetScrollValue(AValue, AMinValue: Integer): Integer;
|
|
begin
|
|
if AValue > AMinValue then
|
|
Result := AValue
|
|
else
|
|
Result := AMinValue;
|
|
end;
|
|
|
|
begin
|
|
inherited;
|
|
with Control do
|
|
begin
|
|
ACell.Height := GetScrollValue(VertScrollBar.Range, Height);
|
|
ACell.Width := GetScrollValue(HorzScrollBar.Range, Width);
|
|
end
|
|
end;
|
|
|
|
function TdxPSScrollingWinControlProducer.ObjectExpandHeight: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TdxPSScrollingWinControlProducer.ObjectExpandWidth: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
{$IFDEF DELPHI5}
|
|
|
|
{ TdxPSCustomFrameProducer }
|
|
|
|
function TdxPSCustomFrameProducer.Control: TCustomFrame;
|
|
begin
|
|
Result := inherited Control as TCustomFrame;
|
|
end;
|
|
|
|
class function TdxPSCustomFrameProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TCustomFrame;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
{ TdxPSCustomFormProducer }
|
|
|
|
function TdxPSCustomFormProducer.Control: TCustomForm;
|
|
begin
|
|
Result := inherited Control as TCustomForm;
|
|
end;
|
|
|
|
class function TdxPSCustomFormProducer.ControlClass: TControlClass;
|
|
begin
|
|
Result := TCustomForm;
|
|
end;
|
|
|
|
{ TdxPSContainerBuilder }
|
|
|
|
constructor TdxPSContainerBuilder.Create(AReportLink: TdxCustomContainerReportLink;
|
|
AContainer: TWinControl; AParentBuilder: TdxPSContainerBuilder; AParentHost: TdxReportCell = nil);
|
|
begin
|
|
inherited Create;
|
|
FReportLink := AReportLink;
|
|
FContainer := AContainer;
|
|
FParentBuilder := AParentBuilder;
|
|
FParentHost := AParentHost;
|
|
ReportLink.FActiveBuilder := Self;
|
|
end;
|
|
|
|
destructor TdxPSContainerBuilder.Destroy;
|
|
begin
|
|
ReportLink.FActiveBuilder := ParentBuilder;
|
|
inherited;
|
|
end;
|
|
|
|
function TdxPSContainerBuilder.Build: TdxReportCell;
|
|
var
|
|
Item: TdxReportVisualItem;
|
|
begin
|
|
Result := CreateHost;
|
|
BuildNestedControls;
|
|
Item := BuildControl(Container);
|
|
Item.Index := 0; // make it as first item
|
|
end;
|
|
|
|
function TdxPSContainerBuilder.BuildControl(AControl: TControl; AParentHost: TdxReportCell = nil): TdxReportVisualItem;
|
|
begin
|
|
FCurrentControl := AControl;
|
|
try
|
|
with Producers[AControl] do
|
|
begin
|
|
if AParentHost = nil then AParentHost := Host;
|
|
Result := ItemClass.Create(AParentHost);
|
|
CreateItemDefinition(AControl, Result);
|
|
InitializeItem(Result);
|
|
end;
|
|
InitializeItem(Result);
|
|
finally
|
|
FCurrentControl := nil;
|
|
end;
|
|
end;
|
|
|
|
function TdxPSContainerBuilder.BuildNestedContainer(AContainer: TWinControl;
|
|
AParentHost: TdxReportCell = nil): TdxReportCell;
|
|
begin
|
|
Result := ReportLink.BuildContainer(AContainer, Self, AParentHost);
|
|
end;
|
|
|
|
class function TdxPSContainerBuilder.ContainerClass: TWinControlClass;
|
|
begin
|
|
Result := TWinControl;
|
|
end;
|
|
|
|
class function TdxPSContainerBuilder.PairClass: TClass;
|
|
begin
|
|
Result := ContainerClass;
|
|
end;
|
|
|
|
class procedure TdxPSContainerBuilder.Register;
|
|
begin
|
|
dxContainerBuilderFactory.Register(Self);
|
|
end;
|
|
|
|
class procedure TdxPSContainerBuilder.Unregister;
|
|
begin
|
|
if not FIsContainerBuilderFactoryReleased then dxContainerBuilderFactory.Unregister(Self);
|
|
end;
|
|
|
|
procedure TdxPSContainerBuilder.BuildNestedControls;
|
|
var
|
|
Control: TControl;
|
|
Count, Index: Integer;
|
|
begin
|
|
if HasAvailableChildren(Container) then
|
|
with CreateNestedControlsIterator do
|
|
begin
|
|
Count := ControlCount;
|
|
Index := 1;
|
|
|
|
// Controls
|
|
GoBeyondEOF;
|
|
while not IsBOF do
|
|
begin
|
|
Control := Prev;
|
|
if not (Control is TWinControl) and ReportLink.DoIsComponentProcessed(Control) then
|
|
BuildControl(Control);
|
|
if IsRoot then
|
|
begin
|
|
Progress(100 * Index / Count);
|
|
if IsAborted then Break;
|
|
end;
|
|
Inc(Index);
|
|
end;
|
|
if IsAborted then Exit;
|
|
|
|
// WinControls
|
|
GoBeforeBOF;
|
|
while not IsEOF do
|
|
begin
|
|
Control := Next;
|
|
if (Control is TWinControl) and ReportLink.DoIsComponentProcessed(Control) then
|
|
BuildNestedContainer(TWinControl(Control), Host);
|
|
if IsRoot then
|
|
begin
|
|
Progress(100 * Index / Count);
|
|
if IsAborted then Break;
|
|
end;
|
|
Inc(Index);
|
|
end;
|
|
|
|
if not IsAborted then Progress(100);
|
|
end;
|
|
end;
|
|
|
|
function TdxPSContainerBuilder.CreateHost: TdxReportCell;
|
|
begin
|
|
FHost := Producers[Container].HostClass.Create(ParentHost);
|
|
InitializeHost;
|
|
Result := Host;
|
|
end;
|
|
|
|
function TdxPSContainerBuilder.CreateItemDefinition(AComponent: TComponent;
|
|
AnItem: TdxReportVisualItem): TdxPSCustomContainerItemDefinition;
|
|
begin
|
|
Result := ReportLink.CreateItemDefinition(AComponent, AnItem);
|
|
end;
|
|
|
|
function TdxPSContainerBuilder.CreateNestedControlsIterator: IdxPSContainerIterator;
|
|
begin
|
|
Result := Producers[Container].CreateIterator;
|
|
end;
|
|
|
|
procedure TdxPSContainerBuilder.InitializeHost;
|
|
begin
|
|
Producers[Container].InitializeHost(Host);
|
|
end;
|
|
|
|
procedure TdxPSContainerBuilder.InitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
ReportLink.DoInitializeItem(AnItem);
|
|
ReportLink.DoInitializeItemOptionsPlace(AnItem);
|
|
end;
|
|
|
|
function TdxPSContainerBuilder.IsAborted: Boolean;
|
|
begin
|
|
Result := ReportLink.AbortBuilding;
|
|
end;
|
|
|
|
procedure TdxPSContainerBuilder.Progress(const APercentDone: Double);
|
|
begin
|
|
ReportLink.DoProgress(APercentDone);
|
|
end;
|
|
|
|
function TdxPSContainerBuilder.GetParentHost: TdxReportCell;
|
|
begin
|
|
Result := FParentHost;
|
|
if Result = nil then
|
|
if ParentBuilder <> nil then
|
|
Result := ParentBuilder.Host
|
|
else
|
|
Result := ReportLink.RootCell;
|
|
end;
|
|
|
|
function TdxPSContainerBuilder.HasAvailableChildren(AControl: TControl): Boolean;
|
|
var
|
|
Producer: TdxPSCustomContainerItemProducer;
|
|
I: Integer;
|
|
Child: TControl;
|
|
begin
|
|
Result := False;
|
|
if (AControl is TWinControl) and (TWinControl(AControl).ControlCount <> 0) then
|
|
begin
|
|
Producer := Producers[AControl];
|
|
if Producer.CanHasAvailableChildren then
|
|
with TWinControl(AControl) do
|
|
for I := 0 to ControlCount - 1 do
|
|
begin
|
|
Child := Controls[I];
|
|
Result := Producer.CanProcessChild(Child) and ReportLink.DoIsComponentProcessed(Child);
|
|
if Result then Exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TdxPSContainerBuilder.GetDC: HDC;
|
|
begin
|
|
Result := ReportLink.ScreenDC;
|
|
end;
|
|
|
|
function TdxPSContainerBuilder.GetIsRoot: Boolean;
|
|
begin
|
|
Result := ParentBuilder = nil;
|
|
end;
|
|
|
|
function TdxPSContainerBuilder.GetProducer(AControl: TControl): TdxPSCustomContainerItemProducer;
|
|
begin
|
|
Result := ReportLink.Producers[AControl] as TdxPSCustomContainerItemProducer;
|
|
end;
|
|
|
|
{ TdxPSContainerReportLinkCustomCache }
|
|
|
|
constructor TdxPSContainerReportLinkCustomCache.Create(AReportLink: TdxCustomContainerReportLink);
|
|
begin
|
|
inherited Create;
|
|
FReportLink := AReportLink;
|
|
end;
|
|
|
|
function TdxPSContainerReportLinkCustomCache.ReportLink: TdxCustomContainerReportLink;
|
|
begin
|
|
Result := FReportLink;
|
|
end;
|
|
|
|
{ TdxPSCustomProducerCache }
|
|
|
|
function TdxPSCustomProducerCache.GetItem(Index: Integer): TdxPSCustomProducer;
|
|
begin
|
|
Result := TdxPSCustomProducer(inherited Items[Index]);
|
|
end;
|
|
|
|
function TdxPSCustomProducerCache.GetProducer(ProducerClass: TdxPSCustomProducerClass;
|
|
Component: TComponent): TdxPSCustomProducer;
|
|
var
|
|
Index: Integer;
|
|
begin
|
|
Index := IndexOfByClass(ProducerClass);
|
|
if (Index = -1) or (not ProducerClass.Reenterable and (Items[Index].ProducingObject <> Component)) then
|
|
Index := Add(ProducerClass.Create(ReportLink, Component));
|
|
Result := Items[Index];
|
|
Result.Initialize(Component);
|
|
end;
|
|
|
|
{ TdxCustomContainerReportLinkOptions }
|
|
|
|
constructor TdxCustomContainerReportLinkOptions.Create(AReportLink: TdxCustomContainerReportLink);
|
|
begin
|
|
inherited Create;
|
|
FReportLink := AReportLink;
|
|
RestoreDefaults;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptions.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxCustomContainerReportLinkOptions then
|
|
else
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptions.RestoreDefaults;
|
|
begin
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptions.Changed;
|
|
begin
|
|
if ReportLink <> nil then ReportLink.OptionsModified(Self);
|
|
end;
|
|
|
|
{ TdxCustomContainerOptionsBehavior }
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsBehavior.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxCustomContainerReportLinkOptionsBehavior then
|
|
with TdxCustomContainerReportLinkOptionsBehavior(Source) do
|
|
begin
|
|
Self.ConsumeExistingLinks := ConsumeExistingLinks;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsBehavior.RestoreDefaults;
|
|
begin
|
|
ConsumeExistingLinks := True;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsBehavior.SetConsumeExistingLinks(Value: Boolean);
|
|
begin
|
|
if FConsumeExistingLinks <> Value then
|
|
begin
|
|
FConsumeExistingLinks := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
{ TdxCustomContainerReportLinkOptionsDesignerTabs }
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsDesignerTabs.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxCustomContainerReportLinkOptionsDesignerTabs then
|
|
with TdxCustomContainerReportLinkOptionsDesignerTabs(Source) do
|
|
begin
|
|
Self.AutoHideReportLinksIfEmpty := AutoHideReportLinksIfEmpty;
|
|
Self.Controls := Controls;
|
|
Self.ReportLinks := ReportLinks;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsDesignerTabs.RestoreDefaults;
|
|
begin
|
|
inherited;
|
|
AutoHideReportLinksIfEmpty := True;
|
|
Controls := True;
|
|
ReportLinks := True;
|
|
end;
|
|
|
|
{ TdxCustomContainerReportLinkOptionsItemPlace }
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsItemPlace.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxCustomContainerReportLinkOptionsItemPlace then
|
|
with TdxCustomContainerReportLinkOptionsItemPlace(Source) do
|
|
begin
|
|
Self.ExpandHeight := ExpandHeight;
|
|
Self.ExpandWidth := ExpandWidth;
|
|
Self.ShrinkHeight := ShrinkHeight;
|
|
Self.ShrinkWidth := ShrinkWidth;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsItemPlace.RestoreDefaults;
|
|
begin
|
|
ExpandHeight := False;
|
|
ExpandWidth := False;
|
|
ShrinkHeight := False;
|
|
ShrinkWidth := False;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLinkOptionsItemPlace.GetData: Integer;
|
|
begin
|
|
Result := ((Ord(ExpandHeight) shl ExpandHeightOffset) and ExpandHeightBit) or
|
|
((Ord(ExpandWidth) shl ExpandWidthOffset) and ExpandWidthBit) or
|
|
((Ord(ShrinkHeight) shl ShrinkHeightOffset) and ShrinkHeightBit) or
|
|
((Ord(ShrinkWidth) shr ShrinkWidthOffset) and ShrinkWidthBit);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsItemPlace.SetData(Value: Integer);
|
|
begin
|
|
ExpandHeight := Boolean((Value and ExpandHeightOffset) shr ExpandHeightBit);
|
|
ExpandWidth := Boolean((Value and ExpandWidthOffset) shr ExpandWidthBit);
|
|
ShrinkHeight := Boolean((Value and ShrinkHeightOffset) shr ShrinkHeightBit);
|
|
ShrinkWidth := Boolean((Value and ShrinkWidthOffset) shr ShrinkWidthBit);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsItemPlace.ReadData(AStream: TStream);
|
|
var
|
|
Buffer: Integer;
|
|
begin
|
|
Buffer := GetData;
|
|
AStream.WriteBuffer(Buffer , SizeOf(Buffer));
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsItemPlace.WriteData(AStream: TStream);
|
|
var
|
|
Buffer: Integer;
|
|
begin
|
|
AStream.ReadBuffer(Buffer , SizeOf(Buffer));
|
|
SetData(Buffer);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLinkOptionsItemPlace.HasHorzResizing: Boolean;
|
|
begin
|
|
Result := ExpandWidth or ShrinkWidth;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLinkOptionsItemPlace.HasVertResizing: Boolean;
|
|
begin
|
|
Result := ExpandHeight or ShrinkHeight;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsItemPlace.SetAll;
|
|
begin
|
|
ExpandHeight := True;
|
|
ExpandWidth := True;
|
|
ShrinkHeight := True;
|
|
ShrinkWidth := True;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsItemPlace.UnsetAll;
|
|
begin
|
|
ExpandHeight := False;
|
|
ExpandWidth := False;
|
|
ShrinkHeight := False;
|
|
ShrinkWidth := False;
|
|
end;
|
|
|
|
{ TdxCustomContainerReportLinkOptionsPagination }
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsPagination.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxCustomContainerReportLinkOptionsPagination then
|
|
with TdxCustomContainerReportLinkOptionsPagination(Source) do
|
|
begin
|
|
Self.ControlDetails := ControlDetails;
|
|
Self.Controls := Controls;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsPagination.RestoreDefaults;
|
|
begin
|
|
inherited;
|
|
ControlDetails := True;
|
|
Controls := True;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsPagination.SetControlDetails(Value: Boolean);
|
|
begin
|
|
if FControlDetails <> Value then
|
|
begin
|
|
FControlDetails := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsPagination.SetControls(Value: Boolean);
|
|
begin
|
|
if FControls <> Value then
|
|
begin
|
|
FControls := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
{ TdxCustomContainerReportLinkOptionsRefinements }
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsRefinements.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxCustomContainerReportLinkOptionsRefinements then
|
|
with TdxCustomContainerReportLinkOptionsRefinements(Source) do
|
|
begin
|
|
Self.RootBorders := RootBorders;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsRefinements.RestoreDefaults;
|
|
begin
|
|
inherited;
|
|
RootBorders := False;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsRefinements.SetRootBorders(Value: Boolean);
|
|
begin
|
|
if FRootBorders <> Value then
|
|
begin
|
|
FRootBorders := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
{ TdxCustomContainerOptionsTransparent }
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsTransparent.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxCustomContainerReportLinkOptionsTransparent then
|
|
with TdxCustomContainerReportLinkOptionsTransparent(Source) do
|
|
begin
|
|
Self.Containers := Containers;
|
|
Self.Controls := Controls;
|
|
Self.Graphics := Graphics;
|
|
Self.Root := Root;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsTransparent.RestoreDefaults;
|
|
begin
|
|
Controls := True;
|
|
Containers := True;
|
|
Graphics := False;
|
|
Root := True;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsTransparent.SetContainters(Value: Boolean);
|
|
begin
|
|
if FContainers <> Value then
|
|
begin
|
|
FContainers := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsTransparent.SetControls(Value: Boolean);
|
|
begin
|
|
if FControls <> Value then
|
|
begin
|
|
FControls := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsTransparent.SetGraphics(Value: Boolean);
|
|
begin
|
|
if FGraphics <> Value then
|
|
begin
|
|
FGraphics := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLinkOptionsTransparent.SetRoot(Value: Boolean);
|
|
begin
|
|
if FRoot <> Value then
|
|
begin
|
|
FRoot := Value;
|
|
Changed;
|
|
end;
|
|
end;
|
|
|
|
{ TdxCustomContainerReportLink }
|
|
|
|
constructor TdxCustomContainerReportLink.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FAggregatedReportLinks := TStringList.Create;
|
|
FDefinitions := TList.Create;
|
|
FDelimitersHorz := TList.Create;
|
|
FDelimitersVert := TList.Create;
|
|
FExcludedComponents := TStringList.Create;
|
|
FHiddenComponents := TStringList.Create;
|
|
FPreparationFont := TFont.Create;
|
|
FProducerCache := TdxPSCustomProducerCache.Create(Self);
|
|
FSupportedCustomDraw := False;
|
|
CreateOptions;
|
|
end;
|
|
|
|
destructor TdxCustomContainerReportLink.Destroy;
|
|
begin
|
|
{$IFNDEF DELPHI5}
|
|
Destroying;
|
|
{$ENDIF}
|
|
DestroyOptions;
|
|
FreeAndNil(FPreparationFont);
|
|
FreeAndNil(FProducerCache);
|
|
FreeAndNil(FHiddenComponents);
|
|
FreeAndNil(FExcludedComponents);
|
|
FreeAndNil(FDelimitersVert);
|
|
FreeAndNil(FDelimitersHorz);
|
|
FreeAndNilDefinitions;
|
|
FreeAndNil(FAggregatedReportLinks);
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.Assign(Source: TPersistent);
|
|
begin
|
|
if Source is TdxCustomContainerReportLink then
|
|
with TdxCustomContainerReportLink(Source) do
|
|
begin
|
|
Self.FAggregatedReportLinks.Assign(FAggregatedReportLinks);
|
|
Self.FExcludedComponents.Assign(FExcludedComponents);
|
|
Self.FHiddenComponents.Assign(FHiddenComponents);
|
|
Self.OptionsBehavior := OptionsBehavior;
|
|
Self.OptionsDesignerTabs := OptionsDesignerTabs;
|
|
//Self.OptionsItemPlace := OptionsItemPlace; {.2}
|
|
Self.OptionsPagination := OptionsPagination;
|
|
Self.OptionsTransparent := OptionsTransparent;
|
|
Self.SupportedCustomDraw := SupportedCustomDraw;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
class function TdxCustomContainerReportLink.Aggregable: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.CanHideComponent(AComponent: TComponent): Boolean;
|
|
begin
|
|
Result := (AComponent <> nil) and (Container <> nil) and (AComponent <> Container);
|
|
if Result then
|
|
if AComponent is TControl then
|
|
Result := Container.ContainsControl(TControl(AComponent))
|
|
else
|
|
Result := (Container.Owner <> nil) and (Container.Owner = AComponent.Owner);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.CanHideComponentByName(const AName: string): Boolean;
|
|
begin
|
|
Result := (AName <> '') and (Container <> nil);
|
|
if Result then
|
|
begin
|
|
Result := Container.FindChildControl(AName) <> nil;
|
|
if not Result and (Container.Owner <> nil) then
|
|
Result := Container.Owner.FindComponent(AName) <> nil;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.HideComponent(AComponent: TComponent);
|
|
var
|
|
Index: Integer;
|
|
begin
|
|
if CanHideComponent(AComponent) and not FindHiddenComponent(AComponent, Index) then
|
|
FHiddenComponents.AddObject(AComponent.Name, AComponent)
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.HideComponentByName(const AName: string);
|
|
var
|
|
Index: Integer;
|
|
Component: TComponent;
|
|
begin
|
|
if CanHideComponentByName(AName) and not FindHiddenComponentByName(AName, Index) then
|
|
begin
|
|
Component := GetComponentByName(AName);
|
|
if Component <> nil then
|
|
FHiddenComponents.AddObject(AName, Component);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.HideComponents(const AComponents: array of TComponent);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := Low(AComponents) to High(AComponents) do
|
|
HideComponent(AComponents[I]);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.HideComponentsByName(const ANames: array of string);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := Low(ANames) to High(ANames) do
|
|
HideComponentByName(ANames[I]);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.FindHiddenComponent(AComponent: TComponent;
|
|
out AnIndex: Integer): Boolean;
|
|
begin
|
|
AnIndex := FHiddenComponents.IndexOfObject(AComponent);
|
|
Result := AnIndex <> -1;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.FindHiddenComponent(AComponent: TComponent): Boolean;
|
|
var
|
|
Index: Integer;
|
|
begin
|
|
Result := FindHiddenComponent(AComponent, Index);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.FindHiddenComponentByName(const AName: string;
|
|
out AnIndex: Integer): Boolean;
|
|
begin
|
|
AnIndex := FHiddenComponents.IndexOf(AName);
|
|
Result := AnIndex <> -1;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.FindHiddenComponentByName(const AName: string): Boolean;
|
|
var
|
|
Index: Integer;
|
|
begin
|
|
Result := FindHiddenComponentByName(AName, Index);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.UnhideAllComponents;
|
|
begin
|
|
FHiddenComponents.Clear;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.UnhideComponent(AComponent: TComponent);
|
|
var
|
|
Index: Integer;
|
|
begin
|
|
if FindHiddenComponent(AComponent, Index) then
|
|
FHiddenComponents.Delete(Index);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.UnhideComponentByName(const AName: string);
|
|
var
|
|
Index: Integer;
|
|
begin
|
|
if FindHiddenComponentByName(AName, Index) then
|
|
FHiddenComponents.Delete(Index);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.UnhideComponents(const AComponents: array of TComponent);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := Low(AComponents) to High(AComponents) do
|
|
UnhideComponent(AComponents[I]);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.UnhideComponentsByName(const ANames: array of string);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := Low(ANames) to High(ANames) do
|
|
UnhideComponentByName(ANames[I]);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.HideStandardControls;
|
|
var
|
|
I, J: Integer;
|
|
ControlClass: TClass;
|
|
Control: TControl;
|
|
begin
|
|
if Container <> nil then
|
|
for I := Low(StandardHiddenControls) to High(StandardHiddenControls) do
|
|
begin
|
|
ControlClass := Classes.GetClass(StandardHiddenControls[I]);
|
|
if ControlClass <> nil then
|
|
for J := 0 to Container.ControlCount - 1 do
|
|
begin
|
|
Control := Container.Controls[J];
|
|
if Control is ControlClass then
|
|
HideComponent(Control);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.UnhideStandardControls;
|
|
var
|
|
I, J: Integer;
|
|
ControlClass: TClass;
|
|
Control: TControl;
|
|
begin
|
|
if Container <> nil then
|
|
for I := Low(StandardHiddenControls) to High(StandardHiddenControls) do
|
|
begin
|
|
ControlClass := Classes.GetClass(StandardHiddenControls[I]);
|
|
if ControlClass <> nil then
|
|
for J := 0 to Container.ControlCount - 1 do
|
|
begin
|
|
Control := Container.Controls[J];
|
|
if Control is ControlClass then
|
|
UnhideComponent(Control);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.CanExcludeComponent(AComponent: TComponent): Boolean;
|
|
begin
|
|
Result := (AComponent <> nil) and (Container <> nil) and (AComponent <> Container);
|
|
if Result then
|
|
if AComponent is TControl then
|
|
Result := Container.ContainsControl(TControl(AComponent))
|
|
else
|
|
Result := (Container.Owner <> nil) and (Container.Owner = AComponent.Owner);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.CanExcludeComponentByName(const AName: string): Boolean;
|
|
begin
|
|
Result := (AName <> '') and (Container <> nil);
|
|
if Result then
|
|
begin
|
|
Result := Container.FindChildControl(AName) <> nil;
|
|
if not Result and (Container.Owner <> nil) then
|
|
Result := Container.Owner.FindComponent(AName) <> nil;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.ExcludeComponent(AComponent: TComponent);
|
|
var
|
|
Index: Integer;
|
|
begin
|
|
if CanExcludeComponent(AComponent) and not FindExcludedComponent(AComponent, Index) then
|
|
FExcludedComponents.AddObject(AComponent.Name, AComponent);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.ExcludeComponentByName(const AName: string);
|
|
var
|
|
Index: Integer;
|
|
Component: TComponent;
|
|
begin
|
|
if CanExcludeComponentByName(AName) and not FindExcludedComponentByName(AName, Index) then
|
|
begin
|
|
Component := GetComponentByName(AName);
|
|
if Component <> nil then
|
|
FExcludedComponents.AddObject(AName, Component);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.ExcludeComponents(const AComponents: array of TComponent);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := Low(AComponents) to High(AComponents) do
|
|
ExcludeComponent(AComponents[I]);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.ExcludeComponentsByName(const ANames: array of string);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := Low(ANames) to High(ANames) do
|
|
ExcludeComponentByName(ANames[I]);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.FindExcludedComponent(AComponent: TComponent;
|
|
out AnIndex: Integer): Boolean;
|
|
begin
|
|
AnIndex := FExcludedComponents.IndexOfObject(AComponent);
|
|
Result := AnIndex <> -1;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.FindExcludedComponent(AComponent: TComponent): Boolean;
|
|
var
|
|
Index: Integer;
|
|
begin
|
|
Result := FindExcludedComponent(AComponent, Index);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.FindExcludedComponentByName(const AName: string;
|
|
out AnIndex: Integer): Boolean;
|
|
begin
|
|
AnIndex := FExcludedComponents.IndexOf(AName);
|
|
Result := AnIndex <> -1;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.FindExcludedComponentByName(const AName: string): Boolean;
|
|
var
|
|
Index: Integer;
|
|
begin
|
|
Result := FindExcludedComponentByName(AName, Index);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.UnexcludeAllComponents;
|
|
begin
|
|
FExcludedComponents.Clear;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.UnexcludeComponent(AComponent: TComponent);
|
|
var
|
|
Index: Integer;
|
|
begin
|
|
if FindExcludedComponent(AComponent, Index) then
|
|
FExcludedComponents.Delete(Index);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.UnexcludeComponentByName(const AName: string);
|
|
var
|
|
Index: Integer;
|
|
begin
|
|
if FindExcludedComponentByName(AName, Index) then
|
|
FExcludedComponents.Delete(Index);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.UnexcludeComponents(const AComponents: array of TComponent);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := Low(AComponents) to High(AComponents) do
|
|
UnexcludeComponent(AComponents[I]);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.UnexcludeComponentsByName(const ANames: array of string);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := Low(ANames) to High(ANames) do
|
|
UnexcludeComponentByName(ANames[I]);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.AggregateLink(AReportLink: TBasedxReportLink);
|
|
begin
|
|
if IsLinkAggregable(AReportLink) and not IsLinkAggregated(AReportLink) then
|
|
FAggregatedReportLinks.AddObject(AReportLink.Name, AReportLink);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.DisaggregateAllLinks;
|
|
begin
|
|
InstallAggregatedReportLinksController(False);
|
|
FAggregatedReportLinks.Clear;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.DisaggregateInconsistentLinks;
|
|
var
|
|
I: Integer;
|
|
Link: TBasedxReportLink;
|
|
begin
|
|
for I := AggregatedReportLinkCount - 1 downto 0 do
|
|
begin
|
|
Link := AggregatedReportLinks[I];
|
|
if not IsLinkAggregatedConsistently(Link) then DisaggregateLink(Link);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.DisaggregateLink(AReportLink: TBasedxReportLink);
|
|
var
|
|
Index: Integer;
|
|
begin
|
|
Index := FAggregatedReportLinks.IndexOfObject(AReportLink);
|
|
if Index <> -1 then
|
|
begin
|
|
TBasedxReportLinkAccess(AReportLink).Controller := nil;
|
|
FAggregatedReportLinks.Delete(Index);
|
|
end;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.FindAggregatedLinkByComponent(AComponent: TComponent): TBasedxReportLink;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
if AComponent <> nil then
|
|
for I := 0 to AggregatedReportLinkCount - 1 do
|
|
begin
|
|
Result := AggregatedReportLinks[I];
|
|
if (Result <> nil) and (Result.Component = AComponent) then
|
|
Exit;
|
|
end;
|
|
Result := nil;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.HasInconsistentlyAggregatedLinks: Boolean;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := True;
|
|
for I := 0 to AggregatedReportLinkCount - 1 do
|
|
if not IsLinkAggregatedConsistently(AggregatedReportLinks[I]) then
|
|
Exit;
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.IsLinkAggregable(AReportLink: TBasedxReportLink): Boolean;
|
|
begin
|
|
Result := (AReportLink <> nil) and (AReportLink <> Self) and AReportLink.Aggregable;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.IsLinkAggregated(AReportLink: TBasedxReportLink): Boolean;
|
|
begin
|
|
Result := FAggregatedReportLinks.IndexOfObject(AReportLink) <> -1;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.IsLinkAggregatedConsistently(AReportLink: TBasedxReportLink): Boolean;
|
|
begin
|
|
Result := IsLinkAggregated(AReportLink) and (AReportLink.Component is TControl) and
|
|
(Container <> nil) and Container.ContainsControl(TControl(AReportLink.Component));
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.DefineProperties(Filer: TFiler);
|
|
begin
|
|
inherited;
|
|
Filer.DefineBinaryProperty('HiddenComponents', ReadHiddenComponents,
|
|
WriteHiddenComponents, True);
|
|
Filer.DefineBinaryProperty('ExcludedComponents', ReadExcludedComponents,
|
|
WriteExcludedComponents, True);
|
|
Filer.DefineBinaryProperty('AggregatedReportLinks', ReadAggregatedReportLinks,
|
|
WriteAggregatedReportLinks, True);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.Loaded;
|
|
begin
|
|
inherited;
|
|
LoadHiddenComponents;
|
|
LoadExcludedComponents;
|
|
LoadAggregatedReportLinks;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.Notification(AComponent: TComponent; Operation: TOperation);
|
|
begin
|
|
inherited;
|
|
if (Operation = opRemove) and not IsDestroying then
|
|
begin
|
|
UnexcludeComponent(AComponent);
|
|
UnhideComponent(AComponent);
|
|
if AComponent is TBasedxReportLink then
|
|
DisaggregateLink(TBasedxReportLink(AComponent));
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.AfterDesignReport(ADone: Boolean);
|
|
begin
|
|
InstallAggregatedReportLinksController(False);
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.BeforeDesignReport;
|
|
begin
|
|
inherited;
|
|
InstallAggregatedReportLinksController(True);
|
|
HideDesignerTabs(DesignWindow);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.ConstructReport(AReportCells: TdxReportCells);
|
|
var
|
|
Root: TdxReportCell;
|
|
begin
|
|
inherited;
|
|
if Container = nil then Exit;
|
|
|
|
PrepareConstruct;
|
|
try
|
|
Root := BuildContainer(Container, nil, nil);
|
|
if not AbortBuilding then
|
|
begin
|
|
RepositionControls;
|
|
Root.Left := 0;
|
|
Root.Top := 0;
|
|
AReportCells.Cells.BoundsRect := MakeRect(0, 0, Root.Width, Root.Height);
|
|
end;
|
|
finally
|
|
UnprepareConstruct;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.ConvertCoords;
|
|
|
|
procedure ConvertDelimiters(ADelimiters: TList);
|
|
var
|
|
I, Value: Integer;
|
|
begin
|
|
for I := 0 to ADelimiters.Count - 1 do
|
|
begin
|
|
Value := Integer(ADelimiters[I]);
|
|
Value := MulDiv(Value, PixelsNumerator, PixelsDenominator);
|
|
ADelimiters[I] := Pointer(Value);
|
|
end;
|
|
end;
|
|
|
|
begin
|
|
inherited;
|
|
ConvertDelimiters(DelimitersHorz);
|
|
ConvertDelimiters(DelimitersVert);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.CustomDraw(AItem: TAbstractdxReportCellData;
|
|
ACanvas: TCanvas; ABoundsRect, AClientRect: TRect; var ADone: Boolean);
|
|
begin
|
|
if AItem.Data <> 0 then DoCustomDrawItem(ACanvas, AItem, ADone);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.DoApplyInDesigner;
|
|
begin
|
|
inherited;
|
|
InstallAggregatedReportLinksController(True);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.DoChangeComponent;
|
|
begin
|
|
inherited;
|
|
DisaggregateAllLinks;
|
|
UnexcludeAllComponents;
|
|
UnhideAllComponents;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetDesignerClass: TdxReportLinkDesignWindowClass;
|
|
begin
|
|
Result := inherited GetDesignerClass;
|
|
if (Result = nil) and ((Component is TForm) {$IFDEF DELPHI5} or (Component is TFrame) {$ENDIF}) then
|
|
Result := TdxfmCustomContainerDesignWindow;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetEmptyPagesCanExist: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.GetImageLists(AProc: TdxPSGetImageListProc);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
inherited;
|
|
for I := 0 to DefinitionCount - 1 do
|
|
Producers[Definitions[I].Component].GetImageLists(AProc);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.InternalRestoreDefaults;
|
|
begin
|
|
inherited;
|
|
|
|
OptionsBehavior.RestoreDefaults;
|
|
OptionsDesignerTabs.RestoreDefaults;
|
|
//OptionsItemPlace.RestoreDefaults; {.2}
|
|
OptionsPagination.RestoreDefaults;
|
|
OptionsRefinements.RestoreDefaults;
|
|
OptionsTransparent.RestoreDefaults;
|
|
|
|
SupportedCustomDraw := False;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.IsSupportedCustomDraw(Item: TAbstractdxReportCellData): Boolean;
|
|
begin
|
|
Result := SupportedCustomDraw and (Item <> nil) and (Item.Data <> 0);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.MakeDelimiters(AReportCells: TdxReportCells;
|
|
AHorzDelimiters, AVertDelimiters: TList);
|
|
begin
|
|
inherited;
|
|
dxPSUtl.dxAppendList(DelimitersHorz, AHorzDelimiters);
|
|
dxPSUtl.dxAppendList(DelimitersVert, AVertDelimiters);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.BuildContainer(AContainer: TWinControl;
|
|
AParentBuilder: TdxPSContainerBuilder; AParentHost: TdxReportCell = nil): TdxReportCell;
|
|
begin
|
|
with CreateBuilder(AContainer, AParentBuilder, AParentHost) do
|
|
try
|
|
Result := Build;
|
|
finally
|
|
Free;
|
|
end;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.CreateBuilder(AContainer: TWinControl;
|
|
AParentBuilder: TdxPSContainerBuilder; AParentHost: TdxReportCell = nil): TdxPSContainerBuilder;
|
|
begin
|
|
Result := dxContainerBuilderFactory.CreateBuilder(Self, AContainer, AParentBuilder, AParentHost);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.CreateItemDefinition(AComponent: TComponent;
|
|
AnItem: TdxReportVisualItem): TdxPSCustomContainerItemDefinition;
|
|
begin
|
|
with Producers[AComponent] do
|
|
begin
|
|
Result := DefinitionClass.Create(Self, AComponent, AnItem);
|
|
InitializeOptionsPlace(Result.OptionsPlace);
|
|
end;
|
|
AddDefinition(Result);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetProducer(Component: TComponent): TdxPSCustomProducer;
|
|
begin
|
|
Result := ProducerCache[dxPSContainerItemProducerFactory[Component, Component = Container], Component];
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.DoCustomDrawItem(ACanvas: TCanvas;
|
|
AnItem: TAbstractdxReportCellData; var ADone: Boolean);
|
|
begin
|
|
if Assigned(FOnCustomDrawItem) then
|
|
FOnCustomDrawItem(Self, ACanvas, AnItem, TComponent(TObject(AnItem.Data)), ADone);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.DoGetComponentCaption(AComponent: TComponent;
|
|
var ACaption: string);
|
|
begin
|
|
if Assigned(FOnGetComponentCaption) then
|
|
FOnGetComponentCaption(Self, AComponent, ACaption)
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.DoGetReportLink(AComponent: TComponent): TBasedxReportLink;
|
|
begin
|
|
Result := nil;
|
|
//if OptionsBehavior.ConsumeExistingLinks then
|
|
Result := FindAggregatedLinkByComponent(AComponent);
|
|
if Assigned(FOnGetComponentReportLink) then
|
|
FOnGetComponentReportLink(Self, AComponent, Result);
|
|
if Result <> nil then
|
|
Result.Initialize;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.DoInitializeItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
if Assigned(FOnInitializeItem) then
|
|
FOnInitializeItem(Self, AnItem, TComponent(TObject(AnItem.Data)));
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.DoInitializeItemOptionsPlace(AnItem: TdxReportVisualItem);
|
|
begin
|
|
if Assigned(FOnInitializeItemOptionsPlace) then
|
|
FOnInitializeItemOptionsPlace(Self, AnItem, TComponent(TObject(AnItem.Data)),
|
|
DefinitionsByReportItem[AnItem].OptionsPlace);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.DoInitializeReportLink(AReportLink: TBasedxReportLink;
|
|
AStage: TdxPSReportLinkProcessingStage);
|
|
begin
|
|
if Assigned(FOnInitializeReportLink) then
|
|
FOnInitializeReportLink(Self, AReportLink, AStage);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.DoIsComponentProcessed(AComponent: TComponent): Boolean;
|
|
var
|
|
Index: Integer;
|
|
begin
|
|
Result := (not (AComponent is TControl) or
|
|
(TControl(AComponent).Visible and not IsRectEmpty(TControl(AComponent).BoundsRect))) and
|
|
not FindHiddenComponent(AComponent, Index) and not FindExcludedComponent(AComponent, Index);
|
|
if Assigned(FOnIsComponentProcessed) then
|
|
FOnIsComponentProcessed(Self, AComponent, Result);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.CreateOptions;
|
|
begin
|
|
FOptionsBehavior := GetOptionsBehaviorClass.Create(Self);
|
|
FOptionsDesignerTabs := GetOptionsDesignerTabsClass.Create(Self);
|
|
//FOptionsItemPlace := GetOptionsItemPlaceClass.Create(Self); {.2}
|
|
FOptionsPagination := GetOptionsPaginationClass.Create(Self);
|
|
FOptionsRefinements := GetOptionsRefinementsClass.Create(Self);
|
|
FOptionsTransparent := GetOptionsTransparentClass.Create(Self);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.DestroyOptions;
|
|
begin
|
|
FreeAndNil(FOptionsTransparent);
|
|
FreeAndNil(FOptionsRefinements);
|
|
FreeAndNil(FOptionsPagination);
|
|
//FreeAndNil(FOptionsItemPlace); {.2}
|
|
FreeAndNil(FOptionsDesignerTabs);
|
|
FreeAndNil(FOptionsBehavior);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetOptionsBehaviorClass: TdxCustomContainerReportLinkOptionsBehaviorClass;
|
|
begin
|
|
Result := TdxCustomContainerReportLinkOptionsBehavior;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetOptionsDesignerTabsClass: TdxCustomContainerReportLinkOptionsDesignerTabsClass;
|
|
begin
|
|
Result := TdxCustomContainerReportLinkOptionsDesignerTabs;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetOptionsItemPlaceClass: TdxCustomContainerReportLinkOptionsItemPlaceClass;
|
|
begin
|
|
Result := TdxCustomContainerReportLinkOptionsItemPlace;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetOptionsPaginationClass: TdxCustomContainerReportLinkOptionsPaginationClass;
|
|
begin
|
|
Result := TdxCustomContainerReportLinkOptionsPagination;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetOptionsRefinementsClass: TdxCustomContainerReportLinkOptionsRefinementsClass;
|
|
begin
|
|
Result := TdxCustomContainerReportLinkOptionsRefinements;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetOptionsTransparentClass: TdxCustomContainerReportLinkOptionsTransparentClass;
|
|
begin
|
|
Result := TdxCustomContainerReportLinkOptionsTransparent;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.OptionsModified(AnOptions: TdxCustomContainerReportLinkOptions);
|
|
begin
|
|
LinkModified(True);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.PrepareConstruct;
|
|
begin
|
|
ClearDefinitions;
|
|
FScreenDC := GetDC(0);
|
|
CreateRootLookAndFeel;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.UnprepareConstruct;
|
|
begin
|
|
if not AbortBuilding then
|
|
begin
|
|
PullReportItems;
|
|
AddDelimiters;
|
|
end;
|
|
ReleaseDC(0, FScreenDC);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.AddDefinition(ADefinition: TdxPSCustomContainerItemDefinition);
|
|
begin
|
|
FDefinitions.Add(ADefinition);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.ClearDefinitions;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to DefinitionCount - 1 do
|
|
Definitions[I].Free;
|
|
FDefinitions.Clear;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.FindDefinition(AComponent: TComponent;
|
|
out AnIndex: Integer): Boolean;
|
|
begin
|
|
AnIndex := FDefinitions.IndexOf(DefinitionsByContainerItem[AComponent]);
|
|
Result := AnIndex <> -1;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.FindDefinition(AnItem: TdxReportVisualItem;
|
|
out AnIndex: Integer): Boolean;
|
|
begin
|
|
AnIndex := FDefinitions.IndexOf(DefinitionsByReportItem[AnItem]);
|
|
Result := AnIndex <> -1;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.FreeAndNilDefinitions;
|
|
begin
|
|
ClearDefinitions;
|
|
FreeAndNil(FDefinitions);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.DeleteDefinition(Index: Integer);
|
|
begin
|
|
Definitions[Index].Free;
|
|
FDefinitions.Delete(Index);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.AddControl(ATreeView: TTreeView;
|
|
AParent: TTreeNode; AControl: TControl);
|
|
var
|
|
Index, I: Integer;
|
|
Control: TControl;
|
|
begin
|
|
AParent := AddNode(ATreeView, AParent, AControl, not FindExcludedComponent(AControl, Index));
|
|
if AControl is TWinControl then
|
|
for I := 0 to TWinControl(AControl).ControlCount - 1 do
|
|
begin
|
|
Control := TWinControl(AControl).Controls[I];
|
|
if Producers[AControl].CanProcessChild(Control) and not FindHiddenComponent(Control, Index) then
|
|
AddControl(ATreeView, AParent, Control);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.AddHiddenControl(ATreeView: TTreeView;
|
|
AParent: TTreeNode; AControl: TControl);
|
|
var
|
|
Index, I: Integer;
|
|
Control: TControl;
|
|
begin
|
|
AParent := AddNode(ATreeView, AParent, AControl, not FindHiddenComponent(AControl, Index));
|
|
if AControl is TWinControl then
|
|
for I := 0 to TWinControl(AControl).ControlCount - 1 do
|
|
begin
|
|
Control := TWinControl(AControl).Controls[I];
|
|
if Producers[AControl].CanProcessChild(Control) then
|
|
AddHiddenControl(ATreeView, AParent, Control);
|
|
end;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.AddNode(ATreeView: TTreeView;
|
|
AParent: TTreeNode; AComponent: TComponent; AChecked: Boolean): TTreeNode;
|
|
|
|
function PrepareText(const S: string): string;
|
|
|
|
procedure DoTrancateString(var S: string);
|
|
begin
|
|
if Length(S) > 255 then
|
|
begin
|
|
Delete(S, 256, Length(S) - 255);
|
|
Delete(S, Length(S) - 3, 3);
|
|
S := S + '...';
|
|
end;
|
|
end;
|
|
|
|
begin
|
|
Result := S;
|
|
DoTrancateString(Result);
|
|
Result := RemoveAccelChars(Result, False);
|
|
end;
|
|
|
|
var
|
|
NodeObject: TdxNodeObject;
|
|
S: string;
|
|
begin
|
|
NodeObject := CreateNodeObject(AComponent, AChecked);
|
|
S := PrepareText(NodeObject.Caption);
|
|
Result := ATreeView.Items.AddChildObject(AParent, S, NodeObject);
|
|
Result.StateIndex := dxPSUtl.dxCheckStateImageIndexMap(NodeObject.State);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.CreateNodeObject(AComponent: TComponent;
|
|
AChecked: Boolean): TdxNodeObject;
|
|
const
|
|
StateMap: array[Boolean] of TCheckBoxState = (cbUnchecked, cbChecked);
|
|
begin
|
|
Result := TdxNodeObject.Create;
|
|
with Result do
|
|
begin
|
|
Caption := Producers[AComponent].ProducingObjectFriendlyName;
|
|
Component := AComponent;
|
|
DoGetComponentCaption(AComponent, Caption);
|
|
State := StateMap[AChecked];
|
|
end;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.IsComponentEditable(AComponent: TComponent): Boolean;
|
|
begin
|
|
Result := AComponent <> Container;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.LoadControlsTree(ATreeView: TTreeView);
|
|
begin
|
|
ATreeView.Items.Clear;
|
|
if Container <> nil then
|
|
AddControl(ATreeView, nil, Container);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.LoadHiddenControlsTree(ATreeView: TTreeView);
|
|
begin
|
|
ATreeView.Items.Clear;
|
|
if Container <> nil then
|
|
AddHiddenControl(ATreeView, nil, Container);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.InstallAggregatedReportLinksController(AnInstall: Boolean);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to AggregatedReportLinkCount - 1 do
|
|
with TBasedxReportLinkAccess(AggregatedReportLinks[I]) do
|
|
if AnInstall then
|
|
Controller := Self
|
|
else
|
|
Controller := nil;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetComponentByName(const AName: string): TComponent;
|
|
begin
|
|
if AName <> '' then
|
|
begin
|
|
Result := Container.FindChildControl(AName);
|
|
if (Result = nil) and (Container <> nil) and (Container.Owner <> nil) then
|
|
Result := Container.Owner.FindComponent(AName);
|
|
end
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetPreparedFontIndex(AFont: TFont): Integer;
|
|
begin
|
|
Result := GetPreparedFontIndex(AFont, True, AFont.Name, AFont.Color, AFont.Style);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetPreparedFontIndex(AFont: TFont; AnIsFontSubstitutable: Boolean;
|
|
const AFontName: string; AFontColor: TColor; AFontStyle: TFontStyles): Integer;
|
|
begin
|
|
PreparationFont.Assign(AFont);
|
|
if AnIsFontSubstitutable and not dxIsTrueTypeFont(AFont) then
|
|
PreparationFont.Name := Font.Name
|
|
else
|
|
PreparationFont.Name := AFontName;
|
|
PreparationFont.Color := AFontColor;
|
|
PreparationFont.Style := AFontStyle;
|
|
Result := AddFontToPool(PreparationFont);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.IsComponentProcessed(AComponent: TComponent): Boolean;
|
|
begin
|
|
Result := DefinitionsByContainerItem[AComponent] <> nil;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.AddDelimiters;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
DelimitersHorz.Clear;
|
|
DelimitersVert.Clear;
|
|
for I := 0 to DefinitionCount - 1 do
|
|
with Definitions[I] do
|
|
begin
|
|
AddDelimitersHorz(DelimitersHorz);
|
|
AddDelimitersVert(DelimitersVert);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.CreateRootLookAndFeel;
|
|
begin
|
|
ReportCells.LookAndFeel := CreateGroupLookAndFeel(TdxPSReportGroupStandardLookAndFeel);
|
|
with ReportCells.LookAndFeel do
|
|
begin
|
|
FontIndex := AddFontToPool(Control_GetFont(Container));
|
|
CaptionFontIndex := ReportCells.LookAndFeel.FontIndex;
|
|
Color := Control_GetColor(Container);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.HideDesignerTabs(ADesignWindow: TdxfmCustomContainerDesignWindow);
|
|
begin
|
|
if not IsDesigning then
|
|
with OptionsDesignerTabs do
|
|
begin
|
|
ADesignWindow.ReportLinksTab.TabVisible :=
|
|
ReportLinks and ((AggregatedReportLinkCount <> 0) or not AutoHideReportLinksIfEmpty);
|
|
ADesignWindow.ControlsTab.TabVisible := Controls;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.PullReportItems;
|
|
|
|
procedure PullNestedItem(AnItem: TdxReportVisualItem);
|
|
begin
|
|
with AnItem do
|
|
begin
|
|
Left := Left + Parent.Left;
|
|
Top := Top + Parent.Top;
|
|
Parent := Parent.Parent;
|
|
end;
|
|
end;
|
|
|
|
function NeedToBeEliminated(AnItem: TdxReportVisualItem): Boolean;
|
|
const
|
|
MaxHeight = High(Word) div 2;
|
|
begin
|
|
Result := AnItem.Height > MaxHeight;
|
|
end;
|
|
|
|
procedure EnumNestedItems(ACell: TdxReportCell; APull: Boolean);
|
|
var
|
|
I, Index: Integer;
|
|
Item: TdxReportVisualItem;
|
|
begin
|
|
for I := ACell.CellCount - 1 downto 0 do
|
|
begin
|
|
Item := ACell.Cells[I];
|
|
if APull then PullNestedItem(Item);
|
|
|
|
if NeedToBeEliminated(Item) then
|
|
begin
|
|
EnumNestedItems(TdxReportCell(Item), True);
|
|
if FindDefinition(Item, Index) then DeleteDefinition(Index);
|
|
Item.Free;
|
|
end;
|
|
end;
|
|
|
|
for I := ACell.DataItemCount - 1 downto 0 do
|
|
begin
|
|
Item := ACell.DataItems[I];
|
|
if NeedToBeEliminated(Item) then
|
|
begin
|
|
if FindDefinition(Item, Index) then DeleteDefinition(Index);
|
|
Item.Free;
|
|
end
|
|
else
|
|
if APull then PullNestedItem(Item);
|
|
end;
|
|
end;
|
|
|
|
begin
|
|
if IsWin9X then EnumNestedItems(RootCell, False);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.RepositionControls;
|
|
|
|
procedure EnumContainer(AContainer: TWinControl);
|
|
var
|
|
I: Integer;
|
|
Control: TControl;
|
|
begin
|
|
for I := 0 to AContainer.ControlCount - 1 do
|
|
begin
|
|
Control := AContainer.Controls[I];
|
|
if IsComponentProcessed(Control) then
|
|
begin
|
|
if Control is TWinControl then
|
|
EnumContainer(TWinControl(Control));
|
|
Producers[Control].Reposition;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
begin
|
|
EnumContainer(Container);
|
|
Producers[Container].Reposition;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.NeedTwoPassRendering: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.IsScaleGridLines: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetAggregatedReportLink(Index: Integer): TBasedxReportLink;
|
|
begin
|
|
Result := TBasedxReportLink(FAggregatedReportLinks.Objects[Index]);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetAggregatedReportLinkCount: Integer;
|
|
begin
|
|
Result := FAggregatedReportLinks.Count;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetContainer: TWinControl;
|
|
begin
|
|
Result := TWinControl(Component);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetController: TdxCustomContainerReportLink;
|
|
begin
|
|
Result := inherited Controller as TdxCustomContainerReportLink;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetDefinition(Index: Integer): TdxPSCustomContainerItemDefinition;
|
|
begin
|
|
Result := TdxPSCustomContainerItemDefinition(FDefinitions[Index]);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetDefinitionByContainerItem(Component: TComponent): TdxPSCustomContainerItemDefinition;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to DefinitionCount - 1 do
|
|
begin
|
|
Result := Definitions[I];
|
|
if Result.Component = Component then Exit;
|
|
end;
|
|
Result := nil;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetDefinitionByReportItem(Item: TdxReportVisualItem): TdxPSCustomContainerItemDefinition;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to DefinitionCount - 1 do
|
|
begin
|
|
Result := Definitions[I];
|
|
if Result.ReportItem = Item then Exit;
|
|
end;
|
|
Result := nil;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetDefinitionCount: Integer;
|
|
begin
|
|
Result := FDefinitions.Count;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetDelimitersHorzCount: Integer;
|
|
begin
|
|
Result := DelimitersHorz.Count;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetDelimitersHorzItem(Index: Integer): Integer;
|
|
begin
|
|
Result := Integer(DelimitersHorz[Index]);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetDelimitersVertCount: Integer;
|
|
begin
|
|
Result := DelimitersVert.Count;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetDelimitersVertItem(Index: Integer): Integer;
|
|
begin
|
|
Result := Integer(DelimitersVert[Index]);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetDesignWindow: TdxfmCustomContainerDesignWindow;
|
|
begin
|
|
Result := inherited DesignWindow as TdxfmCustomContainerDesignWindow;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetExcludedComponent(Index: Integer): TComponent;
|
|
begin
|
|
Result := TComponent(FExcludedComponents.Objects[Index]);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetExcludedComponentCount: Integer;
|
|
begin
|
|
Result := FExcludedComponents.Count;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetHiddenComponent(Index: Integer): TComponent;
|
|
begin
|
|
Result := TComponent(FHiddenComponents.Objects[Index]);
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetHiddenComponentCount: Integer;
|
|
begin
|
|
Result := FHiddenComponents.Count;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetProducerByClass(ProducerClass: TdxPSCustomProducerClass;
|
|
Component: TComponent): TdxPSCustomProducer;
|
|
begin
|
|
Result := ProducerCache[ProducerClass, Component];
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetRootCell: TdxReportCell;
|
|
begin
|
|
Result := ReportCells.Cells;
|
|
end;
|
|
|
|
function TdxCustomContainerReportLink.GetTopLevelContainer: TWinControl;
|
|
begin
|
|
if IsAggregated then
|
|
Result := Controller.TopLevelContainer
|
|
else
|
|
Result := Container;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.SetController(Value: TdxCustomContainerReportLink);
|
|
begin
|
|
inherited Controller := Value;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.SetOnCustomDrawItem(Value: TdxContainerReportLinkCustomDrawItemEvent);
|
|
begin
|
|
if @FOnCustomDrawItem <> @Value then
|
|
begin
|
|
FOnCustomDrawItem := Value;
|
|
if SupportedCustomDraw then LinkModified(True);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.SetOptionsBehavior(Value: TdxCustomContainerReportLinkOptionsBehavior);
|
|
begin
|
|
OptionsBehavior.Assign(Value);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.SetOptionsDesignerTabs(Value: TdxCustomContainerReportLinkOptionsDesignerTabs);
|
|
begin
|
|
OptionsDesignerTabs.Assign(Value);
|
|
end;
|
|
{.2}
|
|
{procedure TdxCustomContainerReportLink.SetOptionsItemPlace(Value: TdxCustomContainerReportLinkOptionsItemPlace);
|
|
begin
|
|
OptionsItemPlace.Assign(Value);
|
|
end;}
|
|
|
|
procedure TdxCustomContainerReportLink.SetOptionsPagination(Value: TdxCustomContainerReportLinkOptionsPagination);
|
|
begin
|
|
OptionsPagination.Assign(Value);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.SetOptionsRefinements(Value: TdxCustomContainerReportLinkOptionsRefinements);
|
|
begin
|
|
OptionsRefinements.Assign(Value);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.SetOptionsTransparent(Value: TdxCustomContainerReportLinkOptionsTransparent);
|
|
begin
|
|
OptionsTransparent.Assign(Value);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.SetSupportedCustomDraw(Value: Boolean);
|
|
begin
|
|
if FSupportedCustomDraw <> Value then
|
|
begin
|
|
FSupportedCustomDraw := Value;
|
|
LinkModified(True);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.LoadAggregatedReportLinks;
|
|
var
|
|
I: Integer;
|
|
Component: TComponent;
|
|
begin
|
|
if Owner <> nil then
|
|
for I := AggregatedReportLinkCount - 1 downto 0 do
|
|
begin
|
|
Component := Owner.FindComponent(FAggregatedReportLinks[I]);
|
|
if Component <> nil then
|
|
FAggregatedReportLinks.Objects[I] := Component
|
|
else
|
|
FAggregatedReportLinks.Delete(I);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.ReadAggregatedReportLinks(Stream: TStream);
|
|
begin
|
|
FAggregatedReportLinks.LoadFromStream(Stream);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.WriteAggregatedReportLinks(Stream: TStream);
|
|
begin
|
|
FAggregatedReportLinks.SaveToStream(Stream);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.LoadExcludedComponents;
|
|
var
|
|
I: Integer;
|
|
Component: TComponent;
|
|
begin
|
|
if Owner <> nil then
|
|
for I := ExcludedComponentCount - 1 downto 0 do
|
|
begin
|
|
Component := Owner.FindComponent(FExcludedComponents[I]);
|
|
if Component <> nil then
|
|
FExcludedComponents.Objects[I] := Component
|
|
else
|
|
FExcludedComponents.Delete(I);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.ReadExcludedComponents(Stream: TStream);
|
|
begin
|
|
FExcludedComponents.LoadFromStream(Stream);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.WriteExcludedComponents(Stream: TStream);
|
|
begin
|
|
FExcludedComponents.SaveToStream(Stream);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.LoadHiddenComponents;
|
|
var
|
|
I: Integer;
|
|
Component: TComponent;
|
|
begin
|
|
if Owner <> nil then
|
|
for I := HiddenComponentCount - 1 downto 0 do
|
|
begin
|
|
Component := Owner.FindComponent(FHiddenComponents[I]);
|
|
if Component <> nil then
|
|
FHiddenComponents.Objects[I] := Component
|
|
else
|
|
FHiddenComponents.Delete(I);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.ReadHiddenComponents(Stream: TStream);
|
|
begin
|
|
FHiddenComponents.LoadFromStream(Stream);
|
|
end;
|
|
|
|
procedure TdxCustomContainerReportLink.WriteHiddenComponents(Stream: TStream);
|
|
begin
|
|
FHiddenComponents.SaveToStream(Stream);
|
|
end;
|
|
|
|
{ TdxPSContainerDesignWindow }
|
|
|
|
constructor TdxfmCustomContainerDesignWindow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
{$IFDEF DELPHI5}
|
|
tvControls.OnAdvancedCustomDrawItem := TreeView_AdvancedCustomDrawItem;
|
|
tvHiddenControls.OnAdvancedCustomDrawItem := TreeView_AdvancedCustomDrawItem;
|
|
{$ENDIF}
|
|
PageControl1.ActivePage := tshOptions;
|
|
FLastActiveTab := PageControl1.ActivePage;
|
|
{$IFDEF WMCONTEXTMENU}
|
|
SubstituteTreeViewsWndProc;
|
|
{$ENDIF}
|
|
end;
|
|
|
|
destructor TdxfmCustomContainerDesignWindow.Destroy;
|
|
begin
|
|
{$IFDEF WMCONTEXTMENU}
|
|
RestoreTreeViewsWndProc;
|
|
{$ENDIF}
|
|
TreeView_FreeNodeObjects(tvControls);
|
|
TreeView_FreeNodeObjects(tvHiddenControls);
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.BeforeConstruction;
|
|
begin
|
|
inherited;
|
|
Options := Options + [foSizeableDialog];
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.DoInitialize;
|
|
begin
|
|
inherited;
|
|
|
|
dxPSUtl.dxCreateCheckMarkImages(ilControls);
|
|
RefreshHiddenControlsTree;
|
|
RefreshControlsTree;
|
|
RefreshReportLinksList;
|
|
|
|
with ReportLink.OptionsPagination do
|
|
begin
|
|
chbxPaginateByControlDetails.Checked := ControlDetails;
|
|
chbxPaginateByControls.Checked := Controls;
|
|
end;
|
|
chbxPaginateByGroups.Visible := False;
|
|
chbxPaginateByItems.Visible := False;
|
|
|
|
{.2}
|
|
{with ReportLink.OptionsItemPlace do
|
|
begin
|
|
chbxExpandHeight.Checked := ExpandHeight;
|
|
chbxExpandWidth.Checked := ExpandWidth;
|
|
chbxShrinkHeight.Checked := ShrinkHeight;
|
|
chbxShrinkWidth.Checked := ShrinkWidth;
|
|
end;}
|
|
|
|
with ReportLink.OptionsTransparent do
|
|
begin
|
|
chbxTransparentContainers.Checked := Containers;
|
|
chbxTransparentControls.Checked := Controls;
|
|
chbxTransparentRoot.Checked := Root;
|
|
chbxTransparentGraphics.Checked := Graphics;
|
|
end;
|
|
chbxTransparentGroups.Visible := False;
|
|
chbxTransparentItems.Visible := False;
|
|
|
|
pnlAvailableLinksSite.Visible := ReportLink.IsDesigning;
|
|
pnlMoveButtonsSite.Visible := ReportLink.IsDesigning;
|
|
lblAggregatedLinks.Visible := ReportLink.IsDesigning;
|
|
if not ReportLink.IsDesigning then
|
|
begin
|
|
lbxAggregatedLinks.Align := alClient;
|
|
lbxAggregatedLinks.DragMode := dmManual;
|
|
lbxAggregatedLinks.MultiSelect := False;
|
|
btnLinksDesign.Top := btnControlsCheckAll.Top;
|
|
btnLinksRemoveInconsistents.Visible := False;
|
|
end;
|
|
|
|
lblSize.Visible := False;
|
|
bvlSize.Visible := False;
|
|
imgSize.Visible := False;
|
|
chbxAutoWidth.Visible := False;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.LoadStrings;
|
|
begin
|
|
inherited;
|
|
tshOptions.Caption := cxGetResourceString(@sdxOptions);
|
|
lblTransparents.Caption := cxGetResourceString(@sdxTransparents);
|
|
chbxTransparentContainers.Caption := cxGetResourceString(@sdxContainers);
|
|
chbxTransparentControls.Caption := cxGetResourceString(@sdxControls);
|
|
chbxTransparentRoot.Caption := cxGetResourceString(@sdxRoot);
|
|
chbxTransparentGraphics.Caption := cxGetResourceString(@sdxGraphics);
|
|
chbxTransparentGroups.Caption := cxGetResourceString(@sdxGroups);
|
|
chbxTransparentItems.Caption := cxGetResourceString(@sdxItems);
|
|
|
|
(*lblControlsPlace.Caption := cxGetResourceString(@sdxControlsPlace);
|
|
chbxExpandHeight.Caption := cxGetResourceString(@sdxExpandHeight);
|
|
chbxExpandWidth.Caption := cxGetResourceString(@sdxExpandWidth);
|
|
chbxShrinkHeight.Caption := cxGetResourceString(@sdxShrinkHeight);
|
|
chbxShrinkWidth.Caption := cxGetResourceString(@sdxShrinkWidth);*)
|
|
|
|
lblPagination.Caption := cxGetResourceString(@sdxPagination);
|
|
chbxPaginateByControlDetails.Caption := cxGetResourceString(@sdxPaginateByControlDetails);
|
|
chbxPaginateByControls.Caption := cxGetResourceString(@sdxPaginateByControls);
|
|
chbxPaginateByGroups.Caption := cxGetResourceString(@sdxPaginateByGroups);
|
|
chbxPaginateByItems.Caption := cxGetResourceString(@sdxPaginateByItems);
|
|
|
|
lblSize.Caption := cxGetResourceString(@sdxSize);
|
|
chbxAutoWidth.Caption := cxGetResourceString(@sdxAutoWidth);
|
|
|
|
tshReportLinks.Caption := cxGetResourceString(@sdxReportLinksTab);
|
|
lblAvailableLinks.Caption := cxGetResourceString(@sdxAvailableLinks);
|
|
lblAggregatedLinks.Caption := cxGetResourceString(@sdxAggregatedLinks);
|
|
btnLinksDesign.Caption := cxGetResourceString(@sdxBtnDesign);
|
|
btnLinksRemoveInconsistents.Caption := cxGetResourceString(@sdxBtnRemoveInconsistents);
|
|
|
|
tshControls.Caption := cxGetResourceString(@sdxControlsTab);
|
|
btnControlsCheckAll.Caption := cxGetResourceString(@sdxCheckAll);
|
|
btnControlsExpandAll.Caption := cxGetResourceString(@sdxExpandAll);
|
|
|
|
tshHiddenControls.Caption := cxGetResourceString(@sdxHiddenControlsTab);
|
|
btnHiddenControlsCheckAll.Caption := cxGetResourceString(@sdxCheckAll);
|
|
btnHiddenControlsExpandAll.Caption := cxGetResourceString(@sdxExpandAll);
|
|
|
|
miControlsCheckAll.Caption := cxGetResourceString(@sdxCheckAll);
|
|
miControlsCheckAllChildren.Caption := cxGetResourceString(@sdxCheckAllChildren);
|
|
miControlsUncheckAllChildren.Caption := cxGetResourceString(@sdxUncheckAllChildren);
|
|
miControlsExpandAll.Caption := cxGetResourceString(@sdxExpandAll);
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.UpdateControlsState;
|
|
var
|
|
Root: TTreeNode;
|
|
begin
|
|
inherited;
|
|
sbtnAdd.Enabled := CanAggregate;
|
|
sbtnRemove.Enabled := CanDisaggregate;
|
|
btnLinksDesign.Enabled := CanDesign;
|
|
btnLinksRemoveInconsistents.Enabled := CanRemoveInconsistents;
|
|
|
|
Root := TreeView_GetRoot(tvControls);
|
|
tvControls.Enabled := Root <> nil;
|
|
btnControlsCheckAll.Enabled := (Root <> nil) and TreeView_HasUncheckedChildren(Root);
|
|
btnControlsExpandAll.Enabled := (Root <> nil) and (Root.Count <> 0);
|
|
|
|
Root := TreeView_GetRoot(tvHiddenControls);
|
|
tvHiddenControls.Enabled := Root <> nil;
|
|
btnHiddenControlsCheckAll.Enabled := (Root <> nil) and TreeView_HasUncheckedChildren(Root);
|
|
btnHiddenControlsExpandAll.Enabled := (Root <> nil) and (Root.Count <> 0);
|
|
|
|
tshHiddenControls.HandleNeeded;
|
|
if tshHiddenControls.HandleAllocated then
|
|
tshHiddenControls.TabVisible := IsDesigning;
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.GetActiveTreeView: TTreeView;
|
|
begin
|
|
if PageControl1.ActivePage = tshControls then
|
|
Result := tvControls
|
|
else
|
|
Result := tvHiddenControls;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.InitializeControlsTree;
|
|
var
|
|
Root: TTreeNode;
|
|
begin
|
|
ReportLink.LoadControlsTree(tvControls);
|
|
|
|
Root := TreeView_GetRoot(tvControls);
|
|
if Root <> nil then
|
|
begin
|
|
TreeView_NormalizeNode(Root);
|
|
Root.Expand(False);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.InitializeHiddenControlsTree;
|
|
var
|
|
Root: TTreeNode;
|
|
begin
|
|
ReportLink.LoadHiddenControlsTree(tvHiddenControls);
|
|
|
|
Root := TreeView_GetRoot(tvHiddenControls);
|
|
if Root <> nil then
|
|
begin
|
|
TreeView_NormalizeNode(Root);
|
|
Root.Expand(False);
|
|
end;
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.IsBoldNode(ANode: TTreeNode): Boolean;
|
|
begin
|
|
Result := not TreeView_IsNodeEditable(ANode);
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.RefreshControlsTree;
|
|
begin
|
|
if not (dwsInitialize in State) then tvControls.Items.BeginUpdate;
|
|
try
|
|
InitializeControlsTree;
|
|
finally
|
|
if not (dwsInitialize in State) then tvControls.Items.EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.RefreshHiddenControlsTree;
|
|
begin
|
|
if not (dwsInitialize in State) then tvHiddenControls.Items.BeginUpdate;
|
|
try
|
|
InitializeHiddenControlsTree;
|
|
finally
|
|
if not (dwsInitialize in State) then tvHiddenControls.Items.EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.RefreshReportLinksList;
|
|
begin
|
|
if ReportLink.IsDesigning then RefreshAvailableLinks;
|
|
RefreshAggregatedLinks;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.SetOptionsPaginationByIndex(AnIndex: Integer;
|
|
AValue: Boolean);
|
|
begin
|
|
if LockControlsUpdate then Exit;
|
|
|
|
with ReportLink.OptionsPagination do
|
|
case AnIndex of
|
|
0: ControlDetails := AValue;
|
|
1: Controls := AValue;
|
|
end;
|
|
Modified := True;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.SetOptionsSizeByIndex(AnIndex: Integer;
|
|
AValue: Boolean);
|
|
begin
|
|
end;
|
|
|
|
{.2}
|
|
{procedure TdxfmCustomContainerDesignWindow.SetOptionsPlaceByIndex(AnIndex: Integer;
|
|
AValue: Boolean);
|
|
begin
|
|
if LockControlsUpdate then Exit;
|
|
|
|
with ContainerReportLink.OptionsItemPlace do
|
|
case AnIndex of
|
|
0: ExpandHeight := AValue;
|
|
1: ExpandWidth := AValue;
|
|
2: ShrinkHeight := AValue;
|
|
3: ShrinkWidth := AValue;
|
|
end;
|
|
Modified := True;
|
|
end;}
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.SetOptionsTransparentByIndex(AnIndex: Integer;
|
|
AValue: Boolean);
|
|
begin
|
|
if LockControlsUpdate then Exit;
|
|
with ReportLink.OptionsTransparent do
|
|
case AnIndex of
|
|
0: Root := AValue;
|
|
1: Controls := AValue;
|
|
2: Containers := AValue;
|
|
3: Graphics := AValue;
|
|
end;
|
|
Modified := True;
|
|
end;
|
|
|
|
{$IFDEF DELPHI5}
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeView_AdvancedCustomDrawItem(
|
|
Sender: TCustomTreeView; Node: TTreeNode; State: TCustomDrawState;
|
|
Stage: TCustomDrawStage; var PaintImages, DefaultDraw: Boolean);
|
|
|
|
procedure DrawNodeExtraText;
|
|
const
|
|
HighlightColor = clBlue;
|
|
var
|
|
S: string;
|
|
R: TRect;
|
|
TextColor, BkColor: COLORREF;
|
|
X, Y: Integer;
|
|
begin
|
|
with Sender.Canvas do
|
|
begin
|
|
S := '[' + TreeView_GetNodeObject(Node).Component.ClassName + ']';
|
|
R := Node.DisplayRect(True);
|
|
with R do
|
|
begin
|
|
Left := Right;
|
|
Inc(Right, 2 + TextWidth(S) + 2);
|
|
X := Left + 1;
|
|
Y := Top + (Bottom - Top - TextHeight(S)) div 2;
|
|
end;
|
|
|
|
TextColor := SetTextColor(Handle, ColorToRGB(HighlightColor));
|
|
BkColor := SetBkColor(Handle, ColorToRGB(clWindow));
|
|
ExtTextOut(Handle, X, Y, ETO_OPAQUE, @R, PChar(S), Length(S), nil);
|
|
SetBkColor(Handle, BkColor);
|
|
SetTextColor(Handle, TextColor);
|
|
end;
|
|
end;
|
|
|
|
begin
|
|
if TBasedxReportLinkAccess(ReportLink).IsDesigning and (Stage = cdPostPaint) and
|
|
(TreeView_GetNodeObject(Node) <> nil) then
|
|
begin
|
|
DrawNodeExtraText;
|
|
DefaultDraw := False;
|
|
end;
|
|
end;
|
|
|
|
{$ENDIF}
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeView_BeginUpdate;
|
|
begin
|
|
dxPSCore.dxPSStartWait;
|
|
ActiveTreeView.Items.BeginUpdate;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeView_CheckAllChildren(ANode: TTreeNode;
|
|
AChecked: Boolean);
|
|
|
|
procedure DoCheckAllChildren(ANode: TTreeNode);
|
|
const
|
|
StateMap: array[Boolean, Boolean] of TCheckBoxState = ((cbGrayed, cbChecked), (cbUnchecked, cbChecked));
|
|
var
|
|
I: Integer;
|
|
Node: TTreeNode;
|
|
begin
|
|
for I := 0 to ANode.Count - 1 do
|
|
begin
|
|
Node := ANode[I];
|
|
TreeView_SetNodeState(Node, StateMap[TreeView_IsNodeEditable(Node), AChecked]);
|
|
DoCheckAllChildren(Node);
|
|
end;
|
|
end;
|
|
|
|
begin
|
|
DoCheckAllChildren(ANode);
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeView_EndUpdate;
|
|
begin
|
|
ActiveTreeView.Items.EndUpdate;
|
|
dxPSCore.dxPSStopWait;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeView_FreeNodeObjects(ATreeView: TTreeView);
|
|
|
|
procedure FreeNodeObject(ANode: TTreeNode);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
TObject(ANode.Data).Free;
|
|
for I := 0 to ANode.Count - 1 do
|
|
FreeNodeObject(ANode[I]);
|
|
end;
|
|
|
|
var
|
|
Root: TTreeNode;
|
|
begin
|
|
Root := TreeView_GetRoot(ATreeView);
|
|
if Root <> nil then
|
|
FreeNodeObject(Root);
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.TreeView_GetNodeObject(ANode: TTreeNode): TdxNodeObject;
|
|
begin
|
|
Result := TdxNodeObject(ANode.Data);
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.TreeView_getRoot(ATreeView: TTreeView): TTreeNode;
|
|
begin
|
|
Result := ATreeView.Items.GetFirstNode;
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.TreeView_HasCheckedChildren(ANode: TTreeNode): Boolean;
|
|
var
|
|
I: Integer;
|
|
Node: TTreeNode;
|
|
begin
|
|
Result := True;
|
|
for I := 0 to ANode.Count - 1 do
|
|
begin
|
|
Node := ANode[I];
|
|
if TreeView_GetNodeObject(Node).State <> cbUnchecked then
|
|
Exit;
|
|
if (Node.Count <> 0) and TreeView_HasCheckedChildren(Node) then
|
|
Exit;
|
|
end;
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.TreeView_HasRoot(ATreeView: TTreeView): Boolean;
|
|
begin
|
|
Result := TreeView_GetRoot(ATreeView) <> nil;
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.TreeView_HasUncheckedChildren(ANode: TTreeNode): Boolean;
|
|
var
|
|
I: Integer;
|
|
Node: TTreeNode;
|
|
begin
|
|
Result := True;
|
|
for I := 0 to ANode.Count - 1 do
|
|
begin
|
|
Node := ANode[I];
|
|
if TreeView_GetNodeObject(Node).State <> cbChecked then
|
|
Exit;
|
|
if (Node.Count <> 0) and TreeView_HasUncheckedChildren(Node) then
|
|
Exit;
|
|
end;
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.TreeView_IsNodeEditable(ANode: TTreeNode): Boolean;
|
|
begin
|
|
Result := (ANode <>nil) and ReportLink.IsComponentEditable(TreeView_GetNodeObject(ANode).Component);
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeView_NormalizeNode(ANode: TTreeNode);
|
|
|
|
procedure DoUpdateNodeState(ANode: TTreeNode);
|
|
var
|
|
NodeObject: TdxNodeObject;
|
|
begin
|
|
NodeObject := TreeView_GetNodeObject(ANode);
|
|
if (NodeObject.State = cbChecked) and TreeView_HasUncheckedChildren(ANode) then
|
|
NodeObject.State := cbGrayed;
|
|
TreeView_UpdateNodeImage(ANode);
|
|
end;
|
|
|
|
var
|
|
I: Integer;
|
|
Node: TTreeNode;
|
|
begin
|
|
for I := 0 to ANode.Count - 1 do
|
|
begin
|
|
Node := ANode[I];
|
|
if Node.Count <> 0 then
|
|
TreeView_NormalizeNode(Node);
|
|
end;
|
|
DoUpdateNodeState(ANode);
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeView_SetNodeState(ANode: TTreeNode;
|
|
AState: TCheckBoxState);
|
|
var
|
|
NodeObject: TdxNodeObject;
|
|
Component: TComponent;
|
|
begin
|
|
NodeObject := TreeView_GetNodeObject(ANode);
|
|
NodeObject.State := AState;
|
|
|
|
Component := NodeObject.Component;
|
|
case NodeObject.State of
|
|
cbUnchecked:
|
|
if ActiveTreeView = tvHiddenControls then
|
|
ReportLink.HideComponent(Component)
|
|
else
|
|
ReportLink.ExcludeComponent(Component);
|
|
cbChecked:
|
|
if ActiveTreeView = tvHiddenControls then
|
|
ReportLink.UnhideComponent(Component)
|
|
else
|
|
ReportLink.UnexcludeComponent(Component);
|
|
end;
|
|
TreeView_UpdateNodeImage(ANode);
|
|
|
|
Modified := True;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeView_ToggleNodeState(ANode: TTreeNode);
|
|
const
|
|
StateToggles: array[TCheckBoxState] of TCheckBoxState = (cbChecked, cbUnchecked, cbChecked);
|
|
var
|
|
NodeObject: TdxNodeObject;
|
|
begin
|
|
if (ANode <> nil) and TreeView_IsNodeEditable(ANode) then
|
|
begin
|
|
NodeObject := TreeView_GetNodeObject(ANode);
|
|
TreeView_SetNodeState(ANode, StateToggles[NodeObject.State]);
|
|
TreeView_CheckAllChildren(ANode, NodeObject.State = cbChecked);
|
|
if ANode.Parent <> nil then
|
|
TreeView_UpdateNodesState(ANode.Parent);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeView_UpdateNodeImage(ANode: TTreeNode);
|
|
begin
|
|
ANode.StateIndex := dxPSUtl.dxCheckStateImageIndexMap(TreeView_GetNodeObject(ANode).State);
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeView_UpdateNodesState(ANode: TTreeNode);
|
|
|
|
procedure DoUpdateNodeState(ANode: TTreeNode);
|
|
begin
|
|
with TreeView_GetNodeObject(ANode) do
|
|
case State of
|
|
cbUnchecked,
|
|
cbChecked:
|
|
if TreeView_HasUncheckedChildren(ANode) then
|
|
State := cbGrayed;
|
|
cbGrayed:
|
|
if not TreeView_HasUncheckedChildren(ANode) then
|
|
State := cbChecked;
|
|
end;
|
|
TreeView_UpdateNodeImage(ANode);
|
|
end;
|
|
|
|
begin
|
|
DoUpdateNodeState(ANode);
|
|
if ANode.Parent <> nil then
|
|
TreeView_UpdateNodesState(ANode.Parent);
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.GetAggregatedLink(Index: Integer): TBasedxReportLink;
|
|
begin
|
|
Result := TBasedxReportLink(lbxAggregatedLinks.Items.Objects[Index]);
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.GetAggregatedLinkCount: Integer;
|
|
begin
|
|
Result := lbxAggregatedLinks.Items.Count;
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.GetAggregatedLinkSelected(Index: Integer): Boolean;
|
|
begin
|
|
Result := lbxAggregatedLinks.Selected[Index];
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.GetAvailableLink(Index: Integer): TBasedxReportLink;
|
|
begin
|
|
Result := TBasedxReportLink(lbxAvailableLinks.Items.Objects[Index]);
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.GetAvailableLinkCount: Integer;
|
|
begin
|
|
Result := lbxAvailableLinks.Items.Count;
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.GetAvailableLinkSelected(Index: Integer): Boolean;
|
|
begin
|
|
Result := lbxAvailableLinks.Selected[Index];
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.GetControlsTab: TTabSheet;
|
|
begin
|
|
Result := tshControls;
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.GetHiddenControlsTab: TTabSheet;
|
|
begin
|
|
Result := tshHiddenControls;
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.GetReportLink: TdxCustomContainerReportLink;
|
|
begin
|
|
Result := inherited ReportLink as TdxCustomContainerReportLink;
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.GetReportLinksTab: TTabSheet;
|
|
begin
|
|
Result := tshReportLinks;
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.GetSelectedReportLink: TBasedxReportLink;
|
|
begin
|
|
with lbxAggregatedLinks do
|
|
if (not ReportLink.IsDesigning or (SelCount = 1)) and (ItemIndex <> -1) then
|
|
Result := TBasedxReportLink(Items.Objects[ItemIndex])
|
|
else
|
|
Result := nil
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.DoCheckAllChildren(ANode: TTreeNode;
|
|
AChecked: Boolean);
|
|
begin
|
|
if ANode <> nil then
|
|
begin
|
|
TreeView_BeginUpdate;
|
|
try
|
|
TreeView_CheckAllChildren(ANode, AChecked);
|
|
TreeView_UpdateNodesState(ANode);
|
|
finally
|
|
TreeView_EndUpdate;
|
|
end;
|
|
FAreHiddenControlsChanged := True;
|
|
Modified := True;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.DoToggleNodeState(ANode: TTreeNode);
|
|
begin
|
|
if TreeView_IsNodeEditable(ANode) then
|
|
begin
|
|
TreeView_BeginUpdate;
|
|
try
|
|
TreeView_ToggleNodeState(ANode);
|
|
finally
|
|
TreeView_EndUpdate;
|
|
end;
|
|
FAreHiddenControlsChanged := True;
|
|
//UpdateControlsState;
|
|
Modified := True;
|
|
end;
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.CanAggregate: Boolean;
|
|
begin
|
|
Result := lbxAvailableLinks.SelCount <> 0;
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.CanDesign: Boolean;
|
|
begin
|
|
Result := (SelectedReportLink <> nil) and SelectedReportLink.CheckToDesign;
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.CanDisaggregate: Boolean;
|
|
begin
|
|
Result := ReportLink.IsDesigning and (lbxAggregatedLinks.SelCount <> 0);
|
|
end;
|
|
|
|
function TdxfmCustomContainerDesignWindow.CanRemoveInconsistents: Boolean;
|
|
begin
|
|
Result := ReportLink.HasInconsistentlyAggregatedLinks;
|
|
end;
|
|
|
|
{function TdxfmCustomContainerDesignWindow.CanSelectAll(AListBox: TListBox): Boolean;
|
|
begin
|
|
with AListBox do
|
|
Result := (Items.Count <> 0) and (Items.Count <> SelCount);
|
|
end;}
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.DoAggregateSelectedLinks;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to AvailableLinkCount - 1 do
|
|
if AvailableLinkSelected[I] then
|
|
ReportLink.AggregateLink(AvailableLinks[I]);
|
|
|
|
RefreshReportLinksList;
|
|
UpdateControlsState;
|
|
Modified := True;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.DoDisaggregateSelectedLinks;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to AggregatedLinkCount - 1 do
|
|
if AggregatedLinkSelected[I] then
|
|
ReportLink.DisaggregateLink(AggregatedLinks[I]);
|
|
|
|
RefreshReportLinksList;
|
|
UpdateControlsState;
|
|
Modified := True;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.RefreshAvailableLinks;
|
|
var
|
|
I: Integer;
|
|
Link: TBasedxReportLink;
|
|
begin
|
|
with lbxAvailableLinks do
|
|
begin
|
|
Items.BeginUpdate;
|
|
try
|
|
Items.Clear;
|
|
for I := 0 to ReportLink.ComponentPrinter.LinkCount - 1 do
|
|
begin
|
|
Link := ReportLink.ComponentPrinter[I];
|
|
if ReportLink.IsLinkAggregable(Link) and not ReportLink.IsLinkAggregated(Link) then
|
|
Items.AddObject(Link.Name, Link);
|
|
end;
|
|
ItemIndex := Items.Count - 1;
|
|
if ItemIndex <> -1 then
|
|
Selected[ItemIndex] := True;
|
|
finally
|
|
Items.EndUpdate;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.RefreshAggregatedLinks;
|
|
var
|
|
I: Integer;
|
|
Link: TBasedxReportLink;
|
|
begin
|
|
with lbxAggregatedLinks do
|
|
begin
|
|
Items.BeginUpdate;
|
|
try
|
|
Items.Clear;
|
|
for I := 0 to ReportLink.AggregatedReportLinkCount - 1 do
|
|
begin
|
|
Link := ReportLink.AggregatedReportLinks[I];
|
|
Items.AddObject(Link.Name, Link);
|
|
end;
|
|
ItemIndex := Items.Count - 1;
|
|
if ItemIndex <> -1 then
|
|
Selected[ItemIndex] := True;
|
|
finally
|
|
Items.EndUpdate;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.DoSelectAll(AListBox: TListBox);
|
|
{$IFNDEF DELPHI6}
|
|
var
|
|
I: Integer;
|
|
{$ENDIF}
|
|
begin
|
|
{$IFDEF DELPHI6}
|
|
AListBox.SelectAll;
|
|
{$ELSE}
|
|
for I := 0 to AListBox.Items.Count - 1 do
|
|
AListBox.Selected[I] := True;
|
|
{$ENDIF}
|
|
end;
|
|
|
|
{$IFDEF WMCONTEXTMENU}
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.ControlsTreeViewWndProc(var Message: TMessage);
|
|
begin
|
|
FControlsTreeViewWndProc(Message);
|
|
if Message.Msg = WM_CONTEXTMENU then
|
|
ProcessContextMenu(TWMContextMenu(Message), tvControls);
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.HiddenControlsTreeViewWndProc(var Message: TMessage);
|
|
begin
|
|
FHiddenControlsTreeViewWndProc(Message);
|
|
if Message.Msg = WM_CONTEXTMENU then
|
|
ProcessContextMenu(TWMContextMenu(Message), tvHiddenControls);
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.ProcessContextMenu(AMessage: TWMContextMenu;
|
|
ATreeView: TTreeView);
|
|
var
|
|
KeyState: TKeyboardState;
|
|
begin
|
|
GetKeyboardState(KeyState);
|
|
with AMessage do
|
|
TreeViewMouseUp(ATreeView, mbRight, KeyboardStateToShiftState(KeyState), Pos.X, Pos.Y)
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.RestoreTreeViewsWndProc;
|
|
begin
|
|
tvControls.WindowProc := FControlsTreeViewWndProc;
|
|
tvHiddenControls.WindowProc := FHiddenControlsTreeViewWndProc;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.SubstituteTreeViewsWndProc;
|
|
begin
|
|
FControlsTreeViewWndProc := tvControls.WindowProc;
|
|
tvControls.WindowProc := ControlsTreeViewWndProc;
|
|
|
|
FHiddenControlsTreeViewWndProc := tvHiddenControls.WindowProc;
|
|
tvHiddenControls.WindowProc := HiddenControlsTreeViewWndProc;
|
|
end;
|
|
|
|
{$ENDIF}
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeViewClick(Sender: TObject);
|
|
var
|
|
TreeView: TTreeView;
|
|
Pt: TPoint;
|
|
HitTest: THitTests;
|
|
begin
|
|
TreeView := TTreeView(Sender);
|
|
Pt := TreeView.ScreenToClient(Mouse.CursorPos);
|
|
HitTest := TreeView.GetHitTestInfoAt(Pt.X, Pt.Y);
|
|
if htOnStateIcon in HitTest then
|
|
DoToggleNodeState(TreeView.GetNodeAt(Pt.X, Pt.Y));
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeViewKeyDown(Sender: TObject;
|
|
var Key: Word; Shift: TShiftState);
|
|
begin
|
|
if Key = VK_SPACE then
|
|
begin
|
|
DoToggleNodeState(TTreeView(Sender).Selected);
|
|
Key := 0;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeViewKeyPress(Sender: TObject;
|
|
var Key: Char);
|
|
begin
|
|
if Key = #32 then Key := #0;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeViewMouseUp(Sender: TObject;
|
|
Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
|
|
var
|
|
Pt: TPoint;
|
|
Node: TTreeNode;
|
|
begin
|
|
if Button = mbRight then
|
|
begin
|
|
Pt := MakePoint(X, Y);
|
|
{$IFDEF DELPHI5}
|
|
{$IFNDEF DELPHI7}
|
|
Pt := TTreeView(Sender).ScreenToClient(Pt);
|
|
{$ENDIF}
|
|
{$ENDIF}
|
|
Node := TTreeView(Sender).GetNodeAt(Pt.X, Pt.Y);
|
|
if Node <> nil then
|
|
begin
|
|
Node.Focused := True;
|
|
Node.Selected := True;
|
|
end;
|
|
dxPSPopupMan.dxPSPopupMenuController.ShowPopupAtMousePos(nil, pmControls);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeViewCheckAllClick(Sender: TObject);
|
|
begin
|
|
DoCheckAllChildren(TreeView_GetRoot(ActiveTreeView), True);
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeViewCheckAllChildrenClick(Sender: TObject);
|
|
begin
|
|
DoCheckAllChildren(ActiveTreeView.Selected, True);
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeViewUncheckAllChildrenClick(Sender: TObject);
|
|
begin
|
|
DoCheckAllChildren(ActiveTreeView.Selected, False);
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeViewExpandAllClick(Sender: TObject);
|
|
begin
|
|
ActiveTreeView.FullExpand;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.HideStandardControlsClick(Sender: TObject);
|
|
begin
|
|
ReportLink.HideStandardControls;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.UnhideStandardControlsClick(Sender: TObject);
|
|
begin
|
|
ReportLink.UnhideStandardControls;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeViewCustomDrawItem(
|
|
Sender: TCustomTreeView; Node: TTreeNode; State: TCustomDrawState;
|
|
var DefaultDraw: Boolean);
|
|
const
|
|
FontColors: array[Boolean] of TColor = (clGrayText, clWindowText);
|
|
SelectedBkColors: array[Boolean] of TColor = (clBtnFace, clHighlight);
|
|
SelectedFontColors: array[Boolean] of TColor = (clGrayText, clHighlightText);
|
|
begin
|
|
if (Node = nil) or (TreeView_GetNodeObject(Node) = nil) then Exit;
|
|
if IsBoldNode(Node) then
|
|
begin
|
|
if cdsSelected in State then
|
|
begin
|
|
Sender.Canvas.Brush.Color := SelectedBkColors[Sender.Focused];
|
|
if Sender.Focused then
|
|
Sender.Canvas.Font.Color := SelectedFontColors[TreeView_IsNodeEditable(Node)]
|
|
else
|
|
Sender.Canvas.Font.Color := FontColors[TreeView_IsNodeEditable(Node)];
|
|
end
|
|
else
|
|
begin
|
|
Sender.Canvas.Brush.Color := clWindow;
|
|
Sender.Canvas.Font.Color := FontColors[TreeView_IsNodeEditable(Node)];
|
|
end;
|
|
Sender.Canvas.Font.Style := Sender.Canvas.Font.Style + [fsBold];
|
|
end;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.DesignClick(Sender: TObject);
|
|
begin
|
|
Modified := CanDesign and SelectedReportLink.DesignReport;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.pmControlsPopup(Sender: TObject);
|
|
var
|
|
Node: TTreeNode;
|
|
begin
|
|
Node := TreeView_GetRoot(ActiveTreeView);
|
|
miControlsCheckAll.Enabled := (Node <> nil) and TreeView_HasUncheckedChildren(Node);
|
|
miControlsExpandAll.Enabled := (Node <> nil) and (Node.Count <> 0);
|
|
// miControlsCheckStandardControls.Visible := ActiveTreeView = tvHiddenControls;
|
|
// miControlsCheckStandardControls.Enabled := Node <> nil;
|
|
// miControlsUncheckStandardControls.Visible := ActiveTreeView = tvHiddenControls;
|
|
// miControlsUncheckStandardControls.Enabled := Node <> nil;
|
|
|
|
Node := ActiveTreeView.Selected;
|
|
miControlsCheckAllChildren.Enabled := (Node <> nil) and (Node.Count <> 0) and
|
|
TreeView_HasUncheckedChildren(Node);
|
|
miControlsUncheckAllChildren.Enabled := (Node <> nil) and (Node.Count <> 0) and
|
|
TreeView_HasCheckedChildren(Node);
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.lbxAggregatedLinksClick(Sender: TObject);
|
|
begin
|
|
UpdateControlsState;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TreeViewChange(Sender: TObject;
|
|
Node: TTreeNode);
|
|
begin
|
|
//UpdateControlsState;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.PageControl1Change(Sender: TObject);
|
|
begin
|
|
UpdateControlsState;
|
|
FAreHiddenControlsChanged := False;
|
|
FLastActiveTab := PageControl1.ActivePage;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.PageControl1Changing(Sender: TObject;
|
|
var AllowChange: Boolean);
|
|
begin
|
|
if FAreHiddenControlsChanged and (FLastActiveTab = HiddenControlsTab) then
|
|
RefreshControlsTree;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.TransparentClick(Sender: TObject);
|
|
begin
|
|
with TCheckBox(Sender) do
|
|
SetOptionsTransparentByIndex(TTagToInt(Tag), Checked);
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.PaginationClick(Sender: TObject);
|
|
begin
|
|
with TCheckBox(Sender) do
|
|
SetOptionsPaginationByIndex(TTagToInt(Tag), Checked);
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.SizeClick(Sender: TObject);
|
|
begin
|
|
with TCheckBox(Sender) do
|
|
SetOptionsSizeByIndex(TTagToInt(Tag), Checked);
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.sbtnAddClick(Sender: TObject);
|
|
begin
|
|
DoAggregateSelectedLinks;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.sbtnRemoveClick(Sender: TObject);
|
|
begin
|
|
DoDisaggregateSelectedLinks;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.tshReportLinksResize(Sender: TObject);
|
|
const
|
|
TopMargin = 22;
|
|
var
|
|
W, H: Integer;
|
|
begin
|
|
if ReportLink.IsDesigning then
|
|
begin
|
|
W := (pnlLinkListsSite.ClientWidth - pnlMoveButtonsSite.Width) div 2;
|
|
pnlAvailableLinksSite.Width := W;
|
|
pnlAggregatedLinksSite.Width := W;
|
|
|
|
H := TopMargin + (sbtnAdd.Parent.ClientHeight - TopMargin) div 2;
|
|
sbtnAdd.Top := H - sbtnAdd.Height - 3;
|
|
sbtnRemove.Top := H + 3;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.lbxAvailableLinksKeyDown(
|
|
Sender: TObject; var Key: Word; Shift: TShiftState);
|
|
begin
|
|
if (Key = Ord('A')) and (ssCtrl in Shift) then
|
|
DoSelectAll(TListBox(Sender));
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.lbxAggregatedLinksKeyDown(
|
|
Sender: TObject; var Key: Word; Shift: TShiftState);
|
|
begin
|
|
if (Key = Ord('A')) and (ssCtrl in Shift) then
|
|
DoSelectAll(TListBox(Sender));
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.lbxAvailableLinksDragOver(
|
|
Sender, Source: TObject; X, Y: Integer; State: TDragState;
|
|
var Accept: Boolean);
|
|
begin
|
|
Accept := (Source = lbxAggregatedLinks) and (lbxAggregatedLinks.SelCount <> 0);
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.lbxAvailableLinksDragDrop(
|
|
Sender, Source: TObject; X, Y: Integer);
|
|
begin
|
|
DoDisaggregateSelectedLinks;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.lbxAggregatedLinksDragOver(
|
|
Sender, Source: TObject; X, Y: Integer; State: TDragState;
|
|
var Accept: Boolean);
|
|
begin
|
|
Accept := (Source = lbxAvailableLinks) and (lbxAvailableLinks.SelCount <> 0);
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.lbxAggregatedLinksDragDrop(
|
|
Sender, Source: TObject; X, Y: Integer);
|
|
begin
|
|
DoAggregateSelectedLinks;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.lbxAggregatedLinksDblClick(Sender: TObject);
|
|
begin
|
|
if CanDisaggregate then
|
|
DoDisaggregateSelectedLinks
|
|
else
|
|
if CanDesign then btnLinksDesign.Click;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.lbxAvailableLinksDblClick(Sender: TObject);
|
|
begin
|
|
if CanAggregate then DoAggregateSelectedLinks;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.btnLinksRemoveInconsistentsClick(
|
|
Sender: TObject);
|
|
begin
|
|
if CanRemoveInconsistents then
|
|
begin
|
|
ReportLink.DisaggregateInconsistentLinks;
|
|
RefreshReportLinksList;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxfmCustomContainerDesignWindow.lbxAggregatedLinksDrawItem(Control: TWinControl;
|
|
Index: Integer; Rect: TRect; State: TOwnerDrawState);
|
|
var
|
|
R: TRect;
|
|
Link: TBasedxReportLink;
|
|
S: string;
|
|
X, Y: Integer;
|
|
begin
|
|
R := Rect;
|
|
with TCustomListBox(Control) do
|
|
begin
|
|
Link := TBasedxReportLink(Items.Objects[Index]);
|
|
|
|
Canvas.FillRect(R);
|
|
|
|
S := Link.ReportDocument.Caption;
|
|
with R do
|
|
begin
|
|
X := Left + 1;
|
|
Y := Top + (Bottom - Top - Canvas.TextHeight(S)) div 2;
|
|
end;
|
|
if (Control = lbxAggregatedLinks) and not ReportLink.IsLinkAggregatedConsistently(Link) and not (odSelected in State) then
|
|
Canvas.Font.Color := clGrayText;
|
|
Canvas.TextRect(R, X, Y, S);
|
|
|
|
if IsDesigning and (Link.Component <> nil) then
|
|
begin
|
|
Inc(R.Left, 1 + 1 + Canvas.TextWidth(S) + 1);
|
|
X := R.Left + 2;
|
|
S := '[' + Link.Component.Name + ']';
|
|
if ((Control = lbxAvailableLinks) or ReportLink.IsLinkAggregatedConsistently(Link)) and not (odSelected in State) then
|
|
Canvas.Font.Color := clBlue;
|
|
Canvas.TextRect(R, X, Y, S);
|
|
end;
|
|
|
|
//if odFocused in State then Canvas.DrawFocusRect(Rect);
|
|
end;
|
|
end;
|
|
|
|
procedure RegisterAssistants;
|
|
begin
|
|
TdxPSContainerBuilder.Register;
|
|
|
|
TdxPSNativePrintableControlProducer.Register;
|
|
|
|
TdxPSControlAsMetafileProducer.Register;
|
|
TdxPSWinControlAsMetafileProducer.Register;
|
|
|
|
TdxPSCustomContainerItemProducer.Register;
|
|
TdxPSContainerControlProducer.Register;
|
|
TdxPSBevelProducer.Register;
|
|
TdxPSPaintBoxProducer.Register;
|
|
TdxPSShapeProducer.Register;
|
|
TdxPSCustomLabelProducer.Register;
|
|
TdxPSContainerCustomWinControlProducer.Register;
|
|
TdxPSContainerWinControlProducer.Register;
|
|
TdxPSDateTimePickerProducer.Register;
|
|
TdxPSCustomHotKeyProducer.Register;
|
|
TdxPSCustomStaticTextProducer.Register;
|
|
TdxPSCustomEditProducer.Register;
|
|
TdxPSCustomMemoProducer.Register;
|
|
TdxPSCustomComboBoxProducer.Register;
|
|
TdxPSCustomCheckBoxProducer.Register;
|
|
TdxPSRadioButtonProducer.Register;
|
|
|
|
//TdxPSCustomContainerProducer.Register;
|
|
TdxPSCustomPanelProducer.Register;
|
|
TdxPSCustomGroupBoxProducer.Register;
|
|
TdxPSCustomRadioGroupProducer.Register;
|
|
|
|
TdxPSTabControlProducer.Register;
|
|
TdxPSTabSheetProducer.Register;
|
|
TdxPSPageControlProducer.Register;
|
|
TdxPSNotebookPageProducer.Register;
|
|
TdxPSNotebookProducer.Register;
|
|
TdxPSTabbedNotebookPageProducer.Register;
|
|
TdxPSTabbedNotebookProducer.Register;
|
|
TdxPSScrollingWinControlProducer.Register;
|
|
TdxPSCustomFormProducer.Register;
|
|
{$IFDEF DELPHI5}
|
|
TdxPSCustomFrameProducer.Register;
|
|
{$ENDIF}
|
|
{$IFDEF DELPHI6}
|
|
TdxPSCustomComboBoxExProducer.Register;
|
|
{$ENDIF}
|
|
end;
|
|
|
|
procedure RegisterItems;
|
|
begin
|
|
TdxReportWinControlHost.Register;
|
|
TdxReportNativePrintableControlHost.Register;
|
|
end;
|
|
|
|
procedure UnregisterAssistants;
|
|
begin
|
|
TdxPSNativePrintableControlProducerFactory.ReleaseInstance;
|
|
TdxPSContainerItemProducerFactory.ReleaseInstance;
|
|
TdxPSContainerBuilderFactory.ReleaseInstance;
|
|
end;
|
|
|
|
procedure UnregisterItems;
|
|
begin
|
|
TdxReportNativePrintableControlHost.Unregister;
|
|
TdxReportWinControlHost.Unregister;
|
|
end;
|
|
|
|
initialization
|
|
RegisterAssistants;
|
|
RegisterItems;
|
|
|
|
dxPSRegisterContainers(StandardContainers);
|
|
|
|
finalization
|
|
dxPSUnregisterContainers(StandardContainers);
|
|
|
|
UnregisterItems;
|
|
UnregisterAssistants;
|
|
|
|
FreeAndNil(FInternalComponentPrinter);
|
|
|
|
end.
|