{*******************************************************************}
{                                                                   }
{       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 dxPScxTL5Lnk;

interface
    
{$I cxVer.inc}

uses
  Windows, SysUtils, Messages, Classes, Graphics, Controls, StdCtrls, ComCtrls, 
  ExtCtrls, ImgList, Menus, Dialogs, ExtDlgs, Contnrs, Types, cxClasses, cxControls,
  cxGraphics, cxGeometry, cxStyles, cxLookAndFeels, cxLookAndFeelPainters, cxEdit,
  cxTextEdit, cxInplaceContainer, cxTL, cxDBTL, cxTLData, cxCustomData, dxExtCtrls,
  dxBase, dxPSSngltn, dxPrnPg, dxPSCore, dxPScxCommon;

const
  vspsTreeListFirst = 0;
  vspsTreeListBandHeader = vspsTreeListFirst + 0;
  vspsTreeListContent = vspsTreeListFirst + 1;
  vspsTreeListContentEven = vspsTreeListFirst + 2;
  vspsTreeListContentOdd = vspsTreeListFirst + 3;
  vspsTreeListFooter = vspsTreeListFirst + 4;
  vspsTreeListFooterRow = vspsTreeListFirst + 5;
  vspsTreeListHeader = vspsTreeListFirst + 6;
  vspsTreeListIndent = vspsTreeListFirst + 7;
  vspsTreeListPreview = vspsTreeListFirst + 8;
  vspsTreeListSelection = vspsTreeListFirst + 9;
  vspsTreeListBandBackground = vspsTreeListFirst + 10;
  vspsTreeListLast = vspsTreeListBandBackground;

  cxTreeListAttributeIDBase = 0;
  cxTreeListUndefinedID = cxTreeListAttributeIDBase + 0;
  cxTreeListBandID = cxTreeListAttributeIDBase + 1;
  cxTreeListFooterID = cxTreeListAttributeIDBase + 2;
  cxTreeListHeaderID = cxTreeListAttributeIDBase + 3;
  cxTreeListIndentID = cxTreeListAttributeIDBase + 4;
  cxTreeListNodeID = cxTreeListAttributeIDBase + 5;
  
type
  TcxTreeListNodeClass = class of TcxTreeListNode;

  TcxTreeListCustomReportLink = class;
  TdxfmTreeListReportLinkDesignWindow = class;
  
  TcxTreeListAttributeHostInfo = class;
  TcxTreeListAdapterClass = class of TcxTreeListAdapter;
  TcxTreeListAdapter = class;
  TcxTreeListReportLinkFormatterClass = class of TcxTreeListReportLinkFormatter;
  TcxTreeListReportLinkFormatter = class;
  TcxTreeListReportLinkBuilderClass = class of TcxTreeListReportLinkBuilder;
  TcxTreeListReportLinkBuilder = class;
  
  TcxTreeListAttributeClass = class of TcxTreeListAttribute;
  TcxTreeListAttribute = class end;
  TcxTreeListBandAttribute = class(TcxTreeListAttribute);
  TcxTreeListNodeAttribute = class(TcxTreeListAttribute);
  TcxTreeListFooterAttribute = class(TcxTreeListAttribute);
  TcxTreeListHeaderAttribute = class(TcxTreeListAttribute);

  TcxTreeListColumnPlace = class;
  TcxTreeListCustomBandPlace = class;
  TcxTreeListBandPlace = class;
  TcxTreeListItemPlaceController = class;
  
  TcxTreeListAttributeID = type Integer;

  TcxTreeListCellCustomDrawInfo = record
    AttributeID: TcxTreeListAttributeID;
    Band: TcxTreeListBand;
    Column: TcxTreeListColumn;
    Node: TcxTreeListNode;
    Index: Integer;
  end;
  
  { producers }

  TcxTreeListReportLinkRowProducerClass = class of TcxTreeListReportLinkRowProducer;
  
  TcxTreeListReportLinkRowProducer = class
  private
    FBuilder: TcxTreeListReportLinkBuilder;
    FHost: TdxReportCell;
    FRow: TdxReportCell;
    FRowHeight: Integer;
    function GetDC: HDC;
    function GetIndentWidth: Integer;    
    function GetRowWidth: Integer;
  protected
    procedure AfterCalculateRowHeight; virtual;
    procedure CalculateRowAutoHeight; virtual;
    procedure CalculateRowHeight; virtual;
    procedure CreateRow; virtual;
    procedure CreateRowHost(const AHostInfo: TcxTreeListAttributeHostInfo); virtual;
    function DoesItemParticipateInRowAutoHeightCalculation(AnItem: TdxReportVisualItem): Boolean; virtual;
    procedure FixupRowDataHeight; virtual;
    procedure FixupRowHeight; virtual;
    procedure FixupRowItselfHeight; virtual;
    procedure InitializeRow; virtual;
    
    function GetAutoHeight: Boolean; virtual;
    function GetLineCount: Integer; virtual;
    function GetLineHeight: Integer; virtual;

    property DC: HDC read GetDC;
  public
    constructor Create(ABuilder: TcxTreeListReportLinkBuilder); virtual;
    
    function Adapter: TcxTreeListAdapter; overload; virtual;
    function Builder: TcxTreeListReportLinkBuilder; overload; virtual;
    function Formatter: TcxTreeListReportLinkFormatter; overload; virtual;

    function Produce(AHostInfo: TcxTreeListAttributeHostInfo): TdxReportCell; virtual;

    property AutoHeight: Boolean read GetAutoHeight;
    property Host: TdxReportCell read FHost;
    property IndentWidth: Integer read GetIndentWidth;
    property LineCount: Integer read GetLineCount;
    property LineHeight: Integer read GetLineHeight;
    property Row: TdxReportCell read FRow;
    property RowHeight: Integer read FRowHeight write FRowHeight;
    property RowWidth: Integer read GetRowWidth;
  end;

  TcxTreeListReportLinkNodeSeparatorProducerClass = class of TcxTreeListReportLinkNodeSeparatorProducer;

  TcxTreeListReportLinkNodeSeparatorProducer = class(TcxTreeListReportLinkRowProducer)
  private
    FItem: TAbstractdxReportCellData;
  protected
    procedure InitializeItem; virtual;
    procedure InitializeRow; override;

    function GetAutoHeight: Boolean; override;
    function GetItemClass: TdxReportCellDataClass; virtual;
    function GetLineHeight: Integer; override;
  public
    function Produce(AHostInfo: TcxTreeListAttributeHostInfo): TdxReportCell; override;
  end;

  TcxTreeListReportLinkRowSubItemsProducerClass = class of TcxTreeListReportLinkRowSubItemsProducer;

  TcxTreeListReportLinkRowSubItemsProducer = class(TcxTreeListReportLinkRowProducer)
  private
    function GetColumn(Index: Integer): TcxTreeListColumn;
  protected
    procedure CreateDataItems(AParent: TdxReportCell); virtual;
    procedure CreateRow; override;
    procedure InitializeSubItem(ASubItem: TAbstractdxReportCellData; AnIndex: Integer); virtual;

    function GetHasSubItem(Index: Integer): Boolean; virtual;
    function GetSubItemBound(Index: Integer): TRect; virtual;
    function GetSubItemClass(Index: Integer): TdxReportCellDataClass; virtual; abstract;
    function GetSubItemCount: Integer; virtual;
  public
    property Columns[Index: Integer]: TcxTreeListColumn read GetColumn;
    property HasSubItem[Index: Integer]: Boolean read GetHasSubItem;
    property SubItemBounds[Index: Integer]: TRect read GetSubItemBound;
    property SubItemClasses[Index: Integer]: TdxReportCellDataClass read GetSubItemClass;
    property SubItemCount: Integer read GetSubItemCount;
  end;
  
  TcxTreeListReportLinkBandsProducerClass = class of TcxTreeListReportLinkBandsProducer;
  
  TcxTreeListReportLinkBandsProducer = class(TcxTreeListReportLinkRowSubItemsProducer)
  protected
    procedure CalculateRowHeight; override;
    procedure InitializeRow; override;
    procedure InitializeSubItem(ASubItem: TAbstractdxReportCellData; AnIndex: Integer); override;

    function GetAutoHeight: Boolean; override;
    function GetSubItemBound(Index: Integer): TRect; override;
    function GetSubItemClass(Index: Integer): TdxReportCellDataClass; override;
    function GetSubItemCount: Integer; override;
  end;

  TcxTreeListReportLinkFootersProducerClass = class of TcxTreeListReportLinkFootersProducer;

  TcxTreeListReportLinkBandedRowProducer = class(TcxTreeListReportLinkRowProducer)
  private
    FIndents: TList;
    function GetIndent(Index: Integer): TdxReportCellExpandButton;
  protected
    procedure AfterCalculateRowHeight; override;
    procedure CreateBandedDataItems(AParent: TdxReportCell); virtual;
    procedure CreateBandedRows(AParent: TdxReportCell); virtual;
    procedure CreateIndents(AParent: TdxReportCell); virtual;
    procedure CreateIndentsRow(AParent: TdxReportCell); virtual;
    procedure CreateRow; override;

    function GetBandedDataItemBounds(AItem: TAbstractdxReportCellData): TRect; virtual;
    function GetBandedDataItemClass(AColumnPlace: TcxTreeListColumnPlace): TdxReportCellDataClass; virtual;
    function GetBandedRowIndent: Integer; virtual;

    function GetIndentArea: Integer; virtual;
    function GetIndentBound(AIndex: Integer): TRect; virtual;
    function GetIndentCount: Integer; virtual;

    procedure InitializeBandedDataItem(AItem: TAbstractdxReportCellData); virtual;
    procedure InitializeBandedRow(ARow: TdxReportCell); virtual;
    procedure InitializeIndent(AnIndent: TdxReportCellExpandButton; AnIndex: Integer); virtual;

    property IndentArea: Integer read GetIndentArea;
    property IndentBounds[Index: Integer]: TRect read GetIndentBound;
    property IndentCount: Integer read GetIndentCount;
    property Indents[Index: Integer]: TdxReportCellExpandButton read GetIndent;
  public
    constructor Create(ABuilder: TcxTreeListReportLinkBuilder); override;
    destructor Destroy; override;
    function Produce(AHostInfo: TcxTreeListAttributeHostInfo): TdxReportCell; override;
  end;

  TcxTreeListReportLinkFootersProducer = class(TcxTreeListReportLinkBandedRowProducer)
  private
    FAttachedNode: TcxTreeListNode;
    FDataNode: TcxTreeListNode;
  protected
    procedure CreateBandedDataItems(AParent: TdxReportCell); override;
    function GetAutoHeight: Boolean; override;
    function GetBandedRowIndent: Integer; override;
    function GetIndentCount: Integer; override;
    function GetLineCount: Integer; override;
    function GetLineHeight: Integer; override;
    procedure InitializeBandedRow(ARow: TdxReportCell); override;
    procedure InitializeIndent(AnIndent: TdxReportCellExpandButton; AnIndex: Integer); override;
    procedure InitializeRow; override;
  public
    function Produce(AHostInfo: TcxTreeListAttributeHostInfo; AAttachedNode,
      ADataNode: TcxTreeListNode): TdxReportCell; reintroduce; virtual;
  end;
  
  TcxTreeListReportLinkHeadersProducerClass = class of TcxTreeListReportLinkHeadersProducer;
  
  TcxTreeListReportLinkHeadersProducer = class(TcxTreeListReportLinkRowSubItemsProducer)
  protected
    procedure InitializeRow; override;
    procedure InitializeSubItem(ASubItem: TAbstractdxReportCellData; AnIndex: Integer); override;
    
    function GetAutoHeight: Boolean; override;
    function GetLineCount: Integer; override;
    function GetLineHeight: Integer; override;    
    function GetSubItemBound(Index: Integer): TRect; override;
    function GetSubItemClass(Index: Integer): TdxReportCellDataClass; override;
  end;

  TcxTreeListReportLinkNodeProducerClass = class of TcxTreeListReportLinkNodeProducer;
  
  TcxTreeListReportLinkNodeProducer = class(TcxTreeListReportLinkBandedRowProducer)
  private
    FCheck: TdxCustomReportCellCheck;
    FImage: TdxReportCellGraphic;
    FNode: TcxTreeListNode;
    FPreviewItem: TAbstractdxReportCellData;
    FStateImage: TdxReportCellGraphic;
    function GetCheckIndentIndex: Integer;
    function GetImageIndentIndex: Integer;
    function GetPreviewColumn: TcxTreeListColumn;
    function GetPreviewPlace: TcxTreeListPreviewPlace;
    function GetStateImageIndentIndex: Integer;
  protected
    procedure CalculateRowAutoHeight; override;
    procedure CreateChecks(AParent: TdxReportCell); virtual;
    procedure CreateIcons(AParent: TdxReportCell); virtual;
    procedure CreateImages(AParent: TdxReportCell); virtual;
    procedure CreateIndents(AParent: TdxReportCell); override;
    procedure CreatePreview(AParent: TdxReportCell); virtual;
    procedure CreateRow; override;
    procedure CreateStateImages(AParent: TdxReportCell); virtual;
    function DoesItemParticipateInRowAutoHeightCalculation(AnItem: TdxReportVisualItem): Boolean; override;
    procedure FixupRowDataHeight; override;
    procedure InitializeBandedDataItem(AItem: TAbstractdxReportCellData); override;
    procedure InitializeBandedRow(ARow: TdxReportCell); override;
    procedure InitializeCheck; virtual;
    procedure InitializeImage(AnIndex: Integer); virtual;
    procedure InitializeIndent(AnIndent: TdxReportCellExpandButton; AnIndex: Integer); override;
    procedure InitializeRow; override;
    procedure InitializeStateImage(AnIndex: Integer); virtual;
    function IsItemIndent(AnItem: TdxReportVisualItem): Boolean;

    function GetAutoHeight: Boolean; override;
    function GetBandedDataItemBounds(AItem: TAbstractdxReportCellData): TRect; override;
    function GetBandedDataItemClass(AColumnPlace: TcxTreeListColumnPlace): TdxReportCellDataClass; override;
    function GetBandedRowIndent: Integer; override;
    function GetCellAutoHeight: Boolean; virtual;
    function GetCheckRect: TRect; virtual;
    function GetHasPreview: Boolean; virtual;
    function GetImageRect: TRect; virtual;
    function GetIndentCount: Integer; override;
    function GetLineCount: Integer; override;
    function GetLineHeight: Integer; override;
    function GetPreviewHeight: Integer; virtual;
    function GetPreviewIndent: Integer; virtual;
    function GetPreviewLineCount: Integer; virtual;
    function GetPreviewLineHeight: Integer; virtual;
    function GetStateImageRect: TRect; virtual;
  public
    function Produce(AHostInfo: TcxTreeListAttributeHostInfo;
      ANode: TcxTreeListNode): TdxReportCell; reintroduce; virtual;

    property CellAutoHeight: Boolean read GetCellAutoHeight;
    property CheckIndentIndex: Integer read GetCheckIndentIndex;
    property CheckRect: TRect read GetCheckRect;
    property HasPreview: Boolean read GetHasPreview;
    property Image: TdxReportCellGraphic read FImage;
    property ImageIndentIndex: Integer read GetImageIndentIndex;
    property ImageRect: TRect read GetImageRect;
    property PreviewColumn: TcxTreeListColumn read GetPreviewColumn;
    property PreviewHeight: Integer read GetPreviewHeight;
    property PreviewIndent: Integer read GetPreviewIndent;
    property PreviewItem: TAbstractdxReportCellData read FPreviewItem;
    property PreviewLineCount: Integer read GetPreviewLineCount;
    property PreviewLineHeight: Integer read GetPreviewLineHeight;
    property PreviewPlace: TcxTreeListPreviewPlace read GetPreviewPlace;
    property StateImage: TdxReportCellGraphic read FStateImage;
    property StateImageIndentIndex: Integer read GetStateImageIndentIndex;
    property StateImageRect: TRect read GetStateImageRect;
  end;

  TcxTreeListReportLinkCategorizedNodeProducer = class(TcxTreeListReportLinkNodeProducer)
  protected
    procedure CreateBandedRows(AParent: TdxReportCell); override;
  end;

  { helpers }
  
  TcxTreeListNodeHelperClass = class of TcxTreeListNodeHelper;
  
  TcxTreeListNodeHelper = class(TdxCustomClassMapItem)
  private
    FAdapter: TcxTreeListAdapter;
    FNode: TcxTreeListNode;
  protected
    function Adapter: TcxTreeListAdapter; overload; virtual;
    class function NodeClass: TcxTreeListNodeClass; virtual;
    
    function GetHasSelectedChildren: Boolean; virtual;
    function GetHasSelectedParents: Boolean; virtual;
  public
    constructor Create(AnAdapter: TcxTreeListAdapter); virtual;

    class function PairClass: TClass; override;
    class function ProducerClass: TcxTreeListReportLinkNodeProducerClass; virtual;
    class procedure Register;
    class procedure Unregister;

    property HasSelectedChildren: Boolean read GetHasSelectedChildren;
    property HasSelectedParents: Boolean read GetHasSelectedParents;
    property Node: TcxTreeListNode read FNode write FNode;
  end;
                                               
  TcxTreeListNodeHelperCache = class(TdxCustomCache)
  private
    FAdapter: TcxTreeListAdapter;
    function GetHelper(Node: TcxTreeListNode): TcxTreeListNodeHelper;
    function GetItem(Index: Integer): TcxTreeListNodeHelper;
  protected 
    function IndexOf(Node: TcxTreeListNode): Integer;
    property Items[Index: Integer]: TcxTreeListNodeHelper read GetItem;
  public
    constructor Create(AnAdapter: TcxTreeListAdapter);

    property Adapter: TcxTreeListAdapter read FAdapter;
    property Helpers[Node: TcxTreeListNode]: TcxTreeListNodeHelper read GetHelper; default;
  end;
    
  TcxTreeListReportLinkProducerCache = class(TdxCustomCache)
  private
    FBuilder: TcxTreeListReportLinkBuilder;
    function GetItem(Index: Integer): TcxTreeListReportLinkRowProducer;
    function GetProducer(ProducerClass: TcxTreeListReportLinkRowProducerClass): TcxTreeListReportLinkRowProducer;
  protected 
    function IndexOf(AProducerClass: TcxTreeListReportLinkRowProducerClass): Integer;
    property Items[Index: Integer]: TcxTreeListReportLinkRowProducer read GetItem;
  public
    constructor Create(ABuilder: TcxTreeListReportLinkBuilder);
    property Builder: TcxTreeListReportLinkBuilder read FBuilder;
    property Producers[ProducerClass: TcxTreeListReportLinkRowProducerClass]: TcxTreeListReportLinkRowProducer read GetProducer; default;
  end;
    
  TcxTreeListReportLinkBuilder = class
  private
    FAdapter: TcxTreeListAdapter;
    FFormatter: TcxTreeListReportLinkFormatter;
    FProducerCache: TcxTreeListReportLinkProducerCache;
    FReportLink: TcxTreeListCustomReportLink;
    FReportRows: TList;
    function GetHost: TdxReportCell;
    function GetReportCells: TdxReportCells;
    function GetReportRow(Index: Integer): TdxReportCell;
    function GetReportRowCount: Integer;
    function GetTreeList: TcxCustomTreeList;
  protected
    procedure AddReportRow(ARow: TdxReportCell);
    procedure AfterBuilding; virtual;
    procedure BeforeBuilding; virtual;
    { bands }
    procedure CreateBands; virtual;
    function GetBandsProducer: TcxTreeListReportLinkBandsProducer; 
    function GetBandsProducerClass: TcxTreeListReportLinkBandsProducerClass; virtual;
    { footers }
    procedure CreateFooters(AHostInfo: TcxTreeListAttributeHostInfo;
      AAttachedNode, ADataNode: TcxTreeListNode); virtual;
    function GetFootersProducer: TcxTreeListReportLinkFootersProducer;
    function GetFootersProducerClass: TcxTreeListReportLinkFootersProducerClass; virtual;
    { headers }
    procedure CreateHeaders; virtual;
    function GetHeadersProducer: TcxTreeListReportLinkHeadersProducer;
    function GetHeadersProducerClass: TcxTreeListReportLinkHeadersProducerClass; virtual;
    { nodes }
    procedure CreateNode(ANode: TcxTreeListNode); virtual;
    procedure CreateNodes; virtual;
    function GetNodeProducer(ANode: TcxTreeListNode): TcxTreeListReportLinkNodeProducer;
    function GetNodeProducerClass(ANode: TcxTreeListNode): TcxTreeListReportLinkNodeProducerClass; virtual;
    { separators }
    procedure CreateNodeSeparator(ANode: TcxTreeListNode); virtual;
    function GetNodeSeparatorProducer: TcxTreeListReportLinkNodeSeparatorProducer;
    function GetNodeSeparatorProducerClass: TcxTreeListReportLinkNodeSeparatorProducerClass; virtual;
    
    procedure DoBuild; virtual;
    function IsAborted: Boolean;
    
    property ProducerCache: TcxTreeListReportLinkProducerCache read FProducerCache;
    property ReportLink: TcxTreeListCustomReportLink read FReportLink;
  public
    constructor Create(AReportLink: TcxTreeListCustomReportLink); virtual;
    destructor Destroy; override;

    procedure Build; virtual;
    procedure Progress(const APercentDone: Double);

    function Adapter: TcxTreeListAdapter; overload; virtual;
    class function AdapterClass: TcxTreeListAdapterClass; virtual;
    function Formatter: TcxTreeListReportLinkFormatter; overload; virtual;
    class function FormatterClass: TcxTreeListReportLinkFormatterClass; virtual;

    property Host: TdxReportCell read GetHost;
    property ReportCells: TdxReportCells read GetReportCells;
    property ReportRowCount: Integer read GetReportRowCount;
    property ReportRows[Index: Integer]: TdxReportCell read GetReportRow;
    property TreeList: TcxCustomTreeList read GetTreeList;
  end;

  TcxTreeListReportLinkBuilderHandler = class
  private
    FBuilder: TcxTreeListReportLinkBuilder;
    function GetReportLink: TcxTreeListCustomReportLink;
  public
    constructor Create(ABuilder: TcxTreeListReportLinkBuilder); virtual;
    function Builder: TcxTreeListReportLinkBuilder; overload; virtual;

    property ReportLink: TcxTreeListCustomReportLink read GetReportLink; 
  end;

  TcxTreeListAdapter = class(TcxTreeListReportLinkBuilderHandler)
  private
    FDetailsLineCount: Integer;
    FFooterLineCount: Integer;
    FGroupFooterLineCount: Integer;
    FHelperCache: TcxTreeListNodeHelperCache;
    FMultiRows: Boolean;
    function GetAutoWidth: Boolean;
    function GetBand(Index: Integer): TcxTreeListBand;
    function GetBandCount: Integer;
    function GetBottomBand(Index: Integer): TcxTreeListBand;
    function GetBottomBandCount: Integer;
    function GetCanUseLookAndFeelColors: Boolean;
    function GetCategorizedColumn: TcxTreeListColumn;
    function GetCellAutoHeight: Boolean;
    function GetCellEndEllipsis: Boolean; 
    function GetCellMultiline: Boolean;
    function GetColumn(Index: Integer): TcxTreeListColumn;
    function GetColumnCount: Integer;
    function GetDefaultRowHeight: Integer;
    function GetFooterLineCount(ANode: TcxTreeListNode): Integer;
    function GetGridLines: TcxTreeListGridLines;
    function GetGridLinesColor: TColor;
    function GetHasPreview: Boolean;
    function GetHeaderAutoHeight: Boolean;
    function GetHelper(Node: TcxTreeListNode): TcxTreeListNodeHelper;
    function GetImages: TCustomImageList;
    function GetIndentWidth: Integer;
    function GetIsDefaultRowHeightAssigned: Boolean;
    function GetIsNodeColorUsedForIndents: Boolean;
    function GetLookAndFeelKind: TcxLookAndFeelKind;
    function GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
    function GetMultiSelection: Boolean;
    function GetNode(Index: Integer): TcxTreeListNode;
    function GetNodeCount: Integer;
    function GetOptionsView: TcxTreeListOptionsView;
    function GetPaintStyle: TcxTreeListPaintStyle;
    function GetPreviewColumn: TcxTreeListColumn;
    function GetPreviewLeftIndent: Integer;
    function GetPreviewPlace: TcxTreeListPreviewPlace;
    function GetPreviewRightIndent: Integer;
    function GetRootBand(Index: Integer): TcxTreeListBand;
    function GetRootBandCount: Integer;
    function GetShowRoot: Boolean;
    function GetShowHorzGridLines: Boolean;
    function GetShowTreeLines: Boolean;
    function GetShowVertGridLines: Boolean;
    function GetStateImages: TCustomImageList;
    function GetStyles: TcxTreeListStyles;
    function GetThemedBandHeaderItemColor: TColor;
    function GetThemedBandHeaderItemTextColor: TColor;
    function GetThemedFooterItemColor: TColor;
    function GetThemedFooterItemTextColor: TColor;
    function GetThemedHeaderItemColor: TColor;
    function GetThemedHeaderItemTextColor: TColor;
    function GetThemedHeaderRowColor: TColor;
    function GetTreeLinesColor: TColor;
    function GetTreeLinesStyle: TcxTreeListTreeLineStyle;
    function GetTreeList: TcxCustomTreeList;
    function GetUseStylesForIndents: Boolean;
  protected
    function CalculateDetailsLineCount: Integer; virtual;
    procedure Calculate;
    { properties }
    class function GetProperties(AColumn: TcxTreeListColumn; ANode: TcxTreeListNode): TcxCustomEditProperties;
    class function GetPropertiesClass(AColumn: TcxTreeListColumn; ANode: TcxTreeListNode): TcxCustomEditPropertiesClass;
    class function GetRepositoryItem(AColumn: TcxTreeListColumn; ANode: TcxTreeListNode): TcxEditRepositoryItem;
    { styles }
    function GetBackgroundViewParams: TcxViewParams; virtual;
    function GetBandBackgroundViewParams: TcxViewParams; virtual;    
    function GetBandHeaderViewParams(ABand: TcxTreeListBand): TcxViewParams; virtual;    
    function GetColumnFooterViewParams(AColumn: TcxTreeListColumn): TcxViewParams; virtual;
    function GetColumnHeaderViewParams(AColumn: TcxTreeListColumn): TcxViewParams; virtual;
    function GetContentViewParams(ANode: TcxTreeListNode; AColumn: TcxTreeListColumn): TcxViewParams; virtual;
    function GetIndentViewParams(ANode: TcxTreeListNode; AnIndent: Integer): TcxViewParams; virtual;
    function GetPreviewViewParams(ANode: TcxTreeListNode; AColumn: TcxTreeListColumn): TcxViewParams; virtual;
    function GetFooterRowViewParams: TcxViewParams; virtual;
    function GetSelectionViewParams: TcxViewParams; virtual;
    function HasSelectionStyle: Boolean;
    { Backgrounds }
    function GetBackgroundBitmap(Index: Integer): TBitmap;
    function HasBackgroundBitmap(Index: Integer): Boolean;

    function GetCheckWidth(ANode: TcxTreeListNode): Integer;
    function GetImagesHeight(ANode: TcxTreeListNode): Integer;
    function GetImagesWidth(ANode: TcxTreeListNode): Integer;
    function GetStateImagesHeight(ANode: TcxTreeListNode): Integer;
    function GetStateImagesWidth(ANode: TcxTreeListNode): Integer;
    function HasCheck(ANode: TcxTreeListNode): Boolean;
    function HasImages(ANode: TcxTreeListNode): Boolean;
    function HasStateImages(ANode: TcxTreeListNode): Boolean;
    function IsGroupNode(ANode: TcxTreeListNode): Boolean;
    function HasNodeAttachedFooter(ANode, ASummaryNode: TcxTreeListNode): Boolean;
    function HasNodeSummary(ANode: TcxTreeListNode): Boolean;

    property Helpers[Node: TcxTreeListNode]: TcxTreeListNodeHelper read GetHelper;
    property LookAndFeelKind: TcxLookAndFeelKind read GetLookAndFeelKind;
    property LookAndFeelPainter: TcxCustomLookAndFeelPainterClass read GetLookAndFeelPainter;
    property OptionsView: TcxTreeListOptionsView read GetOptionsView;
    property Styles: TcxTreeListStyles read GetStyles;
    property TreeList: TcxCustomTreeList read GetTreeList;
  public
    constructor Create(ABuilder: TcxTreeListReportLinkBuilder); override;
    destructor Destroy; override;
    
    property AutoWidth: Boolean read GetAutoWidth;
    property BandCount: Integer read GetBandCount;
    property Bands[Index: Integer]: TcxTreeListBand read GetBand;
    property BottomBandCount: Integer read GetBottomBandCount;
    property BottomBands[Index: Integer]: TcxTreeListBand read GetBottomBand;
    property CanUseLookAndFeelColors: Boolean read GetCanUseLookAndFeelColors;
    property CategorizedColumn: TcxTreeListColumn read GetCategorizedColumn;
    property CellAutoHeight: Boolean read GetCellAutoHeight;
    property CellEndEllipsis: Boolean read GetCellEndEllipsis;
    property CellMultiline: Boolean read GetCellMultiline;
    property ColumnCount: Integer read GetColumnCount;
    property Columns[Index: Integer]: TcxTreeListColumn read GetColumn;
    property DefaultRowHeight: Integer read GetDefaultRowHeight;
    property DetailsLineCount: Integer read FDetailsLineCount;
    property FooterLineCount[ANode: TcxTreeListNode]: Integer read GetFooterLineCount;
    property GridLines: TcxTreeListGridLines read GetGridLines;
    property GridLinesColor: TColor read GetGridLinesColor;
    property HasPreview: Boolean read GetHasPreview;
    property HeaderAutoHeight: Boolean read GetHeaderAutoHeight;
    property Images: TCustomImageList read GetImages;
    property IndentWidth: Integer read GetIndentWidth;
    property IsDefaultRowHeightAssigned: Boolean read GetIsDefaultRowHeightAssigned;
    property IsNodeColorUsedForIndents: Boolean read GetIsNodeColorUsedForIndents;
    property MultiSelection: Boolean read GetMultiSelection;
    property PaintStyle: TcxTreeListPaintStyle read GetPaintStyle;
    property PreviewColumn: TcxTreeListColumn read GetPreviewColumn;
    property PreviewLeftIndent: Integer read GetPreviewLeftIndent;
    property PreviewPlace: TcxTreeListPreviewPlace read GetPreviewPlace;
    property PreviewRightIndent: Integer read GetPreviewRightIndent;
    property NodeCount: Integer read GetNodeCount;
    property Nodes[Index: Integer]: TcxTreeListNode read GetNode;
    property RootBandCount: Integer read GetRootBandCount;
    property RootBands[Index: Integer]: TcxTreeListBand read GetRootBand;
    property ShowRoot: Boolean read GetShowRoot;
    property ShowHorzGridLines: Boolean read GetShowHorzGridLines;
    property ShowTreeLines: Boolean read GetShowTreeLines;
    property ShowVertGridLines: Boolean read GetShowVertGridLines;    
    property StateImages: TCustomImageList read GetStateImages;
    property ThemedBandHeaderItemColor: TColor read GetThemedBandHeaderItemColor;
    property ThemedBandHeaderItemTextColor: TColor read GetThemedBandHeaderItemTextColor;
    property ThemedFooterItemColor: TColor read GetThemedFooterItemColor;
    property ThemedFooterItemTextColor: TColor read GetThemedFooterItemTextColor;
    property ThemedHeaderItemColor: TColor read GetThemedHeaderItemColor;
    property ThemedHeaderItemTextColor: TColor read GetThemedHeaderItemTextColor;
    property ThemedHeaderRowColor: TColor read GetThemedHeaderRowColor;
    property TreeLinesColor: TColor read GetTreeLinesColor;
    property TreeLinesStyle: TcxTreeListTreeLineStyle read GetTreeLinesStyle;
    property UseStylesForIndents: Boolean read GetUseStylesForIndents;
  end;

  TcxTreeListCustomItemPlaceController = class
  private
    FFormatter: TcxTreeListReportLinkFormatter;
    FHeaderLineCount: Integer;
    FWidth: Integer;
    function GetAdapter: TcxTreeListAdapter;
    function GetHeaderLineCount: Integer;
    function GetWidth: Integer;
    procedure SetWidth(Value: Integer);
  protected
    function CalculateWidth: Integer; virtual;
    function CalculateHeaderLineCount: Integer; virtual;
    function GetItemByColumn(Column: TcxTreeListColumn): TcxTreeListColumnPlace; virtual;
    procedure WidthChanged; virtual;
  public
    constructor Create(AFormatter: TcxTreeListReportLinkFormatter); virtual;
    procedure Calculate; virtual;
    procedure Refresh; virtual;

    property Adapter: TcxTreeListAdapter read GetAdapter;
    property Formatter: TcxTreeListReportLinkFormatter read FFormatter;
    property HeaderLineCount: Integer read GetHeaderLineCount;
    property ItemsByColumn[Column: TcxTreeListColumn]: TcxTreeListColumnPlace read GetItemByColumn; default;
    property Width: Integer read GetWidth write SetWidth;
  end;

  TcxTreeListColumnPlace = class
  private
    FColumn: TcxTreeListColumn;
    FController: TcxTreeListCustomBandPlace;
    FLeftBound: Integer;
    FWidth: Integer;
    function GetAdapter: TcxTreeListAdapter;
    function GetCellBounds(ANode: TcxTreeListNode): TRect;
    function GetCellHeight(ANode: TcxTreeListNode): Integer;
    function GetFooterCellBounds(AIndex: Integer): TRect;
    function GetFooterLineHeight: Integer;
    function GetFormatter: TcxTreeListReportLinkFormatter;
    function GetHeaderCellBounds: TRect;
    function GetHeaderLineHeight: Integer;
    function GetIndex: Integer;
    function GetIsFixed: Boolean;
    function GetLeftBound: Integer;
    function GetMinWidth: Integer;
    function GetOriginalWidth: Integer;
    function GetWidth: Integer;
  protected
    function CalculateLeftBound: Integer; virtual;
    function GetLineCount: Integer; virtual;
    function GetRowIndex: Integer; virtual;
    procedure InitAutoWidthItem(AnItem: TcxAutoWidthItem); virtual;

    property Adapter: TcxTreeListAdapter read GetAdapter;
    property Formatter: TcxTreeListReportLinkFormatter read GetFormatter;
    property IsFixed: Boolean read GetIsFixed;
    property LineCount: Integer read GetLineCount;
    property MinWidth: Integer read GetMinWidth;
    property OriginalWidth: Integer read GetOriginalWidth;
    property RowIndex: Integer read GetRowIndex;
  public
    constructor Create(AController: TcxTreeListCustomBandPlace; AColumn: TcxTreeListColumn); virtual;
    procedure Calculate(ALeftBound: Integer); virtual;
    
    property CellBounds[ANode: TcxTreeListNode]: TRect read GetCellBounds;
    property CellHeights[ANode: TcxTreeListNode]: Integer read GetCellHeight;
    property Column: TcxTreeListColumn read FColumn;
    property Controller: TcxTreeListCustomBandPlace read FController;
    property FooterCellBounds[AIndex: Integer]: TRect read GetFooterCellBounds;
    property FooterLineHeight: Integer read GetFooterLineHeight;
    property HeaderCellBounds: TRect read GetHeaderCellBounds;
    property HeaderLineHeight: Integer read GetHeaderLineHeight;
    property Index: Integer read GetIndex;
    property LeftBound: Integer read GetLeftBound write FLeftBound;
    property Width: Integer read GetWidth write FWidth;
  end;

  TcxTreeListCustomBandPlace = class(TcxTreeListCustomItemPlaceController)
  private
    FBand: TcxTreeListBand;
    FColumnIndexes: TList;
    FController: TcxTreeListItemPlaceController;
    FHeight: Integer;
    FItems: TObjectList;
    FLeftBound: Integer;
    FMinWidth: Integer;
    FParent: TcxTreeListBandPlace;
    FTopBound: Integer;
    function GetColumnIndex(AColumn: TcxTreeListColumn): Integer;
    function GetBounds: TRect;
    function GetExpandable: Boolean;
    function GetHeight: Integer;
    function GetIndex: Integer;
    function GetIsFixed: Boolean;
    function GetItem(AIndex: Integer): TcxTreeListColumnPlace;
    function GetItemCount: Integer;
    function GetLeftBound: Integer;
    function GetLevelIndex: Integer;
    function GetMinWidth: Integer;
    function GetTopBound: Integer;
    function GetViewParams: TdxReportItemViewParams;
  protected
    function CalculateHeaderLineCount: Integer; override;
    function CalculateWidth: Integer; override;
    function GetItemByColumn(Column: TcxTreeListColumn): TcxTreeListColumnPlace; override;

    procedure AddItems; virtual;
    procedure AssignWidth;
    function CalculateHeight: Integer; virtual;
    function CalculateItemLeftBound(AnItem: TcxTreeListColumnPlace): Integer; virtual;
    procedure CalculateItemsWidth; virtual;
    function CalculateLeftBound: Integer; virtual;
    function CalculateLevelHeight: Integer; virtual;
    function CalculateLineHeight: Integer; virtual;
    function CalculateMinWidth: Integer; virtual;
    function CalculateTopBound: Integer; virtual;
    function CreateItem(AColumn: TcxTreeListColumn): TcxTreeListColumnPlace; virtual;
    procedure InitAutoWidthItem(AnItem: TcxAutoWidthItem); virtual;

    function GetRowCount: Integer; virtual;
    function GetItemsAutoWidth: Boolean; virtual;
    function GetItemsAvailableWidth: Integer; virtual;
    function InternalCalculateMinWidth: Integer; virtual;
    function InternalCalculateWidth: Integer; virtual;

    property Band: TcxTreeListBand read FBand;
    property IsFixed: Boolean read GetIsFixed;
    property ItemsAutoWidth: Boolean read GetItemsAutoWidth;
    property ItemsAvailableWidth: Integer read GetItemsAvailableWidth;
    property LevelIndex: Integer read GetLevelIndex;
    property MinWidth: Integer read GetMinWidth;
    property RowCount: Integer read GetRowCount;
    property ViewParams: TdxReportItemViewParams read GetViewParams;
  public
    constructor Create(AController: TcxTreeListItemPlaceController;
      AParent: TcxTreeListBandPlace; ABand: TcxTreeListBand); reintroduce; virtual;
    destructor Destroy; override;
    procedure Calculate; override;
    function IndexOf(AnItem: TcxTreeListColumnPlace): Integer; overload;
    function IndexOf(AColumn: TcxTreeListColumn): Integer; overload;
    procedure Refresh; override;

    property Bounds: TRect read GetBounds;
    property ColumnIndexes[Column: TcxTreeListColumn]: Integer read GetColumnIndex;
    property Controller: TcxTreeListItemPlaceController read FController;
    property Expandable: Boolean read GetExpandable;
    property Height: Integer read GetHeight write FHeight;
    property Index: Integer read GetIndex;
    property ItemCount: Integer read GetItemCount;
    property Items[Index: Integer]: TcxTreeListColumnPlace read GetItem; default;
    property LeftBound: Integer read GetLeftBound write FLeftBound;
    property Parent: TcxTreeListBandPlace read FParent;
    property TopBound: Integer read GetTopBound write FTopBound;
  end;

  TcxTreeListCustomBandPlaceClass = class of TcxTreeListCustomBandPlace;

  TcxTreeListBandPlace = class(TcxTreeListCustomBandPlace)
  private
    FChildItems: TList;
    function GetChildItem(Index: Integer): TcxTreeListCustomBandPlace;
    function GetChildItemCount: Integer;
  protected
    function GetRowCount: Integer; override;
    function InternalCalculateMinWidth: Integer; override;
    function InternalCalculateWidth: Integer; override;
    procedure WidthChanged; override;

    procedure CalculateChildItemWidths;
    procedure RefreshChildItems;
  public
    constructor Create(AnOwner: TcxTreeListItemPlaceController;
      AParent: TcxTreeListBandPlace; ABand: TcxTreeListBand); override;
    destructor Destroy; override;

    function IndexOf(AnItem: TcxTreeListCustomBandPlace): Integer;
    procedure Refresh; override;

    property ChildItemCount: Integer read GetChildItemCount;
    property ChildItems[Index: Integer]: TcxTreeListCustomBandPlace read GetChildItem;
  end;

  TcxTreeListBottomBandPlace = class(TcxTreeListCustomBandPlace)
  protected
    procedure AddItems; override;
    function CalculateItemLeftBound(AnItem: TcxTreeListColumnPlace): Integer; override;
    procedure CalculateItemsWidth; override;
    function GetItemsAutoWidth: Boolean; override;
    function GetItemsAvailableWidth: Integer; override;

    function GetRowCount: Integer; override;
    function InternalCalculateMinWidth: Integer; override;
    function InternalCalculateWidth: Integer; override;
    procedure WidthChanged; override;
  end;

  TcxTreeListItemPlaceController = class(TcxTreeListCustomItemPlaceController)
  private
    FBottomItems: TList;
    FHeight: Integer;
    FItems: TObjectList;
    FLevelCount: Integer;
    FLevelHeights: TList;
    FRootItems: TList;
    function GetAutoWidth: Boolean;
    function GetAvailableWidth: Integer;
    function GetBottomItem(AIndex: Integer): TcxTreeListCustomBandPlace;
    function GetBottomItemCount: Integer;
    function GetHeight: Integer;
    function GetItem(AIndex: Integer): TcxTreeListCustomBandPlace;
    function GetItemByBand(ABand: TcxTreeListBand): TcxTreeListCustomBandPlace;
    function GetItemCount: Integer;
    function GetLevelCount: Integer;
    function GetLevelHeight(AIndex: Integer): Integer;
    function GetRootItem(AIndex: Integer): TcxTreeListCustomBandPlace;
    function GetRootItemCount: Integer;
    procedure SetLevelHeight(AIndex: Integer; AValue: Integer);
  protected
    function CalculateHeaderLineCount: Integer; override;
    function CalculateWidth: Integer; override;
    function GetItemByColumn(AColumn: TcxTreeListColumn): TcxTreeListColumnPlace; override;

    procedure AddItems; virtual;
    function CreateItem(ABand: TcxTreeListBand): TcxTreeListCustomBandPlace; virtual;
    function GetItemClass(ABand: TcxTreeListBand): TcxTreeListCustomBandPlaceClass; virtual;
    procedure RefreshBottomItems;
    procedure RefreshItems;
    procedure RefreshRootItems;

    function CalculateHeight: Integer; virtual;
    function CalculateItemHeight(AnItem: TcxTreeListCustomBandPlace): Integer; virtual;
    function CalculateItemLeftBound(AnItem: TcxTreeListCustomBandPlace): Integer; virtual;
    function CalculateItemTopBound(AnItem: TcxTreeListCustomBandPlace): Integer; virtual;
    function CalculateLevelCount: Integer; virtual;

    procedure CalculateItemWidths;
    procedure CalculateLevelHeights;

    property AutoWidth: Boolean read GetAutoWidth;
    property AvailableWidth: Integer read GetAvailableWidth;
  public
    constructor Create(AFormatter: TcxTreeListReportLinkFormatter); override;
    destructor Destroy; override;

    procedure Calculate; override;
    procedure Refresh; override;

    function BottomIndexOf(AnItem: TcxTreeListCustomBandPlace): Integer;
    function IndexOf(AnItem: TcxTreeListCustomBandPlace): Integer; overload;
    function IndexOf(ABand: TcxTreeListBand): Integer; overload;
    function RootIndexOf(AnItem: TcxTreeListCustomBandPlace): Integer; overload;
    function RootIndexOf(ABand: TcxTreeListBand): Integer; overload;

    property BottomItemCount: Integer read GetBottomItemCount;
    property BottomItems[Index: Integer]: TcxTreeListCustomBandPlace read GetBottomItem;
    property Height: Integer read GetHeight;
    property ItemCount: Integer read GetItemCount;
    property Items[Index: Integer]: TcxTreeListCustomBandPlace read GetItem; default;
    property ItemsByBand[Band: TcxTreeListBand]: TcxTreeListCustomBandPlace read GetItemByBand;
    property LevelCount: Integer read GetLevelCount;
    property LevelHeights[Index: Integer]: Integer read GetLevelHeight write SetLevelHeight;
    property RootItemCount: Integer read GetRootItemCount;
    property RootItems[Index: Integer]: TcxTreeListCustomBandPlace read GetRootItem;
  end;

  TcxTreeListReportLinkSummaryItems = array of array of TcxTreeListSummaryItem;

  TcxTreeListReportLinkFormatter = class(TcxTreeListReportLinkBuilderHandler,
    IUnknown, IdxPSCellParams, IdxPSCellParams2)
  private
    FBands: TList;
    FBandLineHeight: Integer;
    FColumns: TList;
    FDetailsLineHeight: Integer;
    FGroupFooterSummaryItems: TcxTreeListReportLinkSummaryItems;
    FItemPlaceController: TcxTreeListItemPlaceController;
    FFont: TFont;
    FFooterLineHeight: Integer;
    FHeaderLineHeight: Integer;
    FLookAndFeelItems: TList;
    FNodes: TList;
    FPreviewLineHeight: Integer;
    FFooterSummaryItems: TcxTreeListReportLinkSummaryItems;
    FTransparentColor: TColor;
    function GetAutoWidth: Boolean;
    function GetAvailableWidth: Integer;
    function GetBandCount: Integer;
    function GetBands(AIndex: Integer): TcxTreeListBand;
    function GetColumnCount: Integer;
    function GetColumns(AIndex: Integer): TcxTreeListColumn;
    function GetDC: HDC;
    function GetExpandButtonColor: TColor;
    function GetExpandButtonSize: Integer;
    function GetGridLinesColor: TColor;
    function GetHasNodeSeparator: Boolean;
    function GetHasPreview: Boolean;
    function GetIndentCount(Node: TcxTreeListNode): Integer;
    function GetIsNodeColorUsedForIndents: Boolean;
    function GetLookAndFeelItem(Index: Integer): TdxReportVisualItem;
    function GetLookAndFeelItemCount: Integer;
    function GetNode(Index: Integer): TcxTreeListNode;
    function GetNodeCount: Integer;
    function GetNodeSeparatorColor: TColor;
    function GetNodeSeparatorThickness: Integer;
    function GetPreviewAutoHeight: Boolean;
    function GetPreviewColumn: TcxTreeListColumn;
    function GetPreviewMaxLineCount: Integer;
    function GetRenderer: TdxPSReportRenderer;
    function GetShowBandHeaders: Boolean;
    function GetShowFooters: Boolean;
    function GetShowHeaders: Boolean;
    function GetShowPreview: Boolean;
    function GetUseLookAndFeelColors: Boolean;
    function GetViewWidth: Integer;
    function GetTreeLinesColor: TColor;
    function GetTreeLinesStyle: TcxTreeListTreeLineStyle;

    procedure FormatLookAndFeelItems;
  protected
    { IUnknown }
    function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
    { IdxPSCellParams }
    function IdxPSCellParams.GetAutoHeight = IdxPSCellParams_GetAutoHeight;
    function IdxPSCellParams.GetDC = IdxPSCellParams_GetDC;
    function IdxPSCellParams.GetDisplayGraphicsAsText = IdxPSCellParams_GetDisplayGraphicsAsText;
    function IdxPSCellParams.GetEndEllipsis = IdxPSCellParams_GetEndEllipsis;
    function IdxPSCellParams.GetFlatCheckMarks = IdxPSCellParams_GetFlatCheckMarks;
    function IdxPSCellParams.GetGraphicsText = IdxPSCellParams_GetGraphicsText;
    function IdxPSCellParams.GetMultiline = IdxPSCellParams_GetMultiline;
    function IdxPSCellParams.GetTransparentGraphics = IdxPSCellParams_GetTransparentGraphics;
    function IdxPSCellParams_GetAutoHeight: Boolean; virtual;
    function IdxPSCellParams_GetDC: HDC; virtual;
    function IdxPSCellParams_GetDisplayGraphicsAsText: Boolean; virtual;
    function IdxPSCellParams_GetEndEllipsis: Boolean; virtual;
    function IdxPSCellParams_GetFlatCheckMarks: Boolean; virtual;
    function IdxPSCellParams_GetGraphicsText: string; virtual;
    function IdxPSCellParams_GetMultiline: Boolean; virtual;
    function IdxPSCellParams_GetTransparentGraphics: Boolean; virtual;
    { IdxPSCellParams2 }
    function IdxPSCellParams2.GetPreviewMarginLeft = IdxPSCellParams2_GetPreviewMarginLeft;
    function IdxPSCellParams2.GetPreviewMarginRight = IdxPSCellParams2_GetPreviewMarginRight;
    function IdxPSCellParams2.GetPreviewMaxHeight = IdxPSCellParams2_GetPreviewMaxHeight;
    function IdxPSCellParams2.GetPreviewMaxLineCount = IdxPSCellParams2_GetPreviewMaxLineCount;
    function IdxPSCellParams2.GetRichEditGraphicClass = IdxPSCellParams2_GetRichEditGraphicClass;
    function IdxPSCellParams2.GetRichEditTransparent = IdxPSCellParams2_GetRichEditTransparent;
    function IdxPSCellParams2_GetPreviewMarginLeft: Integer; virtual;
    function IdxPSCellParams2_GetPreviewMarginRight: Integer; virtual;
    function IdxPSCellParams2_GetPreviewMaxHeight: Integer; virtual;
    function IdxPSCellParams2_GetPreviewMaxLineCount: Integer; virtual;
    function IdxPSCellParams2_GetRichEditGraphicClass: TGraphicClass; virtual;
    function IdxPSCellParams2_GetRichEditTransparent: Boolean; virtual;

    procedure AddDelimiters; virtual;
    procedure AddHorizontalDelimiters; virtual;
    procedure AddVerticalDelimiters; virtual;
    procedure AfterBuilding; virtual;
    procedure BeforeBuilding; virtual;
    procedure CalculateLineHeights; virtual;
    function CanProcessSelectionStyle(ANode: TcxTreeListNode): Boolean;
    procedure CreateNodeList; virtual;
    function IsSelectedNode(ANode: TcxTreeListNode): Boolean; virtual;

    function GetBackgroundBitmap(Index: Integer): TBitmap;
    function GetBackgroundBitmapIndex(Index: Integer): Integer;
    function HasBackgroundBitmap(Index: Integer): Boolean;
    function MapStyleBackgroundBitmapIndex(ATreeListBackgroundBitmapIndex: Integer): Integer;

    procedure CalculateHeight(const AParams: TdxReportItemViewParams; var AHeight: Integer);
    procedure CalculateNodeHeight(ANode: TcxTreeListNode; const AParams: TdxReportItemViewParams;
      var AHeight: Integer);
    function CalculatePatternHeight(const AParams: TdxReportItemViewParams): Integer;
    procedure CreateBands;
    procedure CreateColumns;
    procedure CreateItems;
    procedure CreateSummaryItems;
    function GetFooterCellCount(AColumn: TcxTreeListColumn; ANode: TcxTreeListNode): Integer;
    function GetNodeIndent(ANode: TcxTreeListNode): Integer;
    function GetNodeParent(ANode: TcxTreeListNode; ALevel: Integer): TcxTreeListNode;
    function GetNextNode(ANode: TcxTreeListNode): TcxTreeListNode;
    function GetPrevNode(ANode: TcxTreeListNode): TcxTreeListNode;
    function GetStyleFontIndex(const AParams: TdxReportItemViewParams): Integer;
    function GetSummaryItems(ANode: TcxTreeListNode): TcxTreeListReportLinkSummaryItems;
    function HasFooterCell(AColumn: TcxTreeListColumn; ANode: TcxTreeListNode): Boolean;
    function HasParent(ANode: TcxTreeListNode): Boolean;
    function IndexOfNode(ANode: TcxTreeListNode): Integer;
    function IsColorTransparent(AColor: TColor): Boolean;
    function IsFirstNode(ANode: TcxTreeListNode): Boolean; 
    function IsLastNode(ANode: TcxTreeListNode): Boolean; 
    function IsNodeExpanded(ANode: TcxTreeListNode): Boolean;
    function IsNodeFirstChild(ANode: TcxTreeListNode): Boolean;
    function IsNodeLastChild(ANode: TcxTreeListNode): Boolean;
    function IsOddNode(ANode: TcxTreeListNode): Boolean;
    function IsNodeSelected(ANode: TcxTreeListNode): Boolean;
    procedure RegisterLookAndFeelItem(AnItem: TdxReportVisualItem; AEdgeStyle: TdxCellEdgeStyle);
    procedure SetViewParams(AnItem: TdxReportVisualItem; const AParams: TdxReportItemViewParams);

    function MakeIndentIndex(AnIndex: Integer): DWORD;
    
    property DC: HDC read GetDC;
    property ItemPlaceController: TcxTreeListItemPlaceController read FItemPlaceController;
    property LookAndFeelItemCount: Integer read GetLookAndFeelItemCount;
    property LookAndFeelItems[Index: Integer]: TdxReportVisualItem read GetLookAndFeelItem;
    property Renderer: TdxPSReportRenderer read GetRenderer;
    property ViewWidth: Integer read GetViewWidth;
  public
    constructor Create(ABuilder: TcxTreeListReportLinkBuilder); override;
    destructor Destroy; override;
    function Adapter: TcxTreeListAdapter; overload; virtual;

    procedure DoInitializeHost(AHost: TdxReportCell); virtual;
    { Bands }
    procedure DoInitializeBandItem(AnItem: TAbstractdxReportCellData; AnIndex: Integer); virtual;
    procedure DoInitializeBandRow(ARow: TdxReportCell); virtual;
    procedure DoReportLinkInitializeBandItem(AnItem: TAbstractdxReportCellData; AIndex: Integer); virtual;
    function GetBandBackgroundViewParams: TdxReportItemViewParams; virtual;
    function GetBandItemClass(Index: Integer): TdxReportCellTextClass; virtual;
    function GetBandItemBounds(Index: Integer): TRect;    
    function GetBandItemViewParams(ABand: TcxTreeListBand): TdxReportItemViewParams; virtual;
    { Checks }
    procedure DoInitializeNodeCheck(AnItem: TdxCustomReportCellCheck;
      ANode: TcxTreeListNode; AnIndex: Integer); virtual;
    function GetNodeCheckCellSides(ANode: TcxTreeListNode; AnIndex: Integer): TdxCellSides; virtual;
    function GetNodeCheckClass(ANode: TcxTreeListNode): TdxCustomReportCellCheckClass; virtual;
    function GetNodeCheckViewParams(ANode: TcxTreeListNode; AnIndex: Integer): TdxReportItemViewParams; virtual;
    { Footers }
    procedure DoInitializeFooterCell(AnItem: TAbstractdxReportCellData;
      AColumn: TcxTreeListColumn; ACellIndex: Integer; ANode: TcxTreeListNode); virtual;
    procedure DoInitializeFooterIndent(AnItem: TdxReportCellExpandButton;
      AnIndex, AnIndentCount: Integer; ANode: TcxTreeListNode);
    procedure DoInitializeFooterBandedRow(ARow: TdxReportCell; AIndentCount: Integer); virtual;
    procedure DoInitializeFooterRow(ARow: TdxReportCell); virtual;
    procedure DoReportLinkInitializeFooterCell(AnItem: TAbstractdxReportCellData;
      AColumnIndex, ACellIndex: Integer); virtual;
    function GetFooterCellBounds(AColumn: TcxTreeListColumn; ACellIndex, AIndent: Integer): TRect; virtual;
    function GetFooterCellClass: TdxReportCellTextClass; virtual;
    function GetFooterCellViewParams(AColumn: TcxTreeListColumn): TdxReportItemViewParams; virtual;
    function GetNodeFooterIndentTreeLineMode(AnIndex, AnIndentCount: Integer;
      ANode: TcxTreeListNode): TdxPSTreeLineMode;
    function GetFooterRowViewParams: TdxReportItemViewParams; virtual;
    { Headers }
    procedure DoInitializeHeaderItem(AnItem: TAbstractdxReportCellData; AnIndex: Integer); virtual;   
    procedure DoInitializeHeaderRow(ARow: TdxReportCell); virtual;
    procedure DoReportLinkInitializeHeaderItem(AnItem: TAbstractdxReportCellData; AIndex: Integer); virtual;
    function GetHeaderItemBounds(AnIndex: Integer): TRect; virtual;
    function GetHeaderItemClass(AnIndex: Integer): TdxReportCellTextClass; virtual;
    function GetHeaderItemViewParams(AColumn: TcxTreeListColumn): TdxReportItemViewParams; virtual;    
    { Images }
    procedure DoInitializeNodeImage(AnItem: TdxReportCellGraphic; ANode: TcxTreeListNode; AnIndex: Integer); virtual;
    procedure DoReportLinkInitializeNodeImage(AnItem: TAbstractdxReportCellData; ANode: TcxTreeListNode; AnIndex: Integer); virtual;
    function GetNodeImageCellSides(ANode: TcxTreeListNode; AnIndex: Integer): TdxCellSides;
    function GetNodeImageClass: TdxReportCellGraphicClass; virtual;
    function GetNodeImageViewParams(ANode: TcxTreeListNode; AnIndex: Integer): TdxReportItemViewParams; virtual;
    { Indents and Expand Buttons }
    procedure DoInitializeNodeIndent(AnItem: TdxReportCellExpandButton; AnIndex, AnIndentCount: Integer; ANode: TcxTreeListNode); virtual;
    procedure DoInitializeExpandButton(AnItem: TdxReportCellExpandButton; AnIndex, AnIndentCount: Integer; ANode: TcxTreeListNode); virtual;
    procedure DoReportLinkInitializeNodeIndent(AnItem: TAbstractdxReportCellData; AnIndex, AnIndentCount: Integer; ANode: TcxTreeListNode); virtual;
    function GetNodeIndentCellSides(ANode: TcxTreeListNode; AnIndex, AnIndentCount: Integer): TdxCellSides; virtual;
    function GetNodeIndentClass: TdxReportCellExpandButtonClass; virtual;
    function GetNodeIndentTreeLineMode(AnIndex, AnIndentCount: Integer; ANode: TcxTreeListNode): TdxPSTreeLineMode;
    function GetNodeIndentViewParams(ANode: TcxTreeListNode; AnIndex, AnIndentCount: Integer): TdxReportItemViewParams; virtual;
    { Nodes }
    procedure DoInitializeNodeBandedRow(ARow: TdxReportCell); virtual;
    procedure DoInitializeNodeRow(ARow: TdxReportCell; ANode: TcxTreeListNode); virtual;
    procedure DoInitializeNodeItem(AnItem: TAbstractdxReportCellData; 
      AColumn: TcxTreeListColumn; ANode: TcxTreeListNode; AnIsPreview: Boolean = False); virtual;
    procedure DoReportLinkInitializeNodeItem(AnItem: TAbstractdxReportCellData; 
      AColumn: TcxTreeListColumn; ANode: TcxTreeListNode); virtual;
    function GetCellValue(AProperties: TcxCustomEditProperties; 
      AColumn: TcxTreeListColumn; ANode: TcxTreeListNode): TcxEditValue; virtual;  
    function GetNodeBackgroundBitmapStyleIndex(ANode: TcxTreeListNode): Integer;
    function GetNodeItemBounds(ANode: TcxTreeListNode; AIndex: Integer): TRect; virtual;
    function GetNodeItemCellSides(AColumn: TcxTreeListColumn; ANode: TcxTreeListNode): TdxCellSides;
    function GetNodeItemClass(AColumn: TcxTreeListColumn; ANode: TcxTreeListNode; 
      AnIsPreview: Boolean = False): TdxReportCellDataClass; virtual;
    function GetNodeItemViewParams(AColumn: TcxTreeListColumn; ANode: TcxTreeListNode): TdxReportItemViewParams; virtual;
    { Preview }
    procedure DoInitializePreview(AnItem: TAbstractdxReportCellData; AColumn: TcxTreeListColumn; ANode: TcxTreeListNode); virtual;
    function GetPreviewCellSides(ANode: TcxTreeListNode): TdxCellSides; virtual;
    function GetPreviewClass(AColumn: TcxTreeListColumn; ANode: TcxTreeListNode): TdxReportCellDataClass; virtual;
    function GetPreviewViewParams(AColumn: TcxTreeListColumn; ANode: TcxTreeListNode): TdxReportItemViewParams; virtual;
    { Separators }
    procedure DoInitializeNodeSeparator(AnItem: TAbstractdxReportCellData); virtual;
    procedure DoInitializeNodeSeparatorRow(ARow: TdxReportCell); virtual;
    function GetNodeSeparatorClass: TdxReportCellBoxClass; virtual;
    { State images }
    procedure DoInitializeNodeStateImage(AnItem: TdxReportCellGraphic; ANode: TcxTreeListNode; AnIndex: Integer); virtual;
    procedure DoReportLinkInitializeNodeStateImage(AnItem: TAbstractdxReportCellData; ANode: TcxTreeListNode; AnIndex: Integer); virtual;
    function GetNodeStateImageCellSides(ANode: TcxTreeListNode; AnIndex: Integer): TdxCellSides; virtual;
    function GetNodeStateImageClass: TdxReportCellGraphicClass; virtual;
    function GetNodeStateImageViewParams(ANode: TcxTreeListNode; AnIndex: Integer): TdxReportItemViewParams; virtual;
    
    property AutoWidth: Boolean read GetAutoWidth;
    property AvailableWidth: Integer read GetAvailableWidth;
    property BandLineHeight: Integer read FBandLineHeight write FBandLineHeight;
    property BandCount: Integer read GetBandCount;
    property Bands[Index: Integer]: TcxTreeListBand read GetBands;
    property ColumnCount: Integer read GetColumnCount;
    property Columns[Index: Integer]: TcxTreeListColumn read GetColumns;
    property DetailsLineHeight: Integer read FDetailsLineHeight write FDetailsLineHeight;
    property ExpandButtonColor: TColor read GetExpandButtonColor;
    property ExpandButtonSize: Integer read GetExpandButtonSize;
    property FooterLineHeight: Integer read FFooterLineHeight write FFooterLineHeight;
    property GridLinesColor: TColor read GetGridLinesColor;
    property HasNodeSeparator: Boolean read GetHasNodeSeparator;
    property HasPreview: Boolean read GetHasPreview;
    property HeaderLineHeight: Integer read FHeaderLineHeight write FHeaderLineHeight;
    property IndentCounts[Node: TcxTreeListNode]: Integer read GetIndentCount;
    property IsNodeColorUsedForIndents: Boolean read GetIsNodeColorUsedForIndents;
    property NodeCount: Integer read GetNodeCount;
    property Nodes[Index: Integer]: TcxTreeListNode read GetNode;
    property NodeSeparatorColor: TColor read GetNodeSeparatorColor;
    property NodeSeparatorThickness: Integer read GetNodeSeparatorThickness;
    property PreviewAutoHeight: Boolean read GetPreviewAutoHeight;
    property PreviewColumn: TcxTreeListColumn read GetPreviewColumn;
    property PreviewLineHeight: Integer read FPreviewLineHeight write FPreviewLineHeight;
    property PreviewMaxLineCount: Integer read GetPreviewMaxLineCount;
    property ShowBandHeaders: Boolean read GetShowBandHeaders;
    property ShowFooters: Boolean read GetShowFooters;
    property ShowHeaders: Boolean read GetShowHeaders;
    property ShowPreview: Boolean read GetShowPreview;
    property UseLookAndFeelColors: Boolean read GetUseLookAndFeelColors;
    property TransparentColor: TColor read FTransparentColor write FTransparentColor default clWindow;
    property TreeLinesColor: TColor read GetTreeLinesColor;
    property TreeLinesStyle: TcxTreeListTreeLineStyle read GetTreeLinesStyle;
  end;
  
  { Options }

  TcxTreeListReportLinkOptionsExpanding = class(TdxCustomReportLinkOptionsExpanding) 
  private
    FAutoExpandNodes: Boolean;
    FExplicitlyExpandNodes: Boolean;
    function GetReportLink: TcxTreeListCustomReportLink;
    procedure SetAutoExpandNodes(Value: Boolean); 
    procedure SetExplicitlyExpandNodes(Value: Boolean);
  protected
    function DesignerTabIndex: Integer; override;
  public
    procedure Assign(Source: TPersistent); override;
    procedure RestoreDefaults; override;
    property ReportLink: TcxTreeListCustomReportLink read GetReportLink;
  published  
    property AutoExpandNodes: Boolean read FAutoExpandNodes write SetAutoExpandNodes default False;
    property ExplicitlyExpandNodes: Boolean read FExplicitlyExpandNodes write SetExplicitlyExpandNodes default False;
  end;

  TcxTreeListReportLinkOptionsFormatting = class(TdxCustomReportLinkOptionsFormatting)
  private
    FConsumeSelectionStyle: Boolean;
    FNodeSeparatorColor: TColor;
    FNodeSeparatorThickness: Integer;
    function GetActualNodeSeparatorColor: TColor;
    function GetReportLink: TcxTreeListCustomReportLink;
    procedure SetConsumeSelectionStyle(Value: Boolean);
    procedure SetNodeSeparatorColor(Value: TColor);
    procedure SetNodeSeparatorThickness(Value: Integer);
  protected
    function DesignerTabIndex: Integer; override;
  public    
    procedure Assign(Source: TPersistent); override;
    procedure RestoreDefaults; override;
    
    property ActualNodeSeparatorColor: TColor read GetActualNodeSeparatorColor;
    property ReportLink: TcxTreeListCustomReportLink read GetReportLink;
  published
    property ConsumeSelectionStyle: Boolean read FConsumeSelectionStyle write SetConsumeSelectionStyle default False;
    property NodeSeparatorColor: TColor read FNodeSeparatorColor write SetNodeSeparatorColor default clDefault;
    property NodeSeparatorThickness: Integer read FNodeSeparatorThickness write SetNodeSeparatorThickness default 0;
    property UseLookAndFeelColors;
  end;

  TcxTreeListReportLinkOptionsOnEveryPage = class(TdxCustomTableControlReportLinkOptionsOnEveryPage)
  private
    function GetReportLink: TcxTreeListCustomReportLink;
  protected
    function DesignerTabIndex: Integer; override;
  public
    property ReportLink: TcxTreeListCustomReportLink read GetReportLink;
  published  
    property BandHeaders;
    property Footers;
    property Headers;
  end;

  TcxTreeListReportLinkOptionsPagination = class(TdxCustomTableControlReportLinkOptionsPagination)
  private
    function GetNode: Boolean;
    function GetReportLink: TcxTreeListCustomReportLink;
    procedure SetNode(Value: Boolean);
  protected
    function DesignerTabIndex: Integer; override;
  public
    property ReportLink: TcxTreeListCustomReportLink read GetReportLink;
  published  
    property Band;
    property Column;
    property Custom;
    property Node: Boolean read GetNode write SetNode default True;
  end;

  TcxTreeListReportLinkOptionsPreview = class(TdxCustomTableControlReportLinkOptionsPreview)
  private
    function GetReportLink: TcxTreeListCustomReportLink;
  protected
    function DesignerTabIndex: Integer; override;
  public  
    property ReportLink: TcxTreeListCustomReportLink read GetReportLink;
  end;

  TcxTreeListReportLinkOptionsRefinements = class(TdxCustomReportLinkOptionsRefinements)  
  private
    function GetReportLink: TcxTreeListCustomReportLink;
  protected
    function DesignerTabIndex: Integer; override;
  public
    property ReportLink: TcxTreeListCustomReportLink read GetReportLink;
  end;

  TcxTreeListReportLinkOptionsSelection = class(TdxCustomTableControlReportLinkOptionsSelection)
  private
    function GetReportLink: TcxTreeListCustomReportLink;
  protected
    function DesignerTabIndex: Integer; override;
  public  
    property ReportLink: TcxTreeListCustomReportLink read GetReportLink;
  end;

  TcxTreeListReportLinkOptionsSize = class(TdxCustomReportLinkOptionsSize)
  private
    function GetReportLink: TcxTreeListCustomReportLink;
  protected
    function DesignerTabIndex: Integer; override;
  public  
    property ReportLink: TcxTreeListCustomReportLink read GetReportLink;
  published
    property AutoWidth;
  end;
  
  TcxTreeListReportLinkOptionsView = class(TdxCustomTableControlReportLinkOptionsView)
  private
    FBorders: Boolean;
    FTreeLines: Boolean;
    function GetReportLink: TcxTreeListCustomReportLink;
    procedure SetBorders(Value: Boolean);
    procedure SetTreeLines(Value: Boolean);
  protected
    function DesignerTabIndex: Integer; override;
  public
    procedure Assign(Source: TPersistent); override;
    procedure RestoreDefaults; override;
    property ReportLink: TcxTreeListCustomReportLink read GetReportLink;
  published
    property BandHeaders;
    property Borders: Boolean read FBorders write SetBorders default True;
    property ExpandButtons;
    property Footers;
    property Headers;
    property TreeLines: Boolean read FTreeLines write SetTreeLines default True;
  end;
  
  { TcxTreeListReportLinkStyles }
  
  TcxTreeListReportLinkStylesClass = class of TcxTreeListReportLinkStyles;
  
  TcxTreeListReportLinkStyles = class(TdxCustomReportLinkStyles)
  private
    FOnGetNodeIndentStyle: TcxTreeListGetNodeIndentStyleEvent;
    function GetReportLink: TcxTreeListCustomReportLink;
  protected
    function DesignerTabIndex: Integer; override;

    procedure GetDefaultViewParams(Index: Integer; AData: TObject; out AParams: TcxViewParams); override;
    class function GetStyleCaption(AnIndex: Integer): string; override;
    function GetStyleIndexByCaption(const Caption: string): Integer; override;
  public
    procedure Assign(Source: TPersistent); override;
    
    procedure GetBandHeaderParams(ABand: TcxTreeListBand; out AParams: TcxViewParams); virtual;
    procedure GetColumnFooterParams(ANode: TcxTreeListNode; AColumn: TcxTreeListColumn;
      out AParams: TcxViewParams); virtual;
    procedure GetColumnHeaderParams(AColumn: TcxTreeListColumn; out AParams: TcxViewParams); virtual;
    procedure GetContentParams(ANode: TcxTreeListNode; AColumn: TcxTreeListColumn;
      out AParams: TcxViewParams); virtual;
    procedure GetFooterRowParams(out AParams: TcxViewParams); virtual;
    procedure GetImagesParams(ANode: TcxTreeListNode; out AParams: TcxViewParams); virtual;
    procedure GetIndentParams(ANode: TcxTreeListNode; AnIndent: Integer; out AParams: TcxViewParams); virtual;
    procedure GetPreviewParams(ANode: TcxTreeListNode; AColumn: TcxTreeListColumn;
      out AParams: TcxViewParams); virtual;
    procedure GetSelectionParams(out AParams: TcxViewParams); virtual;  

    property ReportLink: TcxTreeListCustomReportLink read GetReportLink;
  published
    property BandBackground: TcxStyle Index vspsTreeListBandBackground read GetValue write SetValue;
    property BandHeader: TcxStyle Index vspsTreeListBandHeader read GetValue write SetValue;
    property Content: TcxStyle Index vspsTreeListContent read GetValue write SetValue;
    property ContentEven: TcxStyle Index vspsTreeListContentEven read GetValue write SetValue;
    property ContentOdd: TcxStyle Index vspsTreeListContentOdd read GetValue write SetValue;
    property Footer: TcxStyle Index vspsTreeListFooter read GetValue write SetValue;
    property FooterRow: TcxStyle Index vspsTreeListFooterRow read GetValue write SetValue;
    property Header: TcxStyle Index vspsTreeListHeader read GetValue write SetValue;
    property Preview: TcxStyle Index vspsTreeListPreview read GetValue write SetValue;
    property Selection: TcxStyle Index vspsTreeListSelection read GetValue write SetValue;
    property StyleSheet;
    property OnGetNodeIndentStyle: TcxTreeListGetNodeIndentStyleEvent read FOnGetNodeIndentStyle write FOnGetNodeIndentStyle;
  end;
  
  TcxTreeListReportLinkStyleSheet = class(TdxCustomReportLinkStyleSheet) 
  private
    function GetStylesValue: TcxTreeListReportLinkStyles;
    procedure SetStylesValue(Value: TcxTreeListReportLinkStyles);
  public
    class function GetStylesClass: TcxCustomStylesClass; override;
  published  
    property Styles: TcxTreeListReportLinkStyles read GetStylesValue write SetStylesValue; 
  end;

  { Host Services }
  
  TcxTreeListAttributeHostInfo = class
  private
    FParent: TdxReportCell;
  public
    Origin: TPoint;  
    procedure Initialize(AParent: TdxReportCell);    
    property Parent: TdxReportCell read FParent;
  end;

  TcxTreeListAttributeHostInfoServicesClass = class of TcxTreeListAttributeHostInfoServices;
  
  TcxTreeListAttributeHostInfoServices = class
  private
    FPageDetailsHostInfo: TcxTreeListAttributeHostInfo;
    FPageFootersHostInfo: TcxTreeListAttributeHostInfo;
    FPageHeadersHostInfo: TcxTreeListAttributeHostInfo;
    FReportLink: TcxTreeListCustomReportLink;
    function GetArePageFootersAssigned: Boolean;
    function GetArePageHeadersAssigned: Boolean;
    function GetCanUseBandHeadersOnEveyPage: Boolean;
    function GetCanUseFootersOnEveryPage: Boolean;
    function GetCanUseHeadersOnEveryPage: Boolean;
    function GetIsInconsistentHeadersState: Boolean;
    function GetOptionsOnEveryPage: TcxTreeListReportLinkOptionsOnEveryPage;
    function GetOptionsView: TcxTreeListReportLinkOptionsView;
    function GetPageDetails: TdxReportCell;
    function GetPageFooters: TdxReportCell;
    function GetPageHeaders: TdxReportCell;
  protected  
    procedure CreateHostInfos;
    procedure DestroyHostInfos;
   
    function GetBandHeadersHostInfo: TcxTreeListAttributeHostInfo; virtual;
    function GetFootersHostInfo: TcxTreeListAttributeHostInfo; virtual;
    function GetHeadersHostInfo: TcxTreeListAttributeHostInfo; virtual;
    function GetInconsistentStateText: string; virtual;
    function GetIsInconsistentState: Boolean; virtual;
    function HasCells: Boolean;

    property OptionsOnEveryPage: TcxTreeListReportLinkOptionsOnEveryPage read GetOptionsOnEveryPage;
    property OptionsView: TcxTreeListReportLinkOptionsView read GetOptionsView;
    property PageDetails: TdxReportCell read GetPageDetails;
    property PageFooters: TdxReportCell read GetPageFooters;
    property PageHeaders: TdxReportCell read GetPageHeaders;
  public
    constructor Create(AReportLink: TcxTreeListCustomReportLink); virtual;
    destructor Destroy; override;
    procedure InitializeHostInfos;
    
    property ArePageFootersAssigned: Boolean read GetArePageFootersAssigned;
    property ArePageHeadersAssigned: Boolean read GetArePageHeadersAssigned;
    property BandHeadersHostInfo: TcxTreeListAttributeHostInfo read GetBandHeadersHostInfo;
    property CanUseBandHeadersOnEveyPage: Boolean read GetCanUseBandHeadersOnEveyPage;
    property CanUseFootersOnEveryPage: Boolean read GetCanUseFootersOnEveryPage;
    property CanUseHeadersOnEveryPage: Boolean read GetCanUseHeadersOnEveryPage;
    property FootersHostInfo: TcxTreeListAttributeHostInfo read GetFootersHostInfo;
    property HeadersHostInfo: TcxTreeListAttributeHostInfo read GetHeadersHostInfo;
    property InconsistentStateText: string read GetInconsistentStateText;
    property IsInconsistentHeadersState: Boolean read GetIsInconsistentHeadersState;
    property IsInconsistentState: Boolean read GetIsInconsistentState;
    property PageDetailsHostInfo: TcxTreeListAttributeHostInfo read FPageDetailsHostInfo;
    property PageFootersHostInfo: TcxTreeListAttributeHostInfo read FPageFootersHostInfo;
    property PageHeadersHostInfo: TcxTreeListAttributeHostInfo read FPageHeadersHostInfo;
    property ReportLink: TcxTreeListCustomReportLink read FReportLink;
  end;

  { TcxTreeListCustomReportLink }
  
  TcxTreeListNodeArray = array of TcxTreeListNode;

  TcxTreeListReportLinkGetCustomPageBreaksEvent = procedure(Sender: TcxTreeListCustomReportLink) of object;

  TcxTreeListReportLinkCustomDrawBandCellEvent = procedure(Sender: TcxTreeListCustomReportLink;
    ACanvas: TCanvas; ABand: TcxTreeListBand; AnItem: TdxReportCellImage; 
    var ADone: Boolean) of object;
    
  TcxTreeListReportLinkCustomDrawCellEvent = procedure(Sender: TcxTreeListCustomReportLink;
    ACanvas: TCanvas; ANode: TcxTreeListNode; AColumn: TcxTreeListColumn;
    AnItem: TAbstractdxReportCellData; var ADone: Boolean) of object;
    
  TcxTreeListReportLinkCustomDrawFooterCellEvent = procedure(Sender: TcxTreeListCustomReportLink;
    ACanvas: TCanvas; AColumn: TcxTreeListColumn; AnItem: TdxReportCellString; var ADone: Boolean) of object;
    
  TcxTreeListReportLinkCustomDrawHeaderCellEvent = procedure(Sender: TcxTreeListCustomReportLink;
    ACanvas: TCanvas; AColumn: TcxTreeListColumn; AnItem: TdxReportCellImage; var ADone: Boolean) of object;

  TcxTreeListReportLinkCustomDrawIndentCellEvent = procedure(Sender: TcxTreeListCustomReportLink;
    ACanvas: TCanvas; ANode: TcxTreeListNode; AnIndex: Integer; AnItem: TAbstractdxReportCellData;
    var ADone: Boolean) of object;
    
  TcxTreeListReportLinkInitializeBandCellEvent = procedure(Sender: TcxTreeListCustomReportLink;
    ABand: TcxTreeListBand; AnItem: TdxReportCellImage) of object;
    
  TcxTreeListReportLinkInitializeCellEvent = procedure(Sender: TcxTreeListCustomReportLink;
    ANode: TcxTreeListNode; AColumn: TcxTreeListColumn; AnItem: TAbstractdxReportCellData) of object;

  TcxTreeListReportLinkInitializeFooterCellEvent = procedure(Sender: TcxTreeListCustomReportLink;
    ASummaryCellIndex: Integer; AColumn: TcxTreeListColumn; AnItem: TdxReportCellString) of object;
    
  TcxTreeListReportLinkInitializeHeaderCellEvent = procedure(Sender: TcxTreeListCustomReportLink;
    AColumn: TcxTreeListColumn; AnItem: TdxReportCellImage) of object;

  TcxTreeListReportLinkInitializeIndentCellEvent = procedure(Sender: TcxTreeListCustomReportLink;
    ANode: TcxTreeListNode; AnIndex: Integer; AnItem: TAbstractdxReportCellData) of object;
    
  TcxTreeListCustomReportLink = class(TdxCustomTableControlReportLink)
  private
    FBuilder: TcxTreeListReportLinkBuilder;
    FDelimitersHardVert: TList;
    FHostInfoServices: TcxTreeListAttributeHostInfoServices;
    FReportRows: TList;
    FOnCustomDrawBandCell: TcxTreeListReportLinkCustomDrawBandCellEvent;
    FOnCustomDrawCell: TcxTreeListReportLinkCustomDrawCellEvent;
    FOnCustomDrawFooterCell: TcxTreeListReportLinkCustomDrawFooterCellEvent;
    FOnCustomDrawHeaderCell: TcxTreeListReportLinkCustomDrawHeaderCellEvent;
    FOnCustomDrawIndentCell: TcxTreeListReportLinkCustomDrawIndentCellEvent;
    FOnGetCustomPageBreaks: TcxTreeListReportLinkGetCustomPageBreaksEvent;
    FOnInitializeBandCell: TcxTreeListReportLinkInitializeBandCellEvent;
    FOnInitializeCell: TcxTreeListReportLinkInitializeCellEvent;
    FOnInitializeFooterCell: TcxTreeListReportLinkInitializeFooterCellEvent;
    FOnInitializeHeaderCell: TcxTreeListReportLinkInitializeHeaderCellEvent;
    FOnInitializeIndentCell: TcxTreeListReportLinkInitializeIndentCellEvent;
    function GetActiveStyles: TcxTreeListReportLinkStyles;
    function GetDesignWindow: TdxfmTreeListReportLinkDesignWindow;
    function GetReportRow(Index: Integer): TdxReportCell;
    function GetReportRowByNode(Node: TcxTreeListNode): TdxReportCell;
    function GetReportRowCount: Integer;
    function GetOptionsExpanding: TcxTreeListReportLinkOptionsExpanding;
    function GetOptionsFormatting: TcxTreeListReportLinkOptionsFormatting;
    function GetOptionsOnEveryPage: TcxTreeListReportLinkOptionsOnEveryPage;
    function GetOptionsPagination: TcxTreeListReportLinkOptionsPagination;
    function GetOptionsPreview: TcxTreeListReportLinkOptionsPreview;
    function GetOptionsRefinements: TcxTreeListReportLinkOptionsRefinements;
    function GetOptionsSelection: TcxTreeListReportLinkOptionsSelection;
    function GetOptionsSize: TcxTreeListReportLinkOptionsSize;
    function GetOptionsView: TcxTreeListReportLinkOptionsView;
    function GetStyles: TcxTreeListReportLinkStyles;
    function GetTreeList: TcxCustomTreeList;
    procedure SetOnCustomDrawBandCell(Value: TcxTreeListReportLinkCustomDrawBandCellEvent);
    procedure SetOnCustomDrawCell(Value: TcxTreeListReportLinkCustomDrawCellEvent);
    procedure SetOnCustomDrawFooterCell(Value: TcxTreeListReportLinkCustomDrawFooterCellEvent);
    procedure SetOnCustomDrawHeaderCell(Value: TcxTreeListReportLinkCustomDrawHeaderCellEvent);
    procedure SetOnCustomDrawIndentCell(Value: TcxTreeListReportLinkCustomDrawIndentCellEvent);
    procedure SetOptionsExpanding(Value: TcxTreeListReportLinkOptionsExpanding);
    procedure SetOptionsFormatting(Value: TcxTreeListReportLinkOptionsFormatting);    
    procedure SetOptionsOnEveryPage(Value: TcxTreeListReportLinkOptionsOnEveryPage);
    procedure SetOptionsPagination(Value: TcxTreeListReportLinkOptionsPagination);
    procedure SetOptionsPreview(Value: TcxTreeListReportLinkOptionsPreview);
    procedure SetOptionsRefinements(Value: TcxTreeListReportLinkOptionsRefinements);
    procedure SetOptionsSelection(Value: TcxTreeListReportLinkOptionsSelection);
    procedure SetOptionsSize(Value: TcxTreeListReportLinkOptionsSize);
    procedure SetOptionsView(Value: TcxTreeListReportLinkOptionsView);    
    procedure SetStyles(Value: TcxTreeListReportLinkStyles);
  protected
    procedure ConstructReport(AReportCells: TdxReportCells); override;
    procedure ConvertCoords; override;
    procedure CustomDraw(AItem: TAbstractdxReportCellData; ACanvas: TCanvas;
      ABoundsRect, AClientRect: TRect; var ADone: Boolean); override;
    function GetBreakPagesByHardDelimiters: Boolean; override;
    procedure GetImageLists(AProc: TdxPSGetImageListProc); override;
    function GetRebuildOnPageParamsChange(AUpdateCodes: TdxPrinterPageUpdateCodes): Boolean; override;
    function GetUseHardVertDelimiters: Boolean; override;
    procedure InternalRestoreFromOriginal; override;
    function IsDrawFootersOnEveryPage: Boolean; override;
    function IsDrawHeadersOnEveryPage: Boolean; override;
    function IsSupportedCustomDraw(Item: TAbstractdxReportCellData): Boolean; override;
    procedure MakeHardDelimiters(AReportCells: TdxReportCells; AVertDelimiters: TList); override;
      
    function GetAreNativeStylesAvailable: Boolean; override;
    function GetStylesClass: TdxCustomReportLinkStylesClass; override;
    function GetStyleSheetClass: TdxCustomReportLinkStyleSheetClass; override;
    function GetStyleSheetPrototype: TdxCustomReportLinkStyleSheet; override;
    procedure PrepareConstruct; override;

    procedure DoCustomDrawBandCell(ACanvas: TCanvas; ABand: TcxTreeListBand; 
      AnItem: TdxReportCellImage; var ADone: Boolean); dynamic;
    procedure DoCustomDrawCell(ACanvas: TCanvas; ANode: TcxTreeListNode; 
      AColumn: TcxTreeListColumn; AnItem: TAbstractdxReportCellData; 
      var ADone: Boolean); dynamic;
    procedure DoCustomDrawFooterCell(ACanvas: TCanvas; AColumn: TcxTreeListColumn; 
      AnItem: TdxReportCellString; var ADone: Boolean); dynamic;
    procedure DoCustomDrawHeaderCell(ACanvas: TCanvas; AColumn: TcxTreeListColumn; 
      AnItem: TdxReportCellImage; var ADone: Boolean); dynamic;
    procedure DoCustomDrawIndentCell(ACanvas: TCanvas; ANode: TcxTreeListNode; 
      AnIndex: Integer; AnItem: TAbstractdxReportCellData; var ADone: Boolean); dynamic;
    procedure DoGetCustomPageBreaks; dynamic;
    procedure DoInitializeBandCell(ABand: TcxTreeListBand; AnItem: TdxReportCellImage); dynamic;
    procedure DoInitializeCell(ANode: TcxTreeListNode; AColumn: TcxTreeListColumn; AnItem: TAbstractdxReportCellData); dynamic;
    procedure DoInitializeFooterCell( AColumn: TcxTreeListColumn; ASummaryCellIndex: Integer; AnItem: TdxReportCellString); dynamic;
    procedure DoInitializeHeaderCell(AColumn: TcxTreeListColumn; AnItem: TdxReportCellImage); dynamic;
    procedure DoInitializeIndentCell(ANode: TcxTreeListNode; AnIndex: Integer; AnItem: TAbstractdxReportCellData); dynamic;
      
    function GetOptionsExpandingClass: TdxCustomReportLinkOptionsExpandingClass; override;
    function GetOptionsFormattingClass: TdxCustomReportLinkOptionsFormattingClass; override;
    function GetOptionsOnEveryPageClass: TdxCustomTableControlReportLinkOptionsOnEveryPageClass; override;
    function GetOptionsPaginationClass: TdxCustomReportLinkOptionsPaginationClass; override;
    function GetOptionsPreviewClass: TdxCustomTableControlReportLinkOptionsPreviewClass; override;
    function GetOptionsRefinementsClass: TdxCustomReportLinkOptionsRefinementsClass; override;
    function GetOptionsSelectionClass: TdxCustomTableControlReportLinkOptionsSelectionClass; override;
    function GetOptionsSizeClass: TdxCustomReportLinkOptionsSizeClass; override;
    function GetOptionsViewClass: TdxCustomReportLinkOptionsViewClass; override;

    procedure AddReportRow(AReportRow: TdxReportCell);
    procedure AddVerticalHardDelimiter(ADelimiter: TdxReportCell); overload;
    procedure AddVerticalHardDelimiter(ADelimiter: Integer); overload;    

    function CreateBuilder: TcxTreeListReportLinkBuilder; virtual;
    class function GetBuilderClass: TcxTreeListReportLinkBuilderClass; virtual;

    function ExtractIndentIndex(AData: Integer): Integer;
    function GetItemCustomDrawInfo(AnItem: TdxReportVisualItem; 
       out ADrawInfo: TcxTreeListCellCustomDrawInfo): TcxTreeListAttributeID; virtual;
    function IsCustomDrawn(AnAttributeID: TcxTreeListAttributeID): Boolean; virtual;
    function MakeIndentIndex(AnIndex: Integer): DWORD;
    
    property ActiveStyles: TcxTreeListReportLinkStyles read GetActiveStyles;
    property Builder: TcxTreeListReportLinkBuilder read FBuilder;
    property DelimitersHardVert: TList read FDelimitersHardVert;
    property HostInfoServices: TcxTreeListAttributeHostInfoServices read FHostInfoServices;
    property TreeList: TcxCustomTreeList read GetTreeList;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;

    procedure AddPageBreak(ANode: TcxTreeListNode); overload;
    procedure AddPageBreak(const ANodes: array of TcxTreeListNode); overload;
    procedure AddPageBreak(const ANodes: TcxTreeListNodeArray); overload;
    procedure AddPageBreak(ANodes: TList); overload; // List of TcxCustomGridRecord

    property DesignWindow: TdxfmTreeListReportLinkDesignWindow read GetDesignWindow;
    property ReportRows[Index: Integer]: TdxReportCell read GetReportRow;
    property ReportRowsByNode[Node: TcxTreeListNode]: TdxReportCell read GetReportRowByNode;
    property ReportRowCount: Integer read GetReportRowCount;
  published
    property Color;
    property Font;
    property OptionsExpanding: TcxTreeListReportLinkOptionsExpanding read GetOptionsExpanding write SetOptionsExpanding;
    property OptionsFormatting: TcxTreeListReportLinkOptionsFormatting read GetOptionsFormatting write SetOptionsFormatting;
    property OptionsOnEveryPage: TcxTreeListReportLinkOptionsOnEveryPage read GetOptionsOnEveryPage write SetOptionsOnEveryPage;
    property OptionsPagination: TcxTreeListReportLinkOptionsPagination read GetOptionsPagination write SetOptionsPagination;    
    property OptionsPreview: TcxTreeListReportLinkOptionsPreview read GetOptionsPreview write SetOptionsPreview;
    property OptionsRefinements: TcxTreeListReportLinkOptionsRefinements read GetOptionsRefinements write SetOptionsRefinements;
    property OptionsSelection: TcxTreeListReportLinkOptionsSelection read GetOptionsSelection write SetOptionsSelection;
    property OptionsSize: TcxTreeListReportLinkOptionsSize read GetOptionsSize write SetOptionsSize;
    property OptionsView: TcxTreeListReportLinkOptionsView read GetOptionsView write SetOptionsView;
    property ScaleFonts;
    property StyleRepository;
    property Styles: TcxTreeListReportLinkStyles read GetStyles write SetStyles;
    property SupportedCustomDraw;

    property OnCustomDrawBandCell: TcxTreeListReportLinkCustomDrawBandCellEvent read FOnCustomDrawBandCell 
      write SetOnCustomDrawBandCell;
    property OnCustomDrawCell: TcxTreeListReportLinkCustomDrawCellEvent read FOnCustomDrawCell 
      write SetOnCustomDrawCell;
    property OnCustomDrawFooterCell: TcxTreeListReportLinkCustomDrawFooterCellEvent read FOnCustomDrawFooterCell 
      write SetOnCustomDrawFooterCell;
    property OnCustomDrawHeaderCell: TcxTreeListReportLinkCustomDrawHeaderCellEvent read FOnCustomDrawHeaderCell 
      write SetOnCustomDrawHeaderCell;
    property OnCustomDrawIndentCell: TcxTreeListReportLinkCustomDrawIndentCellEvent read FOnCustomDrawIndentCell 
      write SetOnCustomDrawIndentCell;
    property OnGetCustomPageBreaks: TcxTreeListReportLinkGetCustomPageBreaksEvent read FOnGetCustomPageBreaks write FOnGetCustomPageBreaks;
    property OnInitializeBandCell: TcxTreeListReportLinkInitializeBandCellEvent read FOnInitializeBandCell 
      write FOnInitializeBandCell;
    property OnInitializeCell: TcxTreeListReportLinkInitializeCellEvent read FOnInitializeCell 
      write FOnInitializeCell;
    property OnInitializeFooterCell: TcxTreeListReportLinkInitializeFooterCellEvent read FOnInitializeFooterCell 
      write FOnInitializeFooterCell;
    property OnInitializeHeaderCell: TcxTreeListReportLinkInitializeHeaderCellEvent read FOnInitializeHeaderCell 
      write FOnInitializeHeaderCell;
    property OnInitializeIndentCell: TcxTreeListReportLinkInitializeIndentCellEvent read FOnInitializeIndentCell
      Write FOnInitializeIndentCell;
  end;

  TcxTreeListReportLink = class(TcxTreeListCustomReportLink)
  private
    function GetTreeList: TcxTreeList;
  public
    property TreeList: TcxTreeList read GetTreeList;
  end;

  TcxDBTreeListReportLink = class(TcxTreeListCustomReportLink)
  private
    function GetDBTreeList: TcxDBTreeList;
  public
    property DBTreeList: TcxDBTreeList read GetDBTreeList;
  end;

  TcxVirtualTreeListReportLink = class(TcxTreeListCustomReportLink)
  private
    function GetVirtualTreeList: TcxVirtualTreeList;
  public
    property VirtualTreeList: TcxVirtualTreeList read GetVirtualTreeList;
  end;
    
  TdxfmTreeListReportLinkDesignWindow = class(TdxfmCustomcxControlReportLinkDesignWindow)
    PageControl1: TPageControl;
    tshView: TTabSheet;
    lblShow: TLabel;
    imgShow: TImage;
    bvlShow: TBevel;
    lblOnEveryPage: TLabel;
    imgOnEveryPage: TImage;
    bvlOnEveryPage: TBevel;
    bvlWarningHost: TBevel;
    chbxShowBands: TCheckBox;
    chbxShowHeaders: TCheckBox;
    chbxShowFooters: TCheckBox;
    chbxShowExpandButtons: TCheckBox;
    chbxBandsOnEveryPage: TCheckBox;
    chbxHeadersOnEveryPage: TCheckBox;
    chbxFootersOnEveryPage: TCheckBox;
    chbxShowTreeLines: TCheckBox;
    tshBehaviors: TTabSheet;
    tshFormatting: TTabSheet;
    lblLookAndFeel: TLabel;
    bvlLookAndFeel: TBevel;
    imgLookAndFeel: TImage;
    imgRefinements: TImage;
    lblRefinements: TLabel;
    bvlRefinements: TBevel;
    cbxLookAndFeel: TComboBox;
    chbxFlatCheckMarks: TCheckBox;
    chbxDisplayGraphicsAsText: TCheckBox;
    chbxTransparentGraphics: TCheckBox;
    tshPreview: TTabSheet;
    lblPreviewOptions: TLabel;
    bvlPreviewOptions: TBevel;
    lblPreviewMaxLineCount: TLabel;
    bvlPreviewMaxLineCountHost: TBevel;
    imgPreview: TImage;
    chbxPreviewVisible: TCheckBox;
    chbxPreviewAutoHeight: TCheckBox;
    pnlPreview: TPanel;
    cxStyleRepository1: TcxStyleRepository;
    styleBandHeaders: TcxStyle;
    styleStandard: TcxStyle;
    stylePreview: TcxStyle;
    styleCardShadow: TcxStyle;
    chbxSuppressBackgroundBitmaps: TCheckBox;
    tshStyles: TTabSheet;
    bvlStyles: TBevel;
    bvlStyleSheets: TBevel;
    lblStyleSheets: TLabel;
    btnStyleColor: TButton;
    btnStyleFont: TButton;
    btnStyleBackgroundBitmap: TButton;
    chbxUseNativeStyles: TCheckBox;
    cbxStyleSheets: TComboBox;
    btnStyleSheetNew: TButton;
    btnStyleSheetCopy: TButton;
    btnStyleSheetDelete: TButton;
    btnStylesSaveAs: TButton;
    btnStyleSheetRename: TButton;
    pmStyles: TPopupMenu;
    miStyleFont: TMenuItem;
    miStyleColor: TMenuItem;
    miStyleBackgroundBitmap: TMenuItem;
    milLine: TMenuItem;
    miStylesSaveAs: TMenuItem;
    btnStyleBackgroundBitmapClear: TButton;
    btnStyleRestoreDefaults: TButton;
    miLine2: TMenuItem;
    miLine3: TMenuItem;
    miStyleBackgroundBitmapClear: TMenuItem;
    miStyleRestoreDefaults: TMenuItem;
    bvlStylesHost: TBevel;
    ilStylesPopup: TImageList;
    PreviewTreeList: TcxTreeList;
    colManufacturerName: TcxTreeListColumn;
    colManufacturerLogo: TcxTreeListColumn;
    colManufacturerCountry: TcxTreeListColumn;
    colCarModel: TcxTreeListColumn;
    colCarIsSUV: TcxTreeListColumn;
    chbxShowBorders: TCheckBox;
    miStylesSelectAll: TMenuItem;
    miLine4: TMenuItem;
    chbxConsumeSelectionStyle: TCheckBox;
    bvlRefinementsSeparator: TBevel;
    Bevel2: TBevel;
    pnlBehaviors: TPanel;
    pnlSelection: TPanel;
    lblSelection: TLabel;
    imgSelection: TImage;
    bvlSelection: TBevel;
    chbxProcessSelection: TCheckBox;
    chbxProcessExactSelection: TCheckBox;
    pnlExpanding: TPanel;
    lblExpanding: TLabel;
    imgExpanding: TImage;
    bvlExpanding: TBevel;
    chbxExpandNodes: TCheckBox;
    pnlSize: TPanel;
    lblSize: TLabel;
    bvlSize: TBevel;
    imgGridSize: TImage;
    chbxAutoWidth: TCheckBox;
    pnlSeparators: TPanel;
    lblSeparators: TLabel;
    bvlSeparator: TBevel;
    lblSeparatorsThickness: TLabel;
    lblSeparatorsColor: TLabel;
    bvlSeparatorThicknessHost: TBevel;
    bvlSeparatorColorHost: TBevel;
    imgSeparators: TImage;
    chbxExplicitlyExpandNodes: TCheckBox;
    lblPreviewWindow: TStaticText;
    Label1: TLabel;
    lblUseNativeStyles: TLabel;
    procedure LookAndFeelChange(Sender: TObject);
    procedure OptionsRefinementsClick(Sender: TObject);
    procedure PreviewVisibleClick(Sender: TObject);
    procedure PreviewAutoHeightClick(Sender: TObject);
    procedure OptionsSelectionClick(Sender: TObject);
    procedure OptionsExpandingClick(Sender: TObject);
    procedure OptionsViewClick(Sender: TObject);
    procedure OptionsOnEveryPageClick(Sender: TObject);
    procedure OptionsSizeClick(Sender: TObject);
    procedure OptionsFormattingClick(Sender: TObject);
    procedure pmStylesPopup(Sender: TObject);
    procedure StyleColorClick(Sender: TObject);
    procedure StyleFontClick(Sender: TObject);
    procedure StyleBackgroundBitmapClick(Sender: TObject);
    procedure cbxStyleSheetsClick(Sender: TObject);
    procedure btnStyleSheetNewClick(Sender: TObject);
    procedure btnStyleSheetCopyClick(Sender: TObject);
    procedure btnStyleSheetDeleteClick(Sender: TObject);
    procedure btnStyleSheetRenameClick(Sender: TObject);
    procedure StylesSaveAsClick(Sender: TObject);
    procedure cbxStyleSheetsKeyDown(Sender: TObject; var Key: Word; 
      Shift: TShiftState);
    procedure lbxStylesClick(Sender: TObject);
    procedure StyleBackgroundBitmapClearClick(Sender: TObject);
    procedure StyleRestoreDefaultsClick(Sender: TObject);
    procedure miStylesSelectAllClick(Sender: TObject);
    procedure PageControl1Change(Sender: TObject);
    procedure cbxStyleSheetsDrawItem(Control: TWinControl; Index: Integer;
      Rect: TRect; State: TOwnerDrawState);
    procedure lblUseNativeStylesClick(Sender: TObject);
    procedure PreviewTreeListCustomDrawBandHeaderCell(
      Sender: TcxCustomTreeList; ACanvas: TcxCanvas;
      AViewInfo: TcxTreeListHeaderCellViewInfo; var ADone: Boolean);
    procedure PreviewTreeListCustomDrawDataCell(Sender: TcxCustomTreeList;
      ACanvas: TcxCanvas; AViewInfo: TcxTreeListEditCellViewInfo;
      var ADone: Boolean);
    procedure PreviewTreeListCustomDrawFooterCell(
      Sender: TcxCustomTreeList; ACanvas: TcxCanvas;
      AViewInfo: TcxTreeListFooterCellViewInfo; var ADone: Boolean);
    procedure PreviewTreeListCustomDrawHeaderCell(
      Sender: TcxCustomTreeList; ACanvas: TcxCanvas;
      AViewInfo: TcxTreeListHeaderCellViewInfo; var ADone: Boolean);
  private
    lbxStyles: TdxStylesListBox;
    sePreviewMaxLineCount: TdxPSSpinEdit;
    seSeparatorThickness: TdxPSSpinEdit;
    ccbxSeparatorColor: TdxPSColorCombo;
    wpIncorrectOnEveryPageState: TdxPSWarningPane;
    
    function GetActiveStyle: TcxStyle;
    function GetHasSelectedStyles: Boolean;
    function GetHasSelectedStylesWithAssignedBitmap: Boolean;
    function GetReportLink: TcxTreeListCustomReportLink;
    
    procedure PreviewMaxLineCountChanged(Sender: TObject);
    procedure SeparatorColorChanged(Sender: TObject);
    procedure SeparatorThicknessChanged(Sender: TObject);
    
    function CanSelectAllStyles: Boolean;
    procedure CreateControls;
    procedure CustomDrawBorders(ACanvas: TcxCanvas; const R: TRect);
    procedure CustomDrawCheckMark(ACanvas: TcxCanvas; AViewInfo: TcxTreeListEditCellViewInfo);
    procedure CustomDrawFooter(ACanvas: TcxCanvas; R: TRect; AViewInfo: TcxTreeListFooterCellViewInfo);
    procedure CustomDrawHeader(ACanvas: TcxCanvas; R: TRect; AViewInfo: TcxTreeListHeaderCellViewInfo);
    procedure CustomDrawTextRect(ACanvas: TcxCanvas; R: TRect; const AText: string; 
      AnAlignmentHorz: TAlignment; AnAlignmentVert: TcxAlignmentVert; AParams: TcxViewParams);
    function ExtractAlignmentHorz(AViewInfo: TcxTreeListEditCellViewInfo): TAlignment;
    function ExtractAlignmentVert(AViewInfo: TcxTreeListEditCellViewInfo): TcxAlignmentVert;
    procedure InitializePreviewTreeList;
    procedure InitializePreviewTreeListStyles;
    procedure LoadDataIntoPreviewTreeList;
    procedure RecreateStylesListBox;
    procedure RestoreSelectedStyles(AList: TList);
    procedure SaveSelectedStyles(AList: TList);
    procedure SetActivePage;
    procedure UpdatePreviewTreeListStyles(const ACaption: string; AStyle: TcxStyle);
    procedure WarningPaneUpdate;
    
    procedure SetOptionsExpandingByIndex(Index: Integer; Value: Boolean);
    procedure SetOptionsFormattingByIndex(Index: Integer; Value: Boolean);
    procedure SetOptionsOnEveryPageByIndex(Index: Integer; Value: Boolean);
    procedure SetOptionsRefinementsByIndex(Index: Integer; Value: Boolean);
    procedure SetOptionsSelectionByIndex(Index: Integer; Value: Boolean);
    procedure SetOptionsSizeByIndex(Index: Integer; Value: Boolean);
    procedure SetOptionsViewByIndex(Index: Integer; Value: Boolean);
  protected
    procedure DoInitialize; override;
    {$IFDEF DELPHI7}
    function GetPreviewHost: TCustomPanel; override;
    {$ENDIF}
    procedure LoadStrings; override;
    procedure UpdateControlsState; override;
    procedure UpdatePreview; override;

    function GetDesignerTabIndex: Integer; override;
    procedure SetDesignerTabIndex(Value: Integer); override;
   
    procedure DoActiveStyleSheetChanged; override;
    procedure DoFormActivated(AnActive: Boolean); override;
    procedure DoRefreshStylesList; override;
    procedure DoStyleChanged(const ACaption: string; AStyle: TcxStyle); override;
    procedure DoStylesChanged(AStrings: TStrings; ARecreate: Boolean); override;

    procedure GetSelectedStyleNames(AStrings: TStrings); override;
    procedure GetStyleNames(out AStrings: TStrings); override;
    procedure GetStyleSheetNames(out AStrings: TStrings); override;

    property ActiveStyle: TcxStyle read GetActiveStyle;
    property HasSelectedStyles: Boolean read GetHasSelectedStyles;
    property HasSelectedStylesWithAssignedBitmap: Boolean read GetHasSelectedStylesWithAssignedBitmap;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    property ReportLink: TcxTreeListCustomReportLink read GetReportLink;
  end;

const
  dxPSDefaultTreeListNodeSeparatorColor: TColor = clBtnShadow;
  
implementation

{$R *.dfm}

{ 634x420 - DesignWindow }
{.3 - chbxTransparentRichEdits }

uses
 {$IFDEF DELPHI6} 
  Variants, 
 {$ENDIF} Forms, Registry, dxThemeManager, cxDataStorage, cxDataUtils,
  cxImage, cxCheckBox, dxPSGlbl, dxPSRes, dxPSImgs, cxDrawTextUtils, dxPSPopupMan, 
  dxPSUtl, dxBkgnd, Math;
     
const
  CellSidesMap: array[TcxTreeListGridLines] of TdxCellSides = ([], csTopBottom, csLeftRight, csAll);
  SortOrderMap: array[TcxDataSortOrder] of TdxCellSortOrder = (csoNone, csoUp, csoDown);  
  TreeLinesStyleMap: array[TcxTreeListTreeLineStyle] of TdxPSTreeLineStyle = (tlsDot, tlsDot, tlsSolid);
  
  DefaultDataRowLineHeight = 19;
  DefaultExpandButtonSize = 9;
  DefaultIndentWidth = 15;
  ExpandButtonInteriorColors: array[Boolean] of TColor = (clWindow, clBtnShadow);
  FooterItemInflateHorz = 2;
  FooterItemInflateVert = 3;

  NodeIndentMask   = $00000FF0;
  NodeIndentOffset = $00000004;

var
  FDefaultdxPScxTreeListLinkStyleSheet: TcxTreeListReportLinkStyleSheet;

type
  TcxTreeListNodeHelperFactory = class(TdxCustomClassMaps)
  private
    function GetHelperClass(Node: TcxTreeListNode): TcxTreeListNodeHelperClass;
  public
    class function Instance: TcxTreeListNodeHelperFactory; reintroduce; overload; 
    property HelperClasses[Node: TcxTreeListNode]: TcxTreeListNodeHelperClass read GetHelperClass; default;
  end;

 
  TcxCustomTreeListAccess = class(TcxCustomTreeList);
  TcxTreeListColumnAccess = class(TcxTreeListColumn);
  TcxTreeListBandAccess = class(TcxTreeListBand);

{ Helpers }

{ CustomTreeList Helpers }

function CustomTreeList_DoIsGroupNode(AInstance: TcxCustomTreeList; ANode: TcxTreeListNode): Boolean;
begin
  Result := TcxCustomTreeListAccess(AInstance).DoIsGroupNode(ANode);
end;

function CustomTreeList_GetImages(AInstance: TcxCustomTreeList): TCustomImageList;
begin
  Result := TcxCustomTreeListAccess(AInstance).Images;
end;

function CustomTreeList_GetLookAndFeel(AInstance: TcxCustomTreeList): TcxLookAndFeel;
begin
  Result := TcxCustomTreeListAccess(AInstance).LookAndFeel;
end;

function CustomTreeList_GetLookAndFeelPainter(AInstance: TcxCustomTreeList): TcxCustomLookAndFeelPainterClass;
begin
  Result := TcxCustomTreeListAccess(AInstance).LookAndFeelPainter;
end;

function CustomTreeList_GetOptionsSelection(AInstance: TcxCustomTreeList): TcxTreeListOptionsSelection;
begin
  Result := TcxCustomTreeListAccess(AInstance).OptionsSelection;
end;

function CustomTreeList_GetOptionsView(AInstance: TcxCustomTreeList): TcxTreeListOptionsView;
begin
  Result := TcxCustomTreeListAccess(AInstance).OptionsView;
end;

function CustomTreeList_GetPreview(AInstance: TcxCustomTreeList): TcxTreeListPreview;
begin
  Result := TcxCustomTreeListAccess(AInstance).Preview;
end;

function CustomTreeList_GetStateImages(AInstance: TcxCustomTreeList): TCustomImageList;
begin
  Result := TcxCustomTreeListAccess(AInstance).StateImages;
end;

function CustomTreeList_GetStyles(AInstance: TcxCustomTreeList): TcxTreeListStyles;
begin
  Result := TcxCustomTreeListAccess(AInstance).Styles;
end;

function CustomTreeList_GetVisibleBand(AInstance: TcxCustomTreeList; 
  Index: Integer): TcxTreeListBand;
begin
  Result := TcxCustomTreeListAccess(AInstance).Bands.VisibleItems[Index];
end;

function CustomTreeList_GetVisibleBandCount(AInstance: TcxCustomTreeList): Integer;
begin
  Result := TcxCustomTreeListAccess(AInstance).Bands.VisibleItemCount;
end;

function CustomTreeList_GetVisibleColumn(AInstance: TcxCustomTreeList; 
  Index: Integer): TcxTreeListColumn;
begin
  Result := TcxCustomTreeListAccess(AInstance).VisibleColumns[Index];
end;

function CustomTreeList_GetVisibleColumnCount(AInstance: TcxCustomTreeList): Integer;
begin
  Result := TcxCustomTreeListAccess(AInstance).VisibleColumnCount;
end;
  
{ TreeListColumn Helpers }

function TreeListColumn_DoGetEditProperties(AInstance: TcxTreeListColumn; 
  ANode: TcxTreeListNode): TcxCustomEditProperties; 
begin
  Result := TcxTreeListColumnAccess(AInstance).DoGetEditProperties(ANode);
end;

{ Utilities }
 
function DefaultdxPScxTreeListLinkStyleSheet: TcxTreeListReportLinkStyleSheet;

  function CreateStyle(AColor: TColor; AFontColor: TColor): TcxStyle;
  begin
    Result := TcxStyle.Create(DefaultdxPScxTreeListLinkStyleSheet);
    with Result do
    begin
      Color := AColor;
      Font.Name := dxPSCore.dxPSDefaultFontName;
      Font.Color := AFontColor;
    end;
  end;
  
begin
  if FDefaultdxPScxTreeListLinkStyleSheet = nil then 
  begin
    FDefaultdxPScxTreeListLinkStyleSheet := TcxTreeListReportLinkStyleSheet.Create(nil);
    with FDefaultdxPScxTreeListLinkStyleSheet.Styles as TcxTreeListReportLinkStyles do
    begin
      BandHeader := CreateStyle(dxPSCore.dxDefaultFixedColor, dxPSCore.dxPSDefaultFontColor);
      Content := CreateStyle(dxPSCore.dxDefaultContentColor, dxPSCore.dxPSDefaultFontColor);
      ContentEven := CreateStyle(dxPSCore.dxDefaultContentColor, dxPSCore.dxPSDefaultFontColor);
      ContentOdd := CreateStyle(dxPSCore.dxDefaultContentColor, dxPSCore.dxPSDefaultFontColor);
      Footer := CreateStyle(dxPSCore.dxDefaultFixedColor, dxPSCore.dxPSDefaultFontColor);
      FooterRow := CreateStyle(dxPSCore.dxDefaultFixedColor, dxPSCore.dxPSDefaultFontColor);
      Header := CreateStyle(dxPSCore.dxDefaultFixedColor, dxPSCore.dxPSDefaultFontColor);
      Preview := CreateStyle(dxPSCore.dxDefaultContentColor, dxPSCore.dxPSDefaultFontColor);
      Selection := CreateStyle(dxPSCore.dxDefaultFixedColor, dxPSCore.dxPSDefaultFontColor);
    end;
  end;
  Result := FDefaultdxPScxTreeListLinkStyleSheet;
end;

function IsValidPointer(const AData: Integer): Boolean;
begin
  //Result := (HInstance = 0) or (FindHInstance(Pointer(AData)) = HInstance);
  Result := DWORD(AData) > HInstance;
end;

{ TcxTreeListNodeHelperFactory }

function cxTreeListNodeHelperFactory: TcxTreeListNodeHelperFactory;
begin
  Result := TcxTreeListNodeHelperFactory.Instance;
end;

class function TcxTreeListNodeHelperFactory.Instance: TcxTreeListNodeHelperFactory;
begin
  Result := inherited Instance as TcxTreeListNodeHelperFactory;
end;

function TcxTreeListNodeHelperFactory.GetHelperClass(Node: TcxTreeListNode): TcxTreeListNodeHelperClass;
begin
  Result := TcxTreeListNodeHelperClass(PairClasses[Node.ClassType]);
end;

{ CLR Accessors }

  
{ TcxTreeListReportLinkRowProducer }

constructor TcxTreeListReportLinkRowProducer.Create(ABuilder: TcxTreeListReportLinkBuilder);
begin
  inherited Create;
  FBuilder := ABuilder;
end;

function TcxTreeListReportLinkRowProducer.Adapter: TcxTreeListAdapter;
begin
  Result := Builder.Adapter;
end;

function TcxTreeListReportLinkRowProducer.Builder: TcxTreeListReportLinkBuilder;
begin
  Result := FBuilder;
end;

function TcxTreeListReportLinkRowProducer.Formatter: TcxTreeListReportLinkFormatter;
begin
  Result := Builder.Formatter;
end;

function TcxTreeListReportLinkRowProducer.Produce(AHostInfo: TcxTreeListAttributeHostInfo): TdxReportCell;
begin
  CalculateRowHeight;
  
  CreateRowHost(AHostInfo);
  CreateRow;

  if AutoHeight then 
  begin
    CalculateRowAutoHeight;
    FixupRowHeight;
  end;
  AfterCalculateRowHeight;
  
  Inc(AHostInfo.Origin.Y, RowHeight);
  Result := Host;
end;

procedure TcxTreeListReportLinkRowProducer.AfterCalculateRowHeight;
begin
end;

procedure TcxTreeListReportLinkRowProducer.CalculateRowAutoHeight;
var
  DC: HDC;
  MaxRowHeight, I, V: Integer;
  Item: TdxReportVisualItem;
begin
  DC := Self.DC;
  MaxRowHeight := 0;
  for I := 0 to Row.DataItemCount - 1 do 
  begin
    Item := Row.DataItems[I];
    if DoesItemParticipateInRowAutoHeightCalculation(Item) then
    begin
      V := Item.MeasureContentHeight(DC);
      if MaxRowHeight < V then MaxRowHeight := V;
    end;   
  end;  
  // v3.1
  for I := 0 to Row.CellCount - 1 do 
  begin
    Item := Row.Cells[I];
    if DoesItemParticipateInRowAutoHeightCalculation(Item) then
    begin
      V := Item.MeasureContentHeight(DC);
      if MaxRowHeight < V then MaxRowHeight := V;
    end;   
  end;  
  if RowHeight < MaxRowHeight then
    RowHeight := MaxRowHeight;
end;

procedure TcxTreeListReportLinkRowProducer.CalculateRowHeight;
begin
  FRowHeight := LineCount * LineHeight;
end;

procedure TcxTreeListReportLinkRowProducer.CreateRow;
begin
  FRow := TdxReportCell.Create(Host);
  FRow.BoundsRect := MakeBounds(0, 0, RowWidth, RowHeight);
  InitializeRow;
end;

procedure TcxTreeListReportLinkRowProducer.CreateRowHost(const AHostInfo: TcxTreeListAttributeHostInfo);
begin
  FHost := TdxReportCell.Create(AHostInfo.Parent);
  FHost.BoundsRect := MakeBounds(AHostInfo.Origin.X, AHostInfo.Origin.Y, RowWidth, RowHeight);
  Formatter.DoInitializeHost(Host);
end;

function TcxTreeListReportLinkRowProducer.DoesItemParticipateInRowAutoHeightCalculation(
  AnItem: TdxReportVisualItem): Boolean;
begin
  Result := True;
end;

procedure TcxTreeListReportLinkRowProducer.FixupRowDataHeight;  
var
  I: Integer;
begin
  for I := 0 to Row.DataItemCount - 1 do 
    Row.DataItems[I].Height := RowHeight;
  // v3.1
  for I := 0 to Row.CellCount - 1 do 
    Row.Cells[I].Height := RowHeight;
end;

procedure TcxTreeListReportLinkRowProducer.FixupRowHeight;
begin
  FixupRowItselfHeight;
  FixupRowDataHeight;  
end;

procedure TcxTreeListReportLinkRowProducer.FixupRowItselfHeight;
begin
  Host.Height := RowHeight;
  Row.Height := RowHeight;
end;
    
procedure TcxTreeListReportLinkRowProducer.InitializeRow;
begin
end;

function TcxTreeListReportLinkRowProducer.GetAutoHeight: Boolean;
begin
  Result := LineCount = 1;
end;

function TcxTreeListReportLinkRowProducer.GetLineCount: Integer;
begin
  Result := 1;
end;

function TcxTreeListReportLinkRowProducer.GetLineHeight: Integer;
begin
  Result := 20;
end;

function TcxTreeListReportLinkRowProducer.GetDC: HDC;
begin
  Result := Formatter.DC;
end;

function TcxTreeListReportLinkRowProducer.GetIndentWidth: Integer;
begin
  Result := Adapter.IndentWidth;
end;

function TcxTreeListReportLinkRowProducer.GetRowWidth: Integer;
begin
  Result := Formatter.ViewWidth;
end;

{ TcxTreeListReportLinkNodeSeparatorProducer }

function TcxTreeListReportLinkNodeSeparatorProducer.Produce(AHostInfo: TcxTreeListAttributeHostInfo): TdxReportCell;
begin
  Result := inherited Produce(AHostInfo);
  FItem := GetItemClass.Create(Row);
  FItem.BoundsRect := MakeRect(0, 0, RowWidth, RowHeight);
  InitializeItem;
end;
    
procedure TcxTreeListReportLinkNodeSeparatorProducer.InitializeItem;
begin
  Formatter.DoInitializeNodeSeparator(FItem);
end;

procedure TcxTreeListReportLinkNodeSeparatorProducer.InitializeRow;
begin
  Formatter.DoInitializeNodeSeparatorRow(Row);
end;

function TcxTreeListReportLinkNodeSeparatorProducer.GetAutoHeight: Boolean;
begin
  Result := False;
end;

function TcxTreeListReportLinkNodeSeparatorProducer.GetItemClass: TdxReportCellDataClass;
begin
  Result := Formatter.GetNodeSeparatorClass;
end;

function TcxTreeListReportLinkNodeSeparatorProducer.GetLineHeight: Integer;
begin
  Result := Formatter.NodeSeparatorThickness;
end;

{ TcxTreeListReportLinkRowSubItemsProducer }

procedure TcxTreeListReportLinkRowSubItemsProducer.CreateDataItems(AParent: TdxReportCell);
var
  I: Integer;
  AItem: TAbstractdxReportCellData;
begin
  for I := 0 to SubItemCount - 1 do
    if HasSubItem[I] then
    begin
      AItem := SubItemClasses[I].Create(AParent);
      AItem.BoundsRect := SubItemBounds[I];
      InitializeSubItem(AItem, I);
    end;
end;

procedure TcxTreeListReportLinkRowSubItemsProducer.CreateRow;
begin
  inherited CreateRow;
  CreateDataItems(Row);
end;

procedure TcxTreeListReportLinkRowSubItemsProducer.InitializeSubItem(ASubItem: TAbstractdxReportCellData; 
  AnIndex: Integer);
begin
end;

function TcxTreeListReportLinkRowSubItemsProducer.GetHasSubItem(Index: Integer): Boolean;
begin
  Result := True;
end;

function TcxTreeListReportLinkRowSubItemsProducer.GetSubItemBound(Index: Integer): TRect;
begin
  Result := MakeRect(0, 0, -1, -1);
end;

function TcxTreeListReportLinkRowSubItemsProducer.GetSubItemCount: Integer;
begin
  Result := Formatter.ColumnCount;
end;

function TcxTreeListReportLinkRowSubItemsProducer.GetColumn(Index: Integer): TcxTreeListColumn;
begin
  Result := Formatter.Columns[Index];
end;

{ TcxTreeListReportLinkBandsProducer }

function TcxTreeListReportLinkBandsProducer.GetSubItemCount: Integer;
begin
  Result := Formatter.BandCount;
end;

procedure TcxTreeListReportLinkBandsProducer.CalculateRowHeight;
begin
  FRowHeight := Formatter.ItemPlaceController.Height;
end;

procedure TcxTreeListReportLinkBandsProducer.InitializeRow;
begin
  inherited;
  Formatter.DoInitializeBandRow(Row);
end;

procedure TcxTreeListReportLinkBandsProducer.InitializeSubItem(ASubItem: TAbstractdxReportCellData; 
  AnIndex: Integer);
begin
  inherited;
  Formatter.DoInitializeBandItem(ASubItem, AnIndex);
  Formatter.DoReportLinkInitializeBandItem(ASubItem, AnIndex);
end;

function TcxTreeListReportLinkBandsProducer.GetAutoHeight: Boolean;
begin
  Result := False;
end;

function TcxTreeListReportLinkBandsProducer.GetSubItemBound(Index: Integer): TRect;
begin
  Result := Formatter.GetBandItemBounds(Index);
end;

function TcxTreeListReportLinkBandsProducer.GetSubItemClass(Index: Integer): TdxReportCellDataClass; 
begin
  Result := Formatter.GetBandItemClass(Index);
end;

{ TcxTreeListReportLinkBandedProducer }

constructor TcxTreeListReportLinkBandedRowProducer.Create(ABuilder: TcxTreeListReportLinkBuilder);
begin
  inherited Create(ABuilder);
  FIndents := TList.Create;
end;

destructor TcxTreeListReportLinkBandedRowProducer.Destroy;
begin
  FIndents.Free;
  inherited Destroy;
end;

function TcxTreeListReportLinkBandedRowProducer.Produce(AHostInfo: TcxTreeListAttributeHostInfo): TdxReportCell;
begin
  FIndents.Clear;
  Result := inherited Produce(AHostInfo);
end;

procedure TcxTreeListReportLinkBandedRowProducer.AfterCalculateRowHeight;
begin
  CreateIndentsRow(Row);
end;

procedure TcxTreeListReportLinkBandedRowProducer.CreateBandedDataItems(AParent: TdxReportCell);
var
  I: Integer;
  ABandPlace: TcxTreeListCustomBandPlace;
  AColumnPlace: TcxTreeListColumnPlace;
  AItem: TAbstractdxReportCellData;
begin
  ABandPlace := TcxTreeListCustomBandPlace(AParent.Data);
  for I := 0 to ABandPlace.ItemCount - 1 do
  begin
    AColumnPlace := ABandPlace.Items[I];
    AItem := GetBandedDataItemClass(AColumnPlace).Create(AParent);
    AItem.Data := Integer(AColumnPlace);
    AItem.BoundsRect := GetBandedDataItemBounds(AItem);
    InitializeBandedDataItem(AItem);
  end;
end;

procedure TcxTreeListReportLinkBandedRowProducer.CreateBandedRows(AParent: TdxReportCell);
var
  I: Integer;
  ABandPlace: TcxTreeListCustomBandPlace;
  ARow: TdxReportCell;
  ABandRowBounds: TRect;
begin
  for I := 0 to Formatter.ItemPlaceController.BottomItemCount - 1 do
  begin
    ABandPlace := Formatter.ItemPlaceController.BottomItems[I];
    ARow := TdxReportCell.Create(AParent);
    ARow.Data := Integer(ABandPlace);
    ABandRowBounds := MakeBounds(ABandPlace.LeftBound, 0, ABandPlace.Width, RowHeight);
    if ABandPlace.Band.ActuallyExpandable then
      Inc(ABandRowBounds.Left, GetBandedRowIndent);
    ARow.BoundsRect := ABandRowBounds;
    InitializeBandedRow(ARow);
    CreateBandedDataItems(ARow);
  end;
end;

procedure TcxTreeListReportLinkBandedRowProducer.CreateIndents(AParent: TdxReportCell);
var
  I: Integer;
  AIndentCell: TdxReportCellExpandButton;
begin
  for I := 0 to IndentCount - 1 do
  begin
    AIndentCell := Formatter.GetNodeIndentClass.Create(AParent);
    AIndentCell.BoundsRect := IndentBounds[I];
    InitializeIndent(AIndentCell, I);
    FIndents.Add(AIndentCell);
  end;
end;

procedure TcxTreeListReportLinkBandedRowProducer.CreateIndentsRow(AParent: TdxReportCell);
var
  AIndentsRow: TdxReportCell;
  ABandPlace: TcxTreeListCustomBandPlace;
begin
  ABandPlace := Formatter.ItemPlaceController.ItemsByBand[Adapter.TreeList.Bands.ExpandableBand];
  AIndentsRow := TdxReportCell.Create(AParent);
  AIndentsRow.CellSides := [];
  AIndentsRow.BoundsRect := MakeBounds(ABandPlace.LeftBound, 0, GetBandedRowIndent, RowHeight);
  CreateIndents(AIndentsRow);
end;

procedure TcxTreeListReportLinkBandedRowProducer.CreateRow;
begin
  inherited CreateRow;
  CreateBandedRows(Row);
end;

function TcxTreeListReportLinkBandedRowProducer.GetBandedDataItemBounds(
  AItem: TAbstractdxReportCellData): TRect;
begin
  Result := dxPSGlbl.NullRect;
end;

function TcxTreeListReportLinkBandedRowProducer.GetBandedDataItemClass(
  AColumnPlace: TcxTreeListColumnPlace): TdxReportCellDataClass;
begin
  Result := nil;
end;

function TcxTreeListReportLinkBandedRowProducer.GetBandedRowIndent: Integer;
begin
  Result := 0;
end;

function TcxTreeListReportLinkBandedRowProducer.GetIndentArea: Integer;
begin
  Result := IndentCount * IndentWidth;
end;

function TcxTreeListReportLinkBandedRowProducer.GetIndentBound(AIndex: Integer): TRect;
begin
  Result := MakeBounds(IndentWidth * AIndex, 0, IndentWidth, RowHeight);
end;

function TcxTreeListReportLinkBandedRowProducer.GetIndentCount: Integer;
begin
  Result := 0;
end;

procedure TcxTreeListReportLinkBandedRowProducer.InitializeBandedDataItem(
  AItem: TAbstractdxReportCellData);
begin
end;

procedure TcxTreeListReportLinkBandedRowProducer.InitializeBandedRow(
  ARow: TdxReportCell);
begin
end;

procedure TcxTreeListReportLinkBandedRowProducer.InitializeIndent(AnIndent: TdxReportCellExpandButton; AnIndex: Integer);
begin
end;

function TcxTreeListReportLinkBandedRowProducer.GetIndent(Index: Integer): TdxReportCellExpandButton;
begin
  Result := FIndents[Index];
end;

{ TcxTreeListReportLinkFootersProducer }

function TcxTreeListReportLinkFootersProducer.Produce(AHostInfo: TcxTreeListAttributeHostInfo;
  AAttachedNode, ADataNode: TcxTreeListNode): TdxReportCell;
begin
  FAttachedNode := AAttachedNode;
  FDataNode := ADataNode;
  Result := inherited Produce(AHostInfo);
  FDataNode := nil;
  FAttachedNode := nil;
end;

procedure TcxTreeListReportLinkFootersProducer.CreateBandedDataItems(AParent: TdxReportCell);
var
  I, ACellIndex: Integer;
  AItem: TAbstractdxReportCellData;
  AColumnPlace: TcxTreeListColumnPlace;
  ABandPlace: TcxTreeListCustomBandPlace;
begin
  ABandPlace := TcxTreeListCustomBandPlace(AParent.Data);
  for I := 0 to ABandPlace.ItemCount - 1 do
  begin
    AColumnPlace := ABandPlace.Items[I];
    for ACellIndex := 0 to Formatter.GetFooterCellCount(AColumnPlace.Column, FDataNode) - 1 do
    begin
      AItem := TdxReportCellString.Create(AParent);
      AItem.BoundsRect := cxRectOffset(Formatter.GetFooterCellBounds(AColumnPlace.Column,
        ACellIndex, IndentArea), -AParent.Left, 0);
      Formatter.DoInitializeFooterCell(AItem, AColumnPlace.Column, ACellIndex, FDataNode);
    end;
  end;
end;

function TcxTreeListReportLinkFootersProducer.GetAutoHeight: Boolean;
begin
  Result := False;
end;

function TcxTreeListReportLinkFootersProducer.GetBandedRowIndent: Integer;
begin
  Result := IndentArea;
end;

function TcxTreeListReportLinkFootersProducer.GetIndentCount: Integer;
begin
  if FAttachedNode <> nil then
  begin
    Result := Formatter.IndentCounts[FDataNode];
    if Adapter.OptionsView.GroupFooters = tlgfVisibleWhenExpanded then
      Inc(Result);
  end
  else
    Result := 0;
end;

function TcxTreeListReportLinkFootersProducer.GetLineCount: Integer;
begin
  Result := Adapter.FooterLineCount[FDataNode];
end;

function TcxTreeListReportLinkFootersProducer.GetLineHeight: Integer;
begin
  Result := Formatter.FooterLineHeight;
end;

procedure TcxTreeListReportLinkFootersProducer.InitializeBandedRow(ARow: TdxReportCell);
begin
  inherited InitializeBandedRow(ARow);
  Formatter.DoInitializeFooterBandedRow(ARow, IndentCount);
end;

procedure TcxTreeListReportLinkFootersProducer.InitializeIndent(
  AnIndent: TdxReportCellExpandButton; AnIndex: Integer);
begin
  Formatter.DoInitializeFooterIndent(AnIndent, AnIndex, IndentCount, FAttachedNode);
  Formatter.DoReportLinkInitializeNodeIndent(AnIndent, AnIndex, IndentCount, FAttachedNode);  // TODO FooterIndentinitialize
end;

procedure TcxTreeListReportLinkFootersProducer.InitializeRow;
begin
  inherited InitializeRow;
  Formatter.DoInitializeFooterRow(Row);
end;

{ TcxTreeListReportLinkHeadersProducer }

procedure TcxTreeListReportLinkHeadersProducer.InitializeRow;
begin
  inherited;
  Formatter.DoInitializeHeaderRow(Row);
end;

procedure TcxTreeListReportLinkHeadersProducer.InitializeSubItem(
  ASubItem: TAbstractdxReportCellData; AnIndex: Integer);
begin
  inherited;
  Formatter.DoInitializeHeaderItem(ASubItem, AnIndex);
  Formatter.DoReportLinkInitializeHeaderItem(ASubItem, AnIndex);
end;

function TcxTreeListReportLinkHeadersProducer.GetAutoHeight: Boolean;
begin
  Result := inherited GetAutoHeight and Adapter.HeaderAutoHeight;
end;

function TcxTreeListReportLinkHeadersProducer.GetLineCount: Integer;
begin
  Result := Adapter.DetailsLineCount;
end;

function TcxTreeListReportLinkHeadersProducer.GetLineHeight: Integer;
begin
  Result := Formatter.HeaderLineHeight;
end;

function TcxTreeListReportLinkHeadersProducer.GetSubItemBound(Index: Integer): TRect;
begin
  Result := Formatter.GetHeaderItemBounds(Index);
end;

function TcxTreeListReportLinkHeadersProducer.GetSubItemClass(Index: Integer): TdxReportCellDataClass;
begin
  Result := Formatter.GetHeaderItemClass(Index);
end;

{ TcxTreeListReportLinkNodeProducer }

function TcxTreeListReportLinkNodeProducer.Produce(AHostInfo: TcxTreeListAttributeHostInfo;
  ANode: TcxTreeListNode): TdxReportCell;
begin
  FNode := ANode;
  Result := inherited Produce(AHostInfo);
  FNode := nil;
end;

procedure TcxTreeListReportLinkNodeProducer.CalculateRowAutoHeight;
var
  AMaxRowHeight, ACurrentItemHeight: Integer;
  I, J: Integer;
  ACell: TdxReportCell;
  AItem: TdxReportVisualItem;
begin
  if CellAutoHeight then
  begin
    AMaxRowHeight := 0;
    for I := 0 to Row.CellCount - 1 do
    begin
      ACell := Row.Cells[I];
      for J := 0 to ACell.DataItemCount - 1 do
      begin
        AItem := ACell.DataItems[J];
        if DoesItemParticipateInRowAutoHeightCalculation(AItem) then
        begin
          ACurrentItemHeight := AItem.MeasureContentHeight(Self.DC);
          if AMaxRowHeight < ACurrentItemHeight then
           AMaxRowHeight := ACurrentItemHeight;
        end;
      end;
    end;
    if RowHeight < AMaxRowHeight then
      RowHeight := AMaxRowHeight;
  end;
  if HasPreview then
    RowHeight := RowHeight + PreviewItem.Height;
end;

procedure TcxTreeListReportLinkNodeProducer.CreateChecks(AParent: TdxReportCell);
begin
  FCheck := Formatter.GetNodeCheckClass(FNode).Create(AParent);
  FCheck.BoundsRect := CheckRect;
  InitializeCheck;
end;

procedure TcxTreeListReportLinkNodeProducer.CreateIcons(AParent: TdxReportCell);
begin
  if Adapter.HasCheck(FNode) then CreateChecks(AParent);
  if Adapter.HasStateImages(FNode) then CreateStateImages(AParent);
  if Adapter.HasImages(FNode) then CreateImages(AParent);
end;

procedure TcxTreeListReportLinkNodeProducer.CreateImages(AParent: TdxReportCell);
begin
  FImage := Formatter.GetNodeImageClass.Create(AParent);
  FImage.BoundsRect := ImageRect;
  InitializeImage(ImageIndentIndex);
end;

procedure TcxTreeListReportLinkNodeProducer.CreateIndents(AParent: TdxReportCell);
begin
  inherited CreateIndents(AParent);
  CreateIcons(AParent);
end;

procedure TcxTreeListReportLinkNodeProducer.CreatePreview(AParent: TdxReportCell);
begin
  FPreviewItem := Formatter.GetPreviewClass(PreviewColumn, FNode).Create(AParent);
  PreviewItem.Left := PreviewIndent;
  // We have to set Width before because we use this value for PreviewHeight calculation
  PreviewItem.Width := RowWidth - PreviewItem.Left;
  Formatter.DoInitializePreview(FPreviewItem, PreviewColumn, FNode); // v3.1 because cxRichEdit
  PreviewItem.Height := PreviewHeight;
  PreviewItem.AdjustContent(Formatter.DC); // v3.1
end;

procedure TcxTreeListReportLinkNodeProducer.CreateRow;
begin
  inherited CreateRow;
  if HasPreview then CreatePreview(Row);
end;

procedure TcxTreeListReportLinkNodeProducer.CreateStateImages(AParent: TdxReportCell);
begin
  FStateImage := Formatter.GetNodeStateImageClass.Create(AParent);
  FStateImage.BoundsRect := StateImageRect;
  InitializeStateImage(StateImageIndentIndex);
end;

function TcxTreeListReportLinkNodeProducer.DoesItemParticipateInRowAutoHeightCalculation(
  AnItem: TdxReportVisualItem): Boolean;
var
  AColumn: TcxTreeListColumn;
  AProperties: TcxCustomEditProperties;
begin
  Result := AnItem <> FPreviewItem;
  if Result and not IsItemIndent(AnItem) and IsDelphiObject(AnItem.Data) then
  begin
    AColumn := TcxTreeListColumn(AnItem.Data);
    AProperties := Adapter.GetProperties(AColumn, FNode);
    Result := dxPScxCommon.dxPSDataMaps.DoesItemParticipateInAutoHeightCalculation(AProperties);
  end;
end;

procedure TcxTreeListReportLinkNodeProducer.FixupRowDataHeight;
var
  ANewHeight, I, J: Integer;
  AItem: TdxReportVisualItem;
  ACell: TdxReportCell;
begin
  ANewHeight := RowHeight;
  if PreviewItem <> nil then
  begin
    Dec(ANewHeight, PreviewItem.Height);
    if PreviewPlace = tlppTop then 
      PreviewItem.Top := 0
    else
      PreviewItem.Top := ANewHeight;
  end;

  for I := 0 to Row.DataItemCount - 1 do
  begin
    if Row.DataItems[I] <> PreviewItem then
    begin
      Row.DataItems[I].Height := ANewHeight;
      if HasPreview and (PreviewPlace = tlppTop) then
        Row.DataItems[I].Top := Row.DataItems[I].Top + PreviewItem.Height;
    end;
  end;

  for I := 0 to Row.CellCount - 1 do
  begin
    ACell := Row.Cells[I];
    if HasPreview and (PreviewPlace = tlppTop) then
      ACell.Top := ACell.Top + PreviewItem.Height;
    if CellAutoHeight then
    begin
      ACell.Height := ANewHeight;
      for J := 0 to ACell.DataItemCount - 1 do
      begin
        AItem := ACell.DataItems[J];
        AItem.Height := ANewHeight;
      end;
    end;
  end;
end;

procedure TcxTreeListReportLinkNodeProducer.InitializeBandedDataItem(AItem: TAbstractdxReportCellData);
begin
  inherited InitializeBandedDataItem(AItem);
  Formatter.DoInitializeNodeItem(AItem, TcxTreeListColumnPlace(AItem.Data).Column, FNode, False);
  Formatter.DoReportLinkInitializeNodeItem(AItem, TcxTreeListColumnPlace(AItem.Data).Column, FNode);
end;

procedure TcxTreeListReportLinkNodeProducer.InitializeBandedRow(ARow: TdxReportCell);
begin
  inherited InitializeBandedRow(ARow);
  Formatter.DoInitializeNodeBandedRow(ARow);
end;

procedure TcxTreeListReportLinkNodeProducer.InitializeCheck;
begin
  Formatter.DoInitializeNodeCheck(FCheck, FNode, CheckIndentIndex);
end;

procedure TcxTreeListReportLinkNodeProducer.InitializeImage(AnIndex: Integer);
begin
  Formatter.DoInitializeNodeImage(Image, FNode, AnIndex);
end;

procedure TcxTreeListReportLinkNodeProducer.InitializeIndent(AnIndent: TdxReportCellExpandButton; 
  AnIndex: Integer);
begin
  Formatter.DoInitializeNodeIndent(AnIndent, AnIndex, IndentCount, FNode);
  Formatter.DoReportLinkInitializeNodeIndent(AnIndent, AnIndex, IndentCount, FNode);
end;

procedure TcxTreeListReportLinkNodeProducer.InitializeRow;
begin
  inherited;
  Formatter.DoInitializeNodeRow(Row, FNode);
end;

procedure TcxTreeListReportLinkNodeProducer.InitializeStateImage(AnIndex: Integer); 
begin
  Formatter.DoInitializeNodeStateImage(StateImage, FNode, AnIndex);
  Formatter.DoReportLinkInitializeNodeStateImage(StateImage, FNode, AnIndex);
end;

function TcxTreeListReportLinkNodeProducer.IsItemIndent(AnItem: TdxReportVisualItem): Boolean;
begin
  Result := FIndents.IndexOf(AnItem) <> -1;
end;

function TcxTreeListReportLinkNodeProducer.GetAutoHeight: Boolean;
begin
  Result := CellAutoHeight or HasPreview;
end;

function TcxTreeListReportLinkNodeProducer.GetBandedDataItemBounds(AItem: TAbstractdxReportCellData): TRect;
var
  AColumnPlace: TcxTreeListColumnPlace;
begin
  AColumnPlace := TcxTreeListColumnPlace(AItem.Data);
  Result := cxRectOffset(AColumnPlace.CellBounds[FNode], -AItem.Parent.Left, 0);
end;

function TcxTreeListReportLinkNodeProducer.GetBandedDataItemClass(
  AColumnPlace: TcxTreeListColumnPlace): TdxReportCellDataClass;
begin
  Result := Formatter.GetNodeItemClass(AColumnPlace.Column, FNode, False);
end;

function TcxTreeListReportLinkNodeProducer.GetBandedRowIndent: Integer;
begin
  Result := PreviewIndent;
end;

function TcxTreeListReportLinkNodeProducer.GetCellAutoHeight: Boolean;
begin
  Result := inherited GetAutoHeight and Adapter.CellAutoHeight;
end;

function TcxTreeListReportLinkNodeProducer.GetCheckRect: TRect;
begin
  Result := MakeBounds(IndentWidth * IndentCount, 0, Adapter.GetCheckWidth(FNode), RowHeight);
end;

function TcxTreeListReportLinkNodeProducer.GetHasPreview: Boolean;
begin
  Result := Formatter.HasPreview;
end;

function TcxTreeListReportLinkNodeProducer.GetImageRect: TRect;
begin
  Result := MakeBounds(IndentWidth * IndentCount, 0, Adapter.GetImagesWidth(FNode), RowHeight);
  OffsetRect(Result, Adapter.GetStateImagesWidth(FNode) + Adapter.GetCheckWidth(FNode), 0);
end;

function TcxTreeListReportLinkNodeProducer.GetIndentCount: Integer;
begin
  Result := Formatter.IndentCounts[FNode];
end;

function TcxTreeListReportLinkNodeProducer.GetLineCount: Integer;
begin
  Result := Adapter.DetailsLineCount;
end;

function TcxTreeListReportLinkNodeProducer.GetLineHeight: Integer;
begin
  Result := Formatter.DetailsLineHeight;
end;

function TcxTreeListReportLinkNodeProducer.GetPreviewHeight: Integer;
begin
  Result := PreviewLineCount * PreviewLineHeight;
  if not (Formatter.PreviewAutoHeight and (Formatter.PreviewMaxLineCount = 0)) then 
    Inc(Result, 2 * dxTextSpace);
end;

function TcxTreeListReportLinkNodeProducer.GetPreviewIndent: Integer;
begin
  Result := Formatter.GetNodeIndent(FNode);
end;

function TcxTreeListReportLinkNodeProducer.GetPreviewLineCount: Integer;
begin
  if FPreviewItem <> nil then
    if not Formatter.PreviewAutoHeight then 
    begin
      Result := PreviewItem.CalculateLineCount(Formatter.DC);
      if Result <> Formatter.PreviewMaxLineCount then 
        Result := Formatter.PreviewMaxLineCount;
    end
    else
      Result := 1
  else
    Result := 0;    
end;

function TcxTreeListReportLinkNodeProducer.GetPreviewLineHeight: Integer;
var
  LineHeight: Integer;
begin
  if FPreviewItem <> nil then
    if Formatter.PreviewAutoHeight then
    begin
      Result := PreviewItem.MeasureContentHeight(Formatter.DC);
      if Formatter.PreviewMaxLineCount <> 0 then
      begin
        LineHeight := PreviewItem.MeasureFontHeight(Formatter.DC) - 2 * dxTextSpace;
        if Result > LineHeight * Formatter.PreviewMaxLineCount then 
          Result := LineHeight * Formatter.PreviewMaxLineCount;
      end;    
    end  
    else
      Result := PreviewItem.MeasureFontHeight(Formatter.DC) - 2 * dxTextSpace
  else
    Result := 0;  
end;

function TcxTreeListReportLinkNodeProducer.GetStateImageRect: TRect;
begin
  Result := MakeBounds(IndentWidth * IndentCount + Adapter.GetCheckWidth(FNode), 0,
    Adapter.GetStateImagesWidth(FNode), RowHeight);
end;

function TcxTreeListReportLinkNodeProducer.GetCheckIndentIndex: Integer;
begin
  Result := IndentCount;
end;

function TcxTreeListReportLinkNodeProducer.GetImageIndentIndex: Integer;
begin
  Result := StateImageIndentIndex;
  if Adapter.HasStateImages(FNode) then
    Inc(Result);
end;

function TcxTreeListReportLinkNodeProducer.GetPreviewColumn: TcxTreeListColumn;
begin
  Result := Adapter.PreviewColumn;
end;

function TcxTreeListReportLinkNodeProducer.GetPreviewPlace: TcxTreeListPreviewPlace;
begin
  Result := Adapter.PreviewPlace;
end;

function TcxTreeListReportLinkNodeProducer.GetStateImageIndentIndex: Integer;
begin
  Result := CheckIndentIndex;
  if Adapter.HasCheck(FNode) then
    Inc(Result);
end;

{ TcxTreeListReportLinkCategorizedNodeProducer }

procedure TcxTreeListReportLinkCategorizedNodeProducer.CreateBandedRows(AParent: TdxReportCell);
var
  AItem: TAbstractdxReportCellData;
begin
  AItem := Formatter.GetNodeItemClass(Adapter.CategorizedColumn, FNode, False).Create(Row);
  AItem.BoundsRect := MakeRect(PreviewIndent, 0, RowWidth, RowHeight);
  Formatter.DoInitializeNodeItem(AItem, Adapter.CategorizedColumn, FNode, False);
  Formatter.DoReportLinkInitializeNodeItem(AItem, Adapter.CategorizedColumn, FNode);
end;

{ TcxTreeListNodeHelper }

constructor TcxTreeListNodeHelper.Create(AnAdapter: TcxTreeListAdapter);
begin
  inherited Create;
  FAdapter := AnAdapter;
end;

class function TcxTreeListNodeHelper.PairClass: TClass;
begin
  Result := NodeClass;
end;

class function TcxTreeListNodeHelper.ProducerClass: TcxTreeListReportLinkNodeProducerClass;
begin
  Result := TcxTreeListReportLinkNodeProducer;
end;

class procedure TcxTreeListNodeHelper.Register;
begin
  cxTreeListNodeHelperFactory.Register(Self);
end;

class procedure TcxTreeListNodeHelper.Unregister;
begin
  cxTreeListNodeHelperFactory.Unregister(Self);
end;

function TcxTreeListNodeHelper.Adapter: TcxTreeListAdapter;
begin
  Result := FAdapter;
end;

function TcxTreeListNodeHelper.GetHasSelectedChildren: Boolean;
var
  SaveNode: TcxTreeListNode;
  I: Integer;
begin
  Result := True;
  SaveNode := Node;
  try
    with Node do 
      for I := 0 to Count - 1 do          
      begin
        Node := Items[I];
        if Node.Selected or Adapter.Helpers[Node].HasSelectedChildren then Exit;
      end;
  finally
    Node := SaveNode;
  end;
  Result := False;
end;

function TcxTreeListNodeHelper.GetHasSelectedParents: Boolean;
var
  Parent: TcxTreeListNode;
begin
  Parent := Node;
  while (Parent <> nil) and not Parent.Selected do 
    Parent := Parent.Parent;
  Result := Parent <> nil;  
end;

class function TcxTreeListNodeHelper.NodeClass: TcxTreeListNodeClass;
begin
  Result := TcxTreeListNode;
end;

{ TcxTreeListNodeHelperCache }

constructor TcxTreeListNodeHelperCache.Create(AnAdapter: TcxTreeListAdapter);
begin
  inherited Create;
  FAdapter := AnAdapter;
end;

function TcxTreeListNodeHelperCache.IndexOf(Node: TcxTreeListNode): Integer;
begin
  for Result := 0 to Count - 1 do
    if Items[Result].NodeClass = Node.ClassType then Exit;
    
  Result := Add(cxTreeListNodeHelperFactory.HelperClasses[Node].Create(Adapter));
end;

function TcxTreeListNodeHelperCache.GetHelper(Node: TcxTreeListNode): TcxTreeListNodeHelper;
begin
  Result := Items[IndexOf(Node)];
  Result.Node := Node;
end;

function TcxTreeListNodeHelperCache.GetItem(Index: Integer): TcxTreeListNodeHelper;
begin
  Result := TcxTreeListNodeHelper(inherited Items[Index]);
end;

{ TcxTreeListReportLinkProducerCache }

constructor TcxTreeListReportLinkProducerCache.Create(ABuilder: TcxTreeListReportLinkBuilder);
begin
  inherited Create;
  FBuilder := ABuilder;
end;

function TcxTreeListReportLinkProducerCache.IndexOf(AProducerClass: TcxTreeListReportLinkRowProducerClass): Integer;
begin
  for Result := 0 to Count - 1 do
    if Items[Result].ClassType = AProducerClass then Exit;

  Result := Add(AProducerClass.Create(Builder));
end;

function TcxTreeListReportLinkProducerCache.GetProducer(ProducerClass: TcxTreeListReportLinkRowProducerClass): TcxTreeListReportLinkRowProducer;
begin
  Result := Items[IndexOf(ProducerClass)];
end;

function TcxTreeListReportLinkProducerCache.GetItem(Index: Integer): TcxTreeListReportLinkRowProducer;
begin
  Result := TcxTreeListReportLinkRowProducer(inherited Items[Index]);
end;

{ TcxTreeListReportLinkBuilder }

constructor TcxTreeListReportLinkBuilder.Create(AReportLink: TcxTreeListCustomReportLink);
begin
  inherited Create;
  FReportLink := AReportLink;
  FAdapter := AdapterClass.Create(Self);
  FFormatter := FormatterClass.Create(Self);
  FProducerCache := TcxTreeListReportLinkProducerCache.Create(Self);
  FReportRows := TList.Create;
end;

destructor TcxTreeListReportLinkBuilder.Destroy;
begin
  FreeAndNil(FReportRows);
  FreeAndNil(FProducerCache);
  FreeAndNil(FFormatter);
  FreeAndNil(FAdapter);
  inherited;
end;

procedure TcxTreeListReportLinkBuilder.Build;
begin
  BeforeBuilding;
  try
    DoBuild;
  finally
    AfterBuilding;
  end;
end;

procedure TcxTreeListReportLinkBuilder.Progress(const APercentDone: Double);
begin
  ReportLink.DoProgress(APercentDone);
end;

function TcxTreeListReportLinkBuilder.Adapter: TcxTreeListAdapter;
begin
  Result := FAdapter;
end;

class function TcxTreeListReportLinkBuilder.AdapterClass: TcxTreeListAdapterClass;
begin
  Result := TcxTreeListAdapter;
end;

function TcxTreeListReportLinkBuilder.Formatter: TcxTreeListReportLinkFormatter;
begin
  Result := FFormatter;
end;

class function TcxTreeListReportLinkBuilder.FormatterClass: TcxTreeListReportLinkFormatterClass;
begin
  Result := TcxTreeListReportLinkFormatter;
end;

procedure TcxTreeListReportLinkBuilder.AddReportRow(ARow: TdxReportCell);
begin
  if ARow.Parent = ReportLink.ReportCells.Cells then
    FReportRows.Add(ARow);
end;

procedure TcxTreeListReportLinkBuilder.AfterBuilding;
begin
  Formatter.AfterBuilding;
end;

procedure TcxTreeListReportLinkBuilder.BeforeBuilding;
begin
  Formatter.BeforeBuilding;
end;

procedure TcxTreeListReportLinkBuilder.CreateBands;
begin
  AddReportRow(GetBandsProducer.Produce(ReportLink.HostInfoServices.BandHeadersHostInfo));
end;

function TcxTreeListReportLinkBuilder.GetBandsProducer: TcxTreeListReportLinkBandsProducer;
begin
  Result := ProducerCache[GetBandsProducerClass] as TcxTreeListReportLinkBandsProducer;
end;

function TcxTreeListReportLinkBuilder.GetBandsProducerClass: TcxTreeListReportLinkBandsProducerClass;
begin
  Result := TcxTreeListReportLinkBandsProducer;
end;

procedure TcxTreeListReportLinkBuilder.CreateFooters(AHostInfo: TcxTreeListAttributeHostInfo;
   AAttachedNode, ADataNode: TcxTreeListNode);
begin
  AddReportRow(GetFootersProducer.Produce(AHostInfo, AAttachedNode, ADataNode));
end;

function TcxTreeListReportLinkBuilder.GetFootersProducer: TcxTreeListReportLinkFootersProducer;
begin
  Result := ProducerCache[GetFootersProducerClass] as TcxTreeListReportLinkFootersProducer;
end;

function TcxTreeListReportLinkBuilder.GetFootersProducerClass: TcxTreeListReportLinkFootersProducerClass;
begin
  Result := TcxTreeListReportLinkFootersProducer;
end;

procedure TcxTreeListReportLinkBuilder.CreateHeaders;
begin
  AddReportRow(GetHeadersProducer.Produce(ReportLink.HostInfoServices.HeadersHostInfo));
end;

function TcxTreeListReportLinkBuilder.GetHeadersProducer: TcxTreeListReportLinkHeadersProducer;
begin
  Result := ProducerCache[GetHeadersProducerClass] as TcxTreeListReportLinkHeadersProducer;
end;

function TcxTreeListReportLinkBuilder.GetHeadersProducerClass: TcxTreeListReportLinkHeadersProducerClass;
begin
  Result := TcxTreeListReportLinkHeadersProducer;
end;

procedure TcxTreeListReportLinkBuilder.CreateNode(ANode: TcxTreeListNode);
begin
  AddReportRow(GetNodeProducer(ANode).Produce(ReportLink.HostInfoServices.PageDetailsHostInfo, ANode));
end;

procedure TcxTreeListReportLinkBuilder.CreateNodes;
var
  AHasNodeSeparator, AHasGroupFooters: Boolean;
  I: Integer;
  ANode: TcxTreeListNode;
  ASummaryNodes: TObjectStack;
begin
  AHasNodeSeparator := Formatter.HasNodeSeparator;
  AHasGroupFooters := Adapter.OptionsView.GroupFooters <> tlgfInvisible;
  ASummaryNodes := TObjectStack.Create;
  try
    for I := 0 to Formatter.NodeCount - 1 do
    begin
      ANode := Formatter.Nodes[I];
      CreateNode(ANode);
      if AHasGroupFooters then
      begin
        if Adapter.HasNodeSummary(ANode) then
          ASummaryNodes.Push(ANode);
        while (ASummaryNodes.Count > 0) and
          Adapter.HasNodeAttachedFooter(ANode, TcxTreeListNode(ASummaryNodes.Peek)) do
          CreateFooters(ReportLink.HostInfoServices.PageDetailsHostInfo, ANode,
             TcxTreeListNode(ASummaryNodes.Pop));
      end;
      if AHasNodeSeparator and (I < Formatter.NodeCount - 1) then
        CreateNodeSeparator(ANode);

      Progress(100 * (I + 1) / Formatter.NodeCount);
      if IsAborted then Break;
    end;
  finally
    ASummaryNodes.Free;
  end;
end;

function TcxTreeListReportLinkBuilder.GetNodeProducer(ANode: TcxTreeListNode): TcxTreeListReportLinkNodeProducer;
begin
  Result := ProducerCache[GetNodeProducerClass(ANode)] as TcxTreeListReportLinkNodeProducer;
end;

function TcxTreeListReportLinkBuilder.GetNodeProducerClass(ANode: TcxTreeListNode): TcxTreeListReportLinkNodeProducerClass;
begin
  if Adapter.IsGroupNode(ANode) then
    Result := TcxTreeListReportLinkCategorizedNodeProducer
  else
    Result := Adapter.Helpers[ANode].ProducerClass;
end;

procedure TcxTreeListReportLinkBuilder.CreateNodeSeparator(ANode: TcxTreeListNode);
begin
  AddReportRow(GetNodeSeparatorProducer.Produce(ReportLink.HostInfoServices.PageDetailsHostInfo));
end;

function TcxTreeListReportLinkBuilder.GetNodeSeparatorProducer: TcxTreeListReportLinkNodeSeparatorProducer;
begin
  Result := ProducerCache[GetNodeSeparatorProducerClass] as TcxTreeListReportLinkNodeSeparatorProducer;
end;

function TcxTreeListReportLinkBuilder.GetNodeSeparatorProducerClass: TcxTreeListReportLinkNodeSeparatorProducerClass;
begin
  Result := TcxTreeListReportLinkNodeSeparatorProducer;
end;

procedure TcxTreeListReportLinkBuilder.DoBuild;
begin
  if Formatter.ShowBandHeaders then CreateBands;
  if Formatter.ShowHeaders then CreateHeaders;
  CreateNodes;
  
  if not IsAborted and Formatter.ShowFooters then
    CreateFooters(ReportLink.HostInfoServices.FootersHostInfo, nil, TreeList.Root);
end;

function TcxTreeListReportLinkBuilder.IsAborted: Boolean;
begin
  Result := ReportLink.AbortBuilding;
end;

function TcxTreeListReportLinkBuilder.GetHost: TdxReportCell;
begin
  Result := ReportLink.ReportCells.Cells;
end;

function TcxTreeListReportLinkBuilder.GetReportCells: TdxReportCells;
begin
  Result := ReportLink.ReportCells;
end;

function TcxTreeListReportLinkBuilder.GetReportRow(Index: Integer): TdxReportCell;
begin
  Result := TdxReportCell(FReportRows[Index]);
end;

function TcxTreeListReportLinkBuilder.GetReportRowCount: Integer;
begin
  Result := FReportRows.Count;
end;

function TcxTreeListReportLinkBuilder.GetTreeList: TcxCustomTreeList;
begin
  Result := ReportLink.TreeList;
end;    

{ TcxTreeListReportLinkBuilderHandler }

constructor TcxTreeListReportLinkBuilderHandler.Create(ABuilder: TcxTreeListReportLinkBuilder);
begin
  inherited Create;
  FBuilder := ABuilder;
end;

function TcxTreeListReportLinkBuilderHandler.Builder: TcxTreeListReportLinkBuilder;
begin
  Result := FBuilder;
end;

function TcxTreeListReportLinkBuilderHandler.GetReportLink: TcxTreeListCustomReportLink;
begin
  Result := Builder.ReportLink;
end;

{ TcxTreeListAdapter }

constructor TcxTreeListAdapter.Create(ABuilder: TcxTreeListReportLinkBuilder);
begin
  inherited;
  FHelperCache := TcxTreeListNodeHelperCache.Create(Self);
  FDetailsLineCount := -1;
  FFooterLineCount := -1;
  FMultiRows := False;
end;

destructor TcxTreeListAdapter.Destroy;
begin
  FreeAndNil(FHelperCache);
  inherited;
end;

function TcxTreeListAdapter.CalculateDetailsLineCount: Integer;
var
  I, J, V: Integer;
  ABandRows: TcxTreeListBandRows;
begin
  Result := 0;
  for I := 0 to BottomBandCount - 1 do
  begin
    ABandRows := BottomBands[I].BandRows;
    FMultiRows := FMultiRows or (ABandRows.VisibleItemCount > 1);
    V := 0;
    for J := 0 to ABandRows.VisibleItemCount - 1 do
      Inc(V, ABandRows[J].LineCount);
    if Result < V then Result := V;
  end;
end;

procedure TcxTreeListAdapter.Calculate;
begin
  FDetailsLineCount := CalculateDetailsLineCount;
  if not FMultiRows then
  begin
    FFooterLineCount := Max(1, TreeList.Summary.FooterSummaryRowCount);
    FGroupFooterLineCount := Max(1, TreeList.Summary.GroupFooterSummaryRowCount);
  end
  else
  begin
    FFooterLineCount := Max(1, TreeList.Bands.ColumnsLineCount);
    FGroupFooterLineCount := FFooterLineCount;
  end;
end;

class function TcxTreeListAdapter.GetProperties(AColumn: TcxTreeListColumn;
  ANode: TcxTreeListNode): TcxCustomEditProperties;
begin
  Result := TreeListColumn_DoGetEditProperties(AColumn, ANode);
  if Result = nil then
    Result := GetRepositoryItem(AColumn, ANode).Properties;
end;

class function TcxTreeListAdapter.GetPropertiesClass(AColumn: TcxTreeListColumn;
  ANode: TcxTreeListNode): TcxCustomEditPropertiesClass;
begin
  Result := TcxCustomEditPropertiesClass(GetProperties(AColumn, ANode).ClassType);
end;

class function TcxTreeListAdapter.GetRepositoryItem(AColumn: TcxTreeListColumn;
  ANode: TcxTreeListNode): TcxEditRepositoryItem;
begin
  Result := AColumn.RepositoryItem; 
end;

function TcxTreeListAdapter.GetBackgroundViewParams: TcxViewParams;
begin
  Result := Styles.GetBackgroundParams;
end;

function TcxTreeListAdapter.GetBandBackgroundViewParams: TcxViewParams;
begin
  Result := Styles.GetBandBackgroundParams(nil);
end;

function TcxTreeListAdapter.GetBandHeaderViewParams(ABand: TcxTreeListBand): TcxViewParams;
begin
  Result := Styles.GetBandHeaderParams(ABand);
  if ABand = nil then
    Result.Color := LookAndFeelPainter.DefaultHeaderBackgroundColor
end;

function TcxTreeListAdapter.GetContentViewParams(ANode: TcxTreeListNode; 
  AColumn: TcxTreeListColumn): TcxViewParams; 
begin
  Result := Styles.GetContentParams(ANode, AColumn);
  // v3.2
  if Result.Color = clWindow then
    Result.Color := dxPSCore.dxDefaultContentColor;
end;
  
function TcxTreeListAdapter.GetColumnFooterViewParams(AColumn: TcxTreeListColumn): TcxViewParams;
begin
  Result := Styles.GetColumnFooterParams(AColumn, nil);
  Result.Color := LookAndFeelPainter.DefaultHeaderColor
end;

function TcxTreeListAdapter.GetColumnHeaderViewParams(AColumn: TcxTreeListColumn): TcxViewParams;
begin
  if AColumn = nil then
  begin
   // FillChar(Result, SizeOf(Result), 0);
  //  Result.Color := LookAndFeelPainter.DefaultHeaderBackgroundColor;
    Result := Styles.GetBandBackgroundParams(Bands[0])
  end
  else
    Result := Styles.GetColumnHeaderParams(AColumn);
end;

function TcxTreeListAdapter.GetIndentViewParams(ANode: TcxTreeListNode; 
  AnIndent: Integer): TcxViewParams;
begin
  Result := Styles.GetIndentParams(ANode, AnIndent);
  // v3.2
  if Result.Color = clWindow then
    Result.Color := dxPSCore.dxDefaultContentColor;
end;

function TcxTreeListAdapter.GetPreviewViewParams(ANode: TcxTreeListNode; 
  AColumn: TcxTreeListColumn): TcxViewParams;
begin
  Result := Styles.GetPreviewParams(ANode);
  // v3.2
  if Result.Color = clWindow then
    Result.Color := dxPSCore.dxDefaultContentColor;
end;

function TcxTreeListAdapter.GetFooterRowViewParams: TcxViewParams;
begin
  Result := Styles.GetFooterParams;
end;

function TcxTreeListAdapter.GetSelectionViewParams: TcxViewParams; 
begin
  FillChar(Result, SizeOf(Result), 0);
  with Styles.Selection do
  begin
    Result.Bitmap := nil;
    Result.Color := Color;
    Result.Font := Font;
    Result.TextColor := TextColor;
  end;
end;

function TcxTreeListAdapter.HasSelectionStyle: Boolean;
begin
  Result := Styles.Selection <> nil;
end;
  
function TcxTreeListAdapter.GetBackgroundBitmap(Index: Integer): TBitmap;
begin
  Result := Styles.GetBitmap(Index);
end;

function TcxTreeListAdapter.HasBackgroundBitmap(Index: Integer): Boolean;
begin
  Result := GetBackgroundBitmap(Index) <> nil;
end;

function TcxTreeListAdapter.GetCheckWidth(ANode: TcxTreeListNode): Integer;
begin
  if HasCheck(ANode) then 
    Result := DefaultIndentWidth
  else
    Result := 0;
end;

function TcxTreeListAdapter.GetImagesHeight(ANode: TcxTreeListNode): Integer;
begin
  if HasImages(ANode) then 
    Result := 1 + Images.Height + 1
  else
    Result := 0;
end;

function TcxTreeListAdapter.GetImagesWidth(ANode: TcxTreeListNode): Integer;
begin
  if HasImages(ANode) then 
    Result := 1 + Images.Width + 1
  else
    Result := 0;
end;

function TcxTreeListAdapter.GetStateImagesHeight(ANode: TcxTreeListNode): Integer;
begin
  if HasStateImages(ANode) then  
    Result := 1 + StateImages.Height + 1
  else
    Result := 0;
end;

function TcxTreeListAdapter.GetStateImagesWidth(ANode: TcxTreeListNode): Integer;
begin
  if HasStateImages(ANode) then 
    Result := 1 + StateImages.Width + 1
  else
    Result := 0;
end;

function TcxTreeListAdapter.HasCheck(ANode: TcxTreeListNode): Boolean;
begin
  Result := TreeList.OptionsView.CheckGroups and (ANode.Parent <> nil) and
    (ANode.Parent.CheckGroupType <> ncgNone);
end;

function TcxTreeListAdapter.HasImages(ANode: TcxTreeListNode): Boolean;
begin
  Result := Images <> nil;
  if Result and (ANode <> nil) then 
    Result := (ANode.ImageIndex > -1) and (ANode.ImageIndex < Images.Count);
end;

function TcxTreeListAdapter.HasStateImages(ANode: TcxTreeListNode): Boolean;
begin
  Result := StateImages <> nil;
  if Result and (ANode <> nil) then 
    Result := (ANode.StateIndex > -1) and (ANode.StateIndex < StateImages.Count);
end;

function TcxTreeListAdapter.IsGroupNode(ANode: TcxTreeListNode): Boolean; 
begin
  Result := CustomTreeList_DoIsGroupNode(TreeList, ANode);
end;

function TcxTreeListAdapter.HasNodeAttachedFooter(ANode, ASummaryNode: TcxTreeListNode): Boolean;
begin
  Result := not ANode.Expanded and ((ANode = ASummaryNode) or
    (ANode = ASummaryNode.GetLastChildVisible) or
    ANode.HasAsParent(ASummaryNode.GetLastChildVisible));
end;

function TcxTreeListAdapter.HasNodeSummary(ANode: TcxTreeListNode): Boolean;
begin
  Result := ANode.HasChildren and ((OptionsView.GroupFooters = tlgfAlwaysVisible) or
    (OptionsView.GroupFooters = tlgfVisibleWhenExpanded) and ANode.Expanded);
end;

function TcxTreeListAdapter.GetAutoWidth: Boolean;
begin
  Result := OptionsView.ColumnAutoWidth;
end;

function TcxTreeListAdapter.GetBand(Index: Integer): TcxTreeListBand;
begin
  Result := CustomTreeList_GetVisibleBand(TreeList, Index);
end;

function TcxTreeListAdapter.GetBandCount: Integer;
begin
  Result := CustomTreeList_GetVisibleBandCount(TreeList);
end;

function TcxTreeListAdapter.GetBottomBand(Index: Integer): TcxTreeListBand;
begin
  Result := TreeList.Bands.BottomItems[Index];
end;

function TcxTreeListAdapter.GetBottomBandCount: Integer;
begin
  Result := TreeList.Bands.BottomItemCount;
end;

function TcxTreeListAdapter.GetCanUseLookAndFeelColors: Boolean;
begin
  Result := CustomTreeList_GetLookAndFeel(TreeList).NativeStyle and 
    dxThemeManager.AreVisualStylesAvailable;
end;

function TcxTreeListAdapter.GetCategorizedColumn: TcxTreeListColumn;
begin
  Result := OptionsView.GetCategorizedColumn;
end;

function TcxTreeListAdapter.GetColumnCount: Integer;
begin
  Result := CustomTreeList_GetVisibleColumnCount(TreeList);
end;

function TcxTreeListAdapter.GetCellAutoHeight: Boolean;
begin
  Result := OptionsView.CellAutoHeight and (DetailsLineCount = 1);
end;

function TcxTreeListAdapter.GetCellEndEllipsis: Boolean; 
begin
  Result := OptionsView.CellEndEllipsis;
end;

function TcxTreeListAdapter.GetCellMultiline: Boolean;
begin
  Result := OptionsView.CellAutoHeight and (DetailsLineCount = 1);
end;

function TcxTreeListAdapter.GetColumn(Index: Integer): TcxTreeListColumn;
begin
  Result := CustomTreeList_GetVisibleColumn(TreeList, Index);
end;

function TcxTreeListAdapter.GetDefaultRowHeight: Integer;
begin
  Result := TreeList.DefaultRowHeight;
end;

function TcxTreeListAdapter.GetFooterLineCount(ANode: TcxTreeListNode): Integer;
begin
  if ANode = TreeList.Root then
    Result := FFooterLineCount
  else
    Result := FGroupFooterLineCount;
end;

function TcxTreeListAdapter.GetGridLines: TcxTreeListGridLines;
begin
  Result := OptionsView.GridLines;
end;

function TcxTreeListAdapter.GetGridLinesColor: TColor;
begin
  Result := OptionsView.GridLineColor;
  if Result = clDefault then
    Result := LookAndFeelPainter.DefaultGridLineColor;
end;

function TcxTreeListAdapter.GetHasPreview: Boolean;
begin
  Result := TreeList.Preview.Active;
end;

function TcxTreeListAdapter.GetHeaderAutoHeight: Boolean;
begin
  Result := (DetailsLineCount = 1) and OptionsView.CellAutoHeight;
end;

function TcxTreeListAdapter.GetHelper(Node: TcxTreeListNode): TcxTreeListNodeHelper;
begin
  Result := FHelperCache.Helpers[Node];
end;

function TcxTreeListAdapter.GetIndentWidth: Integer;
begin
  Result := GetStateImagesWidth(nil);
  if GetImagesWidth(nil) > GetStateImagesWidth(nil) then 
    Result := GetImagesWidth(nil);
  if Result = 0 then 
    Result := DefaultIndentWidth;
end;

function TcxTreeListAdapter.GetIsDefaultRowHeightAssigned: Boolean;
begin
  Result := DefaultRowHeight <> 0;
end;

function TcxTreeListAdapter.GetImages: TCustomImageList;
begin
  Result := CustomTreeList_GetImages(TreeList);
end;

function TcxTreeListAdapter.GetIsNodeColorUsedForIndents: Boolean;
begin
  Result := OptionsView.UseNodeColorForIndent;
end;

function TcxTreeListAdapter.GetLookAndFeelKind: TcxLookAndFeelKind;
begin
  Result := CustomTreeList_GetLookAndFeel(TreeList).Kind;
end;

function TcxTreeListAdapter.GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
begin
  Result := CustomTreeList_GetLookAndFeelPainter(TreeList);
end;

function TcxTreeListAdapter.GetMultiSelection: Boolean;
begin
  Result := CustomTreeList_GetOptionsSelection(TreeList).MultiSelect;
end;

function TcxTreeListAdapter.GetNode(Index: Integer): TcxTreeListNode;
begin
  Result := TreeList.Root[Index];
end;

function TcxTreeListAdapter.GetNodeCount: Integer;
begin
  Result := TreeList.Root.Count;
end;

function TcxTreeListAdapter.GetOptionsView: TcxTreeListOptionsView;
begin
  Result := CustomTreeList_GetOptionsView(TreeList);
end;

function TcxTreeListAdapter.GetPaintStyle: TcxTreeListPaintStyle;
begin
  Result := OptionsView.PaintStyle;
end;

function TcxTreeListAdapter.GetPreviewColumn: TcxTreeListColumn;
begin
  Result := CustomTreeList_GetPreview(TreeList).Column;
end;

function TcxTreeListAdapter.GetPreviewLeftIndent: Integer;
begin
  Result := CustomTreeList_GetPreview(TreeList).LeftIndent;
end;

function TcxTreeListAdapter.GetPreviewPlace: TcxTreeListPreviewPlace;
begin
  Result := CustomTreeList_GetPreview(TreeList).Place;
end;

function TcxTreeListAdapter.GetPreviewRightIndent: Integer;
begin
  Result := CustomTreeList_GetPreview(TreeList).RightIndent;
end;

function TcxTreeListAdapter.GetRootBand(Index: Integer): TcxTreeListBand;
begin
  Result := TreeList.Bands.VisibleRootItems[Index];
end;

function TcxTreeListAdapter.GetRootBandCount: Integer;
begin
  Result := TreeList.Bands.visibleRootItemCount;
end;

function TcxTreeListAdapter.GetShowRoot: Boolean;
begin
  Result := OptionsView.ShowRoot;
end;

function TcxTreeListAdapter.GetShowHorzGridLines: Boolean;
begin
  Result := GridLines in [tlglHorz, tlglBoth];
end;

function TcxTreeListAdapter.GetShowTreeLines: Boolean;
begin
  Result := OptionsView.TreeLineStyle <> tllsNone;
end;

function TcxTreeListAdapter.GetShowVertGridLines: Boolean;
begin
  Result := GridLines in [tlglVert, tlglBoth];
end;

function TcxTreeListAdapter.GetStateImages: TCustomImageList;
begin
  Result := CustomTreeList_GetStateImages(TreeList);
end;

function TcxTreeListAdapter.GetStyles: TcxTreeListStyles;
begin
  Result := CustomTreeList_GetStyles(TreeList);
end;

function TcxTreeListAdapter.GetThemedBandHeaderItemColor: TColor;
begin
  Result := LookAndFeelPainter.DefaultHeaderColor;
end;

function TcxTreeListAdapter.GetThemedBandHeaderItemTextColor: TColor;
begin
  Result := LookAndFeelPainter.DefaultHeaderTextColor;
end;

function TcxTreeListAdapter.GetThemedFooterItemColor: TColor;
begin
  Result := LookAndFeelPainter.DefaultFooterColor;
end;

function TcxTreeListAdapter.GetThemedFooterItemTextColor: TColor;
begin
  Result := LookAndFeelPainter.DefaultFooterTextColor;
end;

function TcxTreeListAdapter.GetThemedHeaderItemColor: TColor;
begin
  Result := LookAndFeelPainter.DefaultHeaderColor;
end;

function TcxTreeListAdapter.GetThemedHeaderItemTextColor: TColor;
begin
  Result := LookAndFeelPainter.DefaultHeaderTextColor;
end;

function TcxTreeListAdapter.GetThemedHeaderRowColor: TColor;
begin
  Result := LookAndFeelPainter.DefaultHeaderBackgroundColor;
end;

function TcxTreeListAdapter.GetTreeLinesColor: TColor;
begin
  Result := OptionsView.TreeLineColor;
end;

function TcxTreeListAdapter.GetTreeLinesStyle: TcxTreeListTreeLineStyle;
begin
  Result := OptionsView.TreeLineStyle;
end;

function TcxTreeListAdapter.GetTreeList: TcxCustomTreeList;
begin
  Result := Builder.TreeList;
end;

function TcxTreeListAdapter.GetUseStylesForIndents: Boolean;
begin
  Result := OptionsView.UseNodeColorForIndent;
end;

{ TcxTreeListCustomItemPlaceController }

constructor TcxTreeListCustomItemPlaceController.Create(
  AFormatter: TcxTreeListReportLinkFormatter);
begin
  inherited Create;
  FFormatter := AFormatter;
  FHeaderLineCount := -1;
  FWidth := -1;
end;

procedure TcxTreeListCustomItemPlaceController.Calculate;
begin
end;

procedure TcxTreeListCustomItemPlaceController.Refresh;
begin
end;

function TcxTreeListCustomItemPlaceController.CalculateWidth: Integer;
begin
  Result := 0;
end;

function TcxTreeListCustomItemPlaceController.CalculateHeaderLineCount: Integer;
begin
  Result := 1;
end;

function TcxTreeListCustomItemPlaceController.GetItemByColumn(
  Column: TcxTreeListColumn): TcxTreeListColumnPlace;
begin
  Result := nil;
end;

procedure TcxTreeListCustomItemPlaceController.WidthChanged;
begin
end;

function TcxTreeListCustomItemPlaceController.GetAdapter: TcxTreeListAdapter;
begin
  Result := Formatter.Adapter;
end;

function TcxTreeListCustomItemPlaceController.GetHeaderLineCount: Integer;
begin
  if FHeaderLineCount = -1 then
    FHeaderLineCount := CalculateHeaderLineCount;
  Result := FHeaderLineCount;
end;

function TcxTreeListCustomItemPlaceController.GetWidth: Integer;
begin
  if FWidth = -1 then
    FWidth := CalculateWidth;
  Result := FWidth;
end;

procedure TcxTreeListCustomItemPlaceController.SetWidth(Value: Integer);
begin
  FWidth := Value;
  WidthChanged;
end;

{ TcxTreeListColumnPlace }

constructor TcxTreeListColumnPlace.Create(
  AController: TcxTreeListCustomBandPlace; AColumn: TcxTreeListColumn);
begin
  inherited Create;
  FController := AController;
  FColumn := AColumn;
  
  FLeftBound := -1;
  FWidth := -1;
end;

procedure TcxTreeListColumnPlace.Calculate(ALeftBound: Integer);
begin
  FLeftBound := ALeftBound;
end;

function TcxTreeListColumnPlace.CalculateLeftBound: Integer;
begin
  Result := Controller.CalculateItemLeftBound(Self);
end;

function TcxTreeListColumnPlace.GetLineCount: Integer;
begin
  Result := Column.Position.LineCount;
end;

function TcxTreeListColumnPlace.GetRowIndex: Integer;
begin
  Result := Column.Position.Row.LineOffset;
end;

procedure TcxTreeListColumnPlace.InitAutoWidthItem(
  AnItem: TcxAutoWidthItem);
begin
  AnItem.Fixed := IsFixed;
  AnItem.MinWidth := MinWidth;
  AnItem.Width := Width;
end;

function TcxTreeListColumnPlace.GetAdapter: TcxTreeListAdapter;
begin
  Result := Formatter.Adapter;
end;

function TcxTreeListColumnPlace.GetCellBounds(ANode: TcxTreeListNode): TRect;
var
  ACellHeight: Integer;
  AColumnAccess: TcxTreeListColumnAccess;
begin
  ACellHeight := CellHeights[ANode];
  Result := cxRectBounds(LeftBound, RowIndex * ACellHeight, Width, LineCount * ACellHeight);
  AColumnAccess := TcxTreeListColumnAccess(Column);
  if AColumnAccess.HasIndent then
    Inc(Result.Left, Formatter.GetNodeIndent(ANode));
end;

function TcxTreeListColumnPlace.GetCellHeight(ANode: TcxTreeListNode): Integer;
begin
  Result := Formatter.DetailsLineHeight;
end;

function TcxTreeListColumnPlace.GetFooterCellBounds(AIndex: Integer): TRect;
begin
  Result := Bounds(LeftBound, (RowIndex + AIndex * LineCount) * FooterLineHeight,
    Width, LineCount * FooterLineHeight);
  InflateRect(Result, -FooterItemInflateHorz, -FooterItemInflateVert);
end;

function TcxTreeListColumnPlace.GetFooterLineHeight: Integer;
begin
  Result := Formatter.FooterLineHeight;
end;

function TcxTreeListColumnPlace.GetFormatter: TcxTreeListReportLinkFormatter;
begin
  Result := Controller.Formatter;
end;

function TcxTreeListColumnPlace.GetHeaderCellBounds: TRect;
begin
  Result := cxRectBounds(LeftBound, RowIndex * HeaderLineHeight, Width,
    LineCount * HeaderLineHeight);
end;

function TcxTreeListColumnPlace.GetHeaderLineHeight: Integer;
begin
  Result := Formatter.HeaderLineHeight;
end;

function TcxTreeListColumnPlace.GetIndex: Integer;
begin
  Result := Controller.IndexOf(Self);
end;

function TcxTreeListColumnPlace.GetIsFixed: Boolean;
var
  AColumnAccess: TcxTreeListColumnAccess;
begin
  AColumnAccess := TcxTreeListColumnAccess(Column);
  Result := AColumnAccess.IsFixed;
end;

function TcxTreeListColumnPlace.GetLeftBound: Integer;
begin
  if FLeftBound = -1 then
    FLeftBound := CalculateLeftBound;
  Result := FLeftBound; 
end;

function TcxTreeListColumnPlace.GetMinWidth: Integer;
begin
  Result := Column.MinWidth + Column.IndentWidth;
end;

function TcxTreeListColumnPlace.GetOriginalWidth: Integer;
begin
  Result := Column.DisplayWidth;
end;

function TcxTreeListColumnPlace.GetWidth: Integer;
begin
  Result := FWidth;
  if Result = -1 then
    Result := OriginalWidth;
end;

{ TcxTreeListCustomBandPlace }

constructor TcxTreeListCustomBandPlace.Create(
  AController: TcxTreeListItemPlaceController;
  AParent: TcxTreeListBandPlace; ABand: TcxTreeListBand);
begin
  inherited Create(AController.Formatter);
  FColumnIndexes := TList.Create;
  FItems := TObjectList.Create;
  FController := AController;
  FParent := AParent;
  FBand := ABand;
  FHeight := -1;
  FLeftBound := -1;
  FMinWidth := -1;
  FTopBound := -1;
end;

destructor TcxTreeListCustomBandPlace.Destroy;
begin
  FreeAndNil(FItems);
  FreeAndNil(FColumnIndexes);
  inherited Destroy;
end;

procedure TcxTreeListCustomBandPlace.Calculate;
begin
  if ItemsAutoWidth then CalculateItemsWidth;
end;

function TcxTreeListCustomBandPlace.IndexOf(
  AnItem: TcxTreeListColumnPlace): Integer;
begin
  Result := FItems.IndexOf(AnItem);
end;

function TcxTreeListCustomBandPlace.IndexOf(
  AColumn: TcxTreeListColumn): Integer;
begin
  for Result := 0 to ItemCount - 1 do
    if Items[Result].Column = AColumn then
      Exit;
  Result := -1;
end;

procedure TcxTreeListCustomBandPlace.Refresh;
begin
  FColumnIndexes.Clear;
  FItems.Clear;
  AddItems;
end;

function TcxTreeListCustomBandPlace.CalculateHeaderLineCount: Integer;
var
  I: Integer;
begin
  Result := 0;
  with Band.BandRows do
    for I := 0 to VisibleItemCount - 1 do
      Inc(Result, VisibleItems[I].LineCount);
end;

function TcxTreeListCustomBandPlace.CalculateWidth: Integer;

  function FixedSize: Boolean;
  var
    I: Integer;
  begin
    Result := False;
    for I := 0 to Band.ColumnCount - 1 do
      Result := Result or not Band.Columns[I].Options.Sizing;
  end;

begin
  if FixedSize then
    Result := Max(Band.Width, InternalCalculateWidth)
  else
  begin
    Result := Band.Width;
    if Result = 0 then
      Result := InternalCalculateWidth
  end;
  if Result = 0 then
     Result := cxTreeListDefWidth;
  if Result < InternalCalculateMinWidth then
    Result := InternalCalculateMinWidth;
end;

function TcxTreeListCustomBandPlace.GetItemByColumn(
  Column: TcxTreeListColumn): TcxTreeListColumnPlace;
var
  Index: Integer;
begin
  Index := ColumnIndexes[Column];
  //Index := IndexOf(Column);
  if Index <> -1 then // might be -1 when we are in loading stage (Building report while loading form)
    Result := Items[Index]
  else
    Result := nil;
end;

procedure TcxTreeListCustomBandPlace.AddItems;
var
  I: Integer;
begin
  for I := 0 to Formatter.ColumnCount - 1 do
    CreateItem(Formatter.Columns[I]);
end;

procedure TcxTreeListCustomBandPlace.AssignWidth;
begin
  Width := Width;
end;

function TcxTreeListCustomBandPlace.CalculateHeight: Integer;
begin
  Result := Controller.CalculateItemHeight(Self);
end;

function TcxTreeListCustomBandPlace.CalculateItemLeftBound(
  AnItem: TcxTreeListColumnPlace): Integer;
var
  I: Integer;
begin
  Result := 0;
  for I := 0 to AnItem.Index - 1 do
    Inc(Result, Items[I].Width);
end;

procedure TcxTreeListCustomBandPlace.CalculateItemsWidth;
var
  AAutoWidthObject: TcxAutoWidthObject;
  I: Integer;
begin
  AAutoWidthObject := TcxAutoWidthObject.Create(ItemCount);
  try
    for I := 0 to ItemCount - 1 do
      Items[I].InitAutoWidthItem(AAutoWidthObject.AddItem);
    AAutoWidthObject.AvailableWidth := ItemsAvailableWidth;
    AAutoWidthObject.Calculate;

    for I := 0 to ItemCount - 1 do
      Items[I].Width := AAutoWidthObject[I].AutoWidth;
  finally
    AAutoWidthObject.Free;
  end;
end;

function TcxTreeListCustomBandPlace.CalculateLeftBound: Integer;
begin
  Result := Controller.CalculateItemLeftBound(Self);
end;

function TcxTreeListCustomBandPlace.CalculateLevelHeight: Integer;
begin
  if Adapter.OptionsView.BandLineHeight > 0 then
    Result := Adapter.OptionsView.BandLineHeight
  else
    Result := CalculateLineHeight;// * BandLineCount;
end;

function TcxTreeListCustomBandPlace.CalculateLineHeight: Integer;
begin
  Result := 0;
  Formatter.CalculateHeight(ViewParams, Result);
end;

function TcxTreeListCustomBandPlace.CalculateMinWidth: Integer;
begin
  Result := Max(InternalCalculateMinWidth, Band.MinWidth);
end;

function TcxTreeListCustomBandPlace.CalculateTopBound: Integer;
begin
  Result := Controller.CalculateItemTopBound(Self);
end;

function TcxTreeListCustomBandPlace.CreateItem(
  AColumn: TcxTreeListColumn): TcxTreeListColumnPlace;
begin
  Result := TcxTreeListColumnPlace.Create(Self, AColumn);
  FItems.Add(Result);
end;

procedure TcxTreeListCustomBandPlace.InitAutoWidthItem(
  AnItem: TcxAutoWidthItem);
begin
  AnItem.Fixed := IsFixed;
  AnItem.MinWidth := MinWidth;
  AnItem.Width := Width;
end;

function TcxTreeListCustomBandPlace.GetRowCount: Integer;
begin
  Result := 0;
end;

function TcxTreeListCustomBandPlace.GetItemsAutoWidth: Boolean;
begin
  Result := Formatter.AutoWidth;
end;

function TcxTreeListCustomBandPlace.GetItemsAvailableWidth: Integer;
begin
  Result := Formatter.AvailableWidth;
end;

function TcxTreeListCustomBandPlace.InternalCalculateMinWidth: Integer;
begin
  Result := 0;
end;

function TcxTreeListCustomBandPlace.InternalCalculateWidth: Integer;
begin
  Result := 0;
end;

function TcxTreeListCustomBandPlace.GetColumnIndex(
  AColumn: TcxTreeListColumn): Integer;
var
  AColumnIndex, AIndexCount, I: Integer;
begin
  AColumnIndex := AColumn.ItemIndex;
  AIndexCount := FColumnIndexes.Count;
  if AColumnIndex > AIndexCount - 1 then
  begin
    FColumnIndexes.Count := AColumnIndex + 1;
    for I := AIndexCount to FColumnIndexes.Count - 1 do
      FColumnIndexes[I] := TObject(-1);
  end;
  Result := Integer(FColumnIndexes[AColumnIndex]);
  if Result = -1 then
  begin
    FColumnIndexes[AColumnIndex] := TObject(IndexOf(AColumn));
    Result := Integer(FColumnIndexes[AColumnIndex]);
  end;
end;

function TcxTreeListCustomBandPlace.GetBounds: TRect;
begin
  Result := MakeBounds(LeftBound, TopBound, Width, Height);
end;

function TcxTreeListCustomBandPlace.GetExpandable: Boolean;
begin
  Result := Band.ActuallyExpandable;
end;

function TcxTreeListCustomBandPlace.GetHeight: Integer;
begin
  if FHeight = -1 then
    FHeight := CalculateHeight;
  Result := FHeight;
end;

function TcxTreeListCustomBandPlace.GetIndex: Integer;
begin
  if Parent <> nil then
    Result := Parent.IndexOf(Self)
  else
    Result := Controller.RootIndexOf(Self);  
end;

function TcxTreeListCustomBandPlace.GetIsFixed: Boolean;
begin
  Result := not Band.Options.Sizing;
end;

function TcxTreeListCustomBandPlace.GetItem(AIndex: Integer): TcxTreeListColumnPlace;
begin
  Result := TcxTreeListColumnPlace(FItems[AIndex]);
end;

function TcxTreeListCustomBandPlace.GetItemCount: Integer;
begin
  Result := FItems.Count;
end;

function TcxTreeListCustomBandPlace.GetLeftBound: Integer;
begin
  if FLeftBound = -1 then
    FLeftBound := CalculateLeftBound;
  Result := FLeftBound;
end;

function TcxTreeListCustomBandPlace.GetLevelIndex: Integer;
begin
  Result := Band.Level;
end;

function TcxTreeListCustomBandPlace.GetMinWidth: Integer;
begin
  if FMinWidth = -1 then
    FMinWidth := CalculateMinWidth;
  Result := FMinWidth;  
end;

function TcxTreeListCustomBandPlace.GetTopBound: Integer;
begin
  if FTopBound = -1 then
    FTopBound := CalculateTopBound;
  Result := FTopBound;
end;

function TcxTreeListCustomBandPlace.GetViewParams: TdxReportItemViewParams;
begin
  Result := Formatter.GetBandItemViewParams(Band);
end;

{ TcxTreeListBandPlace }

constructor TcxTreeListBandPlace.Create(AnOwner: TcxTreeListItemPlaceController;
  AParent: TcxTreeListBandPlace; ABand: TcxTreeListBand);
begin
  inherited;
  FChildItems := TList.Create;
end;

destructor TcxTreeListBandPlace.Destroy;
begin
  FreeAndNil(FChildItems);
  inherited;
end;

function TcxTreeListBandPlace.IndexOf(
  AnItem: TcxTreeListCustomBandPlace): Integer;
begin
  Result := FChildItems.IndexOf(AnItem);
end;

procedure TcxTreeListBandPlace.Refresh;
begin
  inherited Refresh;
  RefreshChildItems;
end;

function TcxTreeListBandPlace.GetRowCount: Integer;
begin
  Result := 1;
end;

function TcxTreeListBandPlace.InternalCalculateMinWidth: Integer;
var
  I: Integer;
begin
  Result := 0;  
  for I := 0 to ChildItemCount - 1 do
    Inc(Result, ChildItems[I].MinWidth);
end;

function TcxTreeListBandPlace.InternalCalculateWidth: Integer;
var
  I: Integer;
begin
  Result := 0;
  for I := 0 to ChildItemCount - 1 do
    Inc(Result, ChildItems[I].Width);
end;

procedure TcxTreeListBandPlace.WidthChanged;
begin
  inherited WidthChanged;
  CalculateChildItemWidths;
end;

procedure TcxTreeListBandPlace.CalculateChildItemWidths;
var
  AAutoWidthObject: TcxAutoWidthObject;
  I: Integer;
begin
  AAutoWidthObject := TcxAutoWidthObject.Create(ChildItemCount);
  try
    for I := 0 to ChildItemCount - 1 do
      ChildItems[I].InitAutoWidthItem(AAutoWidthObject.AddItem);
    AAutoWidthObject.AvailableWidth := Width;
    AAutoWidthObject.Calculate;
      
    for I := 0 to ChildItemCount - 1 do
      ChildItems[I].Width := AAutoWidthObject[I].AutoWidth;
  finally
    AAutoWidthObject.Free;
  end;
end;

procedure TcxTreeListBandPlace.RefreshChildItems;
var
  I: Integer;
  ABandAccess: TcxTreeListBandAccess;
begin
  ABandAccess := TcxTreeListBandAccess(Band);
  FChildItems.Count := ABandAccess.ChildVisibleBands.Count;
  for I := 0 to FChildItems.Count - 1 do
  begin
    FChildItems[I] := Controller.ItemsByBand[ABandAccess.ChildVisibleBands[I]];
    ChildItems[I].FParent := Self;
  end;  
end;

function TcxTreeListBandPlace.GetChildItem(
  Index: Integer): TcxTreeListCustomBandPlace;
begin
  Result := TcxTreeListCustomBandPlace(FChildItems[Index]);
end;

function TcxTreeListBandPlace.GetChildItemCount: Integer;
begin
  Result := FChildItems.Count;
end;

{ TcxTreeListBottomBandPlace }

procedure TcxTreeListBottomBandPlace.AddItems;
var
  I, J: Integer;
  ARow: TcxTreeListBandRow;
begin
  for I := 0 to Band.BandRows.VisibleItemCount - 1 do
  begin
    ARow := Band.BandRows.VisibleItems[I];
    for J := 0 to ARow.VisibleItemCount - 1 do
      CreateItem(ARow.VisibleItems[J]);
  end;
end;

function TcxTreeListBottomBandPlace.CalculateItemLeftBound(
  AnItem: TcxTreeListColumnPlace): Integer;
var
  ARow: TcxTreeListBandRow;
  I: Integer;
  ACurrentItem: TcxTreeListColumnPlace;
begin
  Result := LeftBound;
  ARow := AnItem.Column.Position.Row;
  for I := 0 to AnItem.Column.Position.VisibleColIndex - 1 do
  begin
    ACurrentItem := ItemsByColumn[ARow.VisibleItems[I]];
    Inc(Result, ACurrentItem.Width);
  end;  
end;

procedure TcxTreeListBottomBandPlace.CalculateItemsWidth;
var
  I, J: Integer;
  ARow: TcxTreeListBandRow;
  AAutoWidthObject: TcxAutoWidthObject;
  AColumn: TcxTreeListColumn;
begin
  for I := 0 to Band.BandRows.VisibleItemCount - 1 do
  begin
    ARow := Band.BandRows.VisibleItems[I];
    AAutoWidthObject := TcxAutoWidthObject.Create(ARow.VisibleItemCount);
    try
      for J := 0 to ARow.VisibleItemCount - 1 do
        ItemsByColumn[ARow.VisibleItems[J]].InitAutoWidthItem(AAutoWidthObject.AddItem);
      AAutoWidthObject.AvailableWidth := ItemsAvailableWidth;
      AAutoWidthObject.Calculate;
        
      for J := 0 to ARow.VisibleItemCount - 1 do
      begin
        AColumn := ARow.VisibleItems[J];
        ItemsByColumn[AColumn].Width := AAutoWidthObject[J].AutoWidth;
      end;  
    finally
      AAutoWidthObject.Free;
    end;
  end;    
end;

function TcxTreeListBottomBandPlace.GetItemsAutoWidth: Boolean;
begin
  Result := True;
end;

function TcxTreeListBottomBandPlace.GetItemsAvailableWidth: Integer;
begin
  Result := Width;
end;

function TcxTreeListBottomBandPlace.GetRowCount: Integer;
begin
  Result := Controller.LevelCount - LevelIndex;
end;

function TcxTreeListBottomBandPlace.InternalCalculateMinWidth: Integer;
var
  I, V, J: Integer;
  ARow: TcxTreeListBandRow;
  AColumn: TcxTreeListColumn;
begin
  Result := 0;
  for I := 0 to Band.BandRows.VisibleItemCount - 1 do
  begin
    V := 0;
    ARow := Band.BandRows.VisibleItems[I];
    for J := 0 to ARow.VisibleItemCount - 1 do
    begin
      AColumn := ARow.VisibleItems[J];
      Inc(V, AColumn.MinWidth);
    end;
    if Result < V then Result := V;
  end;
end;

function TcxTreeListBottomBandPlace.InternalCalculateWidth: Integer;
var
  I, V, J: Integer;
  ARow: TcxTreeListBandRow;
  AColumn: TcxTreeListColumn;
begin
  Result := 0;
  for I := 0 to Band.BandRows.VisibleItemCount - 1 do
  begin
    V := 0;
    ARow := Band.BandRows.VisibleItems[I];
    for J := 0 to ARow.VisibleItemCount - 1 do
    begin
      AColumn := ARow.VisibleItems[J];
      Inc(V, AColumn.Width);
    end;  
    if Result < V then Result := V;
  end;
end;

procedure TcxTreeListBottomBandPlace.WidthChanged;
begin
  inherited;
  CalculateItemsWidth;
end;

{ TcxTreeListItemPlaceController }

constructor TcxTreeListItemPlaceController.Create(
  AFormatter: TcxTreeListReportLinkFormatter);
begin
  inherited Create(AFormatter);
  FBottomItems := TList.Create;
  FItems := TObjectList.Create;
  FRootItems := TList.Create;
  FLevelHeights := TList.Create;
  
  FHeight := -1;
  FLevelCount := -1;
end;

destructor TcxTreeListItemPlaceController.Destroy;
begin
  FreeAndNil(FLevelHeights);
  FreeAndNil(FRootItems);
  FreeAndNil(FItems);
  FreeAndNil(FBottomItems);
  inherited;
end;

procedure TcxTreeListItemPlaceController.Calculate;
begin
  CalculateLevelHeights;
  CalculateItemWidths;
end;

procedure TcxTreeListItemPlaceController.Refresh;
begin
  FItems.Clear;
  AddItems;
  RefreshRootItems;
  RefreshBottomItems;
  RefreshItems;
end;

function TcxTreeListItemPlaceController.BottomIndexOf(AnItem: TcxTreeListCustomBandPlace): Integer;
begin
  Result := FBottomItems.IndexOf(AnItem);
end;

function TcxTreeListItemPlaceController.IndexOf(
  AnItem: TcxTreeListCustomBandPlace): Integer;
begin
  Result := FItems.IndexOf(AnItem);
end;

function TcxTreeListItemPlaceController.IndexOf(
  ABand: TcxTreeListBand): Integer;
begin
  for Result := 0 to ItemCount - 1 do
    if Items[Result].Band = ABand then
      Exit;
  Result := -1;  
end;

function TcxTreeListItemPlaceController.RootIndexOf(
  ABand: TcxTreeListBand): Integer;
begin
  for Result := 0 to RootItemCount - 1 do
    if RootItems[Result].Band = ABand then
      Exit;
  Result := -1;
end;

function TcxTreeListItemPlaceController.RootIndexOf(
  AnItem: TcxTreeListCustomBandPlace): Integer;
begin
  Result := FRootItems.IndexOf(AnItem);
end;

function TcxTreeListItemPlaceController.CalculateHeaderLineCount: Integer;
var
  I, V: Integer;
begin
  Result := -1;
  for I := 0 to BottomItemCount - 1 do 
  begin
    V := BottomItems[I].HeaderLineCount;
    if Result < V then Result := V;
  end;
end;

function TcxTreeListItemPlaceController.CalculateWidth: Integer;
var
  I: Integer;
begin
  Result := 0;
  for I := 0 to RootItemCount - 1 do
    Inc(Result, RootItems[I].Width);
end;

function TcxTreeListItemPlaceController.GetItemByColumn(
  AColumn: TcxTreeListColumn): TcxTreeListColumnPlace;
var
  ABandPlace: TcxTreeListCustomBandPlace;
begin
  ABandPlace := ItemsByBand[TcxTreeListColumn(AColumn).Position.Band];
  if ABandPlace <> nil then
    Result := ABandPlace.ItemsByColumn[AColumn]
  else
    Result := nil;
end;

procedure TcxTreeListItemPlaceController.AddItems;
var
  I: Integer;
begin
  FItems.Count := Formatter.BandCount;
  for I := 0 to ItemCount - 1 do
    FItems[I] := CreateItem(Formatter.Bands[I]);
end;

function TcxTreeListItemPlaceController.CreateItem(
  ABand: TcxTreeListBand): TcxTreeListCustomBandPlace;
begin
  Result := GetItemClass(ABand).Create(Self, nil, ABand);
end;

function TcxTreeListItemPlaceController.GetItemClass(
  ABand: TcxTreeListBand): TcxTreeListCustomBandPlaceClass;
begin
  if ABand.IsBottom then
    Result := TcxTreeListBottomBandPlace
  else
    Result := TcxTreeListBandPlace;
end;

procedure TcxTreeListItemPlaceController.RefreshBottomItems;
var
  I: Integer;
begin
  FBottomItems.Count := Adapter.BottomBandCount;
  for I := 0 to BottomItemCount - 1 do 
    FBottomItems[I] := ItemsByBand[Adapter.BottomBands[I]];
end;

procedure TcxTreeListItemPlaceController.RefreshItems;
var
  I: Integer;
begin 
  for I := 0 to ItemCount - 1 do
    Items[I].Refresh;
end;

procedure TcxTreeListItemPlaceController.RefreshRootItems;
var
  I: Integer;
begin 
  FRootItems.Count := Adapter.RootBandCount;
  for I := 0 to RootItemCount - 1 do
    FRootItems[I] := ItemsByBand[Adapter.RootBands[I]];
end;

function TcxTreeListItemPlaceController.CalculateHeight: Integer;
var
  I: Integer;
begin
  Result := 0;
  for I := 0 to LevelCount - 1 do 
    Inc(Result, LevelHeights[I]);
end;

function TcxTreeListItemPlaceController.CalculateItemHeight(
  AnItem: TcxTreeListCustomBandPlace): Integer;
var
  I: Integer;
begin
  Result := 0;
  for I := AnItem.LevelIndex to AnItem.LevelIndex + AnItem.RowCount - 1 do 
    Inc(Result, LevelHeights[I]);
end;

function TcxTreeListItemPlaceController.CalculateItemLeftBound(
  AnItem: TcxTreeListCustomBandPlace): Integer;
var
  I: Integer;
begin
  if AnItem.Parent <> nil then
  begin
    Result := AnItem.Parent.LeftBound;
    for I := 0 to AnItem.Index - 1 do
      Inc(Result, AnItem.Parent.ChildItems[I].Width);
  end
  else
  begin
    Result := 0;
    for I := 0 to AnItem.Index - 1 do
      Inc(Result, RootItems[I].Width);
  end;
end;

function TcxTreeListItemPlaceController.CalculateItemTopBound(
  AnItem: TcxTreeListCustomBandPlace): Integer;
var
  I: Integer;
begin
  Result := 0;
  for I := 0 to AnItem.LevelIndex - 1 do
    Inc(Result, LevelHeights[I]);
end;

function TcxTreeListItemPlaceController.CalculateLevelCount: Integer;
var
  I, V: Integer;
begin
  Result := 0;
  if ItemCount <> 0 then
  begin
    for I := 0 to ItemCount - 1 do
    begin
      V := Items[I].LevelIndex;
      if Result < V then Result := V;
    end;
    Inc(Result);
  end;
end;

procedure TcxTreeListItemPlaceController.CalculateItemWidths;
var
  I: Integer;
  AutoWidthObject: TcxAutoWidthObject;
begin
  for I := 0 to RootItemCount - 1 do 
    RootItems[I].AssignWidth;

  if AutoWidth then
  begin
    AutoWidthObject := TcxAutoWidthObject.Create(RootItemCount);
    try
      for I := 0 to RootItemCount - 1 do
        RootItems[I].InitAutoWidthItem(AutoWidthObject.AddItem);
      AutoWidthObject.AvailableWidth := AvailableWidth;
      AutoWidthObject.Calculate;

      for I := 0 to RootItemCount - 1 do
        RootItems[I].Width := AutoWidthObject[I].AutoWidth;
    finally
      AutoWidthObject.Free;
    end;
  end;
end;

procedure TcxTreeListItemPlaceController.CalculateLevelHeights;
var
  I, V: Integer;
  AItem: TcxTreeListCustomBandPlace;
begin
  FLevelHeights.Count := LevelCount;
  for I := 0 to ItemCount - 1 do
  begin
    AItem := Items[I];
    V := AItem.CalculateLevelHeight;
    if LevelHeights[AItem.LevelIndex] < V then
      LevelHeights[AItem.LevelIndex] := V;
  end;
end;

function TcxTreeListItemPlaceController.GetAutoWidth: Boolean;
begin
  Result := Formatter.AutoWidth or Adapter.AutoWidth;
end;

function TcxTreeListItemPlaceController.GetAvailableWidth: Integer;
begin
  Result := Formatter.AvailableWidth;
end;

function TcxTreeListItemPlaceController.GetBottomItem(
  AIndex: Integer): TcxTreeListCustomBandPlace;
begin
  Result := TcxTreeListCustomBandPlace(FBottomItems[AIndex]);
end;

function TcxTreeListItemPlaceController.GetBottomItemCount: Integer;
begin
  Result := FBottomItems.Count;
end;

function TcxTreeListItemPlaceController.GetHeight: Integer;
begin
  if FHeight = -1 then
    FHeight := CalculateHeight;
  Result := FHeight;
end;

function TcxTreeListItemPlaceController.GetItem(
  AIndex: Integer): TcxTreeListCustomBandPlace;
begin
  Result := TcxTreeListCustomBandPlace(FItems[AIndex]);
end;

function TcxTreeListItemPlaceController.GetItemByBand(
  ABand: TcxTreeListBand): TcxTreeListCustomBandPlace;
var
  AIndex: Integer;
begin
  AIndex := IndexOf(ABand);
  if AIndex <> -1 then
    Result := Items[IndexOf(ABand)]
  else
    Result := nil;
end;

function TcxTreeListItemPlaceController.GetItemCount: Integer;
begin
  Result := FItems.Count;
end;

function TcxTreeListItemPlaceController.GetLevelCount: Integer;
begin
  if FLevelCount = -1 then
    FLevelCount := CalculateLevelCount;
  Result := FLevelCount;
end;

function TcxTreeListItemPlaceController.GetLevelHeight(
  AIndex: Integer): Integer;
begin
  Result := Integer(FLevelHeights[AIndex]);
end;

function TcxTreeListItemPlaceController.GetRootItem(
  AIndex: Integer): TcxTreeListCustomBandPlace;
begin
  Result := TcxTreeListCustomBandPlace(FRootItems[AIndex]);
end;

function TcxTreeListItemPlaceController.GetRootItemCount: Integer;
begin
  Result := FRootItems.Count;
end;

procedure TcxTreeListItemPlaceController.SetLevelHeight(AIndex,
  AValue: Integer);
begin
  FLevelHeights[AIndex] := TObject(AValue);
end;

{ TcxTreeListReportLinkFormatter }

constructor TcxTreeListReportLinkFormatter.Create(ABuilder: TcxTreeListReportLinkBuilder);
begin
  inherited;
  FFont := TFont.Create;
  FLookAndFeelItems := TList.Create;
  FNodes := TList.Create;
  FColumns := TList.Create;
  FBands := TList.Create;
  CreateNodeList;
  FTransparentColor := dxPSCore.dxDefaultContentColor;
  FItemPlaceController := TcxTreeListItemPlaceController.Create(Self);
end;

destructor TcxTreeListReportLinkFormatter.Destroy;
begin
  FreeAndNil(FItemPlaceController);
  FreeAndNil(FBands);
  FreeAndNil(FColumns);
  FreeAndNil(FNodes);
  FreeAndNil(FLookAndFeelItems);
  FreeAndNil(FFont);
  inherited;
end;

function TcxTreeListReportLinkFormatter.Adapter: TcxTreeListAdapter;
begin
  Result := Builder.Adapter;
end;

procedure TcxTreeListReportLinkFormatter.DoInitializeHost(AHost: TdxReportCell);
begin
  AHost.CellSides := [];
  AHost.Transparent := True;
end;

procedure TcxTreeListReportLinkFormatter.DoInitializeBandItem(AnItem: TAbstractdxReportCellData; 
  AnIndex: Integer);
var
  Band: TcxTreeListBand;
begin
  Band := Bands[AnIndex];
  SetViewParams(AnItem, GetBandItemViewParams(Band));
  RegisterLookAndFeelItem(AnItem, cesRaised);
  if HasBackgroundBitmap(tlsv_BandHeader) then
    AnItem.BackgroundBitmapIndex := GetBackgroundBitmapIndex(tlsv_BandHeader);
  
  with AnItem as TdxReportCellImage do
  begin
    Data := Integer(Band);
    EndEllipsis := Band.Caption.ShowEndEllipsis;
    if not Band.Caption.Glyph.Empty then
    begin
      Image := Band.Caption.Glyph;
      ImageLayout := HeaderImageLayoutMap[Band.Caption.GlyphAlignHorz, Band.Caption.GlyphAlignVert];
      ImageTransparent := True;
      IsTextDrawnForCenteredImage := True;
      IsTextShiftedForHorizontallyCenteredImage := not (ImageLayout in [ilImageTopCenter, ilImageCenterCenter, ilImageBottomCenter]);
    end;
    Multiline := Band.Caption.Multiline;
    Text := Band.Caption.Text;
    TextAlignX := TextAlignXMap[Band.Caption.AlignHorz];
    TextAlignY := TextAlignYMap[Band.Caption.AlignVert];
  end;  
end;

procedure TcxTreeListReportLinkFormatter.DoInitializeBandRow(ARow: TdxReportCell);
begin
  //SetViewParams(ARow, GetBandBackgroundViewParams);
  ARow.Transparent := True; //???
  ARow.Data := Integer(TcxTreeListBandAttribute);
end;

procedure TcxTreeListReportLinkFormatter.DoReportLinkInitializeBandItem(AnItem: TAbstractdxReportCellData; 
  AIndex: Integer);
begin
  ReportLink.DoInitializeBandCell(Bands[AIndex], TdxReportCellImage(AnItem));
end;  

function TcxTreeListReportLinkFormatter.GetBandBackgroundViewParams: TdxReportItemViewParams;
begin
  Result.NativeParams := Adapter.GetBandBackgroundViewParams;
  Result.CellSides := [];
  Result.FontStyle := [];
  Result.Transparent := True;
end;

function TcxTreeListReportLinkFormatter.GetBandItemBounds(Index: Integer): TRect;
var
  Item: TcxTreeListCustomBandPlace;
begin
  Item := ItemPlaceController.ItemsByBand[Bands[Index]];
  if Item <> nil then
    Result := Item.Bounds
  else
    Result := dxPSGlbl.NullRect;
end;

function TcxTreeListReportLinkFormatter.GetBandItemClass(Index: Integer): TdxReportCellTextClass;
begin
  Result := TdxReportCellImage;
end;

function TcxTreeListReportLinkFormatter.GetBandItemViewParams(ABand: TcxTreeListBand): TdxReportItemViewParams;
begin
  FillChar(Result, SizeOf(Result), 0);
  if ReportLink.OptionsFormatting.UseNativeStyles then 
    ReportLink.Styles.GetBandHeaderParams(ABand, Result.NativeParams)
  else
    Result.NativeParams := Adapter.GetBandHeaderViewParams(ABand);

  if UseLookAndFeelColors and Adapter.CanUseLookAndFeelColors then
    if ABand <> nil then
    begin
      Result.NativeParams.Color := Adapter.ThemedBandHeaderItemColor;
      Result.NativeParams.TextColor := Adapter.ThemedBandHeaderItemTextColor;
    end;
    
  Result.CellSides := csAll;
  Result.FontStyle := [];
  Result.Transparent := IsColorTransparent(Result.NativeParams.Color); // ReportLink.FixedTransparent;
end;

procedure TcxTreeListReportLinkFormatter.DoInitializeNodeCheck(AnItem: TdxCustomReportCellCheck;
  ANode: TcxTreeListNode; AnIndex: Integer);
begin
  SetViewParams(AnItem, GetNodeCheckViewParams(ANode, AnIndex));
  if HasBackgroundBitmap(tlsv_Content) then
    AnItem.BackgroundBitmapIndex := GetBackgroundBitmapIndex(tlsv_Content);
  AnItem.Checked := ANode.CheckState <> cbsUnchecked;
  AnItem.Enabled := ANode.CheckState <> cbsGrayed;
  TdxReportCellCheck(AnItem).FlatBorder := ReportLink.OptionsRefinements.FlatCheckMarks;
end;

function TcxTreeListReportLinkFormatter.GetNodeCheckCellSides(ANode: TcxTreeListNode;
  AnIndex: Integer): TdxCellSides;
begin
  Result := [];
  if ReportLink.OptionsView.Borders and not Adapter.HasStateImages(ANode) and
    not Adapter.HasImages(ANode) then
      Result := [csRight];
end;

function TcxTreeListReportLinkFormatter.GetNodeCheckClass(ANode: TcxTreeListNode): TdxCustomReportCellCheckClass;
begin
  case ANode.Parent.CheckGroupType of
    ncgCheckGroup:
      Result := TdxReportCellCheck
  else {ncgRadioGroup}
    Result := TdxReportCellRadio;
  end;
end;

function TcxTreeListReportLinkFormatter.GetNodeCheckViewParams(ANode: TcxTreeListNode;
  AnIndex: Integer): TdxReportItemViewParams;
begin
  FillChar(Result, SizeOf(Result), 0);
  if ReportLink.OptionsFormatting.UseNativeStyles then
    if CanProcessSelectionStyle(ANode) then
      ReportLink.Styles.GetSelectionParams(Result.NativeParams)
    else
      ReportLink.Styles.GetImagesParams(ANode, Result.NativeParams)
  else
    if CanProcessSelectionStyle(ANode) then
      Result.NativeParams := Adapter.GetSelectionViewParams
    else
      Result.NativeParams := Adapter.GetIndentViewParams(ANode, AnIndex);
    
  Result.CellSides := GetNodeCheckCellSides(ANode, AnIndex);
  Result.Transparent := IsColorTransparent(Result.NativeParams.Color);
end;

procedure TcxTreeListReportLinkFormatter.DoInitializeFooterCell(AnItem: TAbstractdxReportCellData;
  AColumn: TcxTreeListColumn; ACellIndex: Integer; ANode: TcxTreeListNode);
var
  ASummaryItem: TcxTreeListSummaryItem;
  I, AColumnIndex: Integer;
begin
  AColumnIndex := FColumns.IndexOf(AColumn);
  SetViewParams(AnItem, GetFooterCellViewParams(AColumn));
  RegisterLookAndFeelItem(AnItem, cesSunken);
  if HasBackgroundBitmap(tlsv_ColumnFooter) then 
    AnItem.BackgroundBitmapIndex := GetBackgroundBitmapIndex(tlsv_ColumnFooter);

  ASummaryItem := GetSummaryItems(ANode)[AColumnIndex, ACellIndex];

  with AnItem as TdxReportCellString do
  begin
    Data := Integer(AColumn);
    Multiline := AColumn.Position.LineCount > 1;
    TextAlignX := TextAlignXMap[ASummaryItem.AlignHorz];
    TextAlignY := TextAlignYMap[ASummaryItem.AlignVert];
    if (GetFooterCellCount(AColumn, ANode) <> 1) or
      (Length(GetSummaryItems(ANode)[AColumnIndex]) = 1) then
      Text := ANode.FooterSummaryTexts[ASummaryItem.AbsoluteIndex]
    else
      for I := 0 to High(GetSummaryItems(ANode)[AColumnIndex]) do
      begin
        if Text <> '' then
          Text := Text + ';';
        Text := Text + ANode.FooterSummaryTexts[GetSummaryItems(ANode)[AColumnIndex, I].AbsoluteIndex];
      end;
    end;
end;

procedure TcxTreeListReportLinkFormatter.DoInitializeFooterIndent(AnItem: TdxReportCellExpandButton;
  AnIndex, AnIndentCount: Integer; ANode: TcxTreeListNode);
begin
  SetViewParams(AnItem, GetNodeIndentViewParams(ANode, AnIndex, AnIndentCount));
  if HasBackgroundBitmap(tlsv_Content) then 
    AnItem.BackgroundBitmapIndex := GetBackgroundBitmapIndex(tlsv_Content);
  AnItem.Data := MakeIndentIndex(AnIndex);
  AnItem.ShowButton := False;
  if ReportLink.OptionsView.Borders and (AnIndex = AnIndentCount - 1) then
    AnItem.CellSides := [csRight]
  else
    AnItem.CellSides := [];
  if ReportLink.OptionsView.TreeLines then
    AnItem.TreeLineMode := GetNodeFooterIndentTreeLineMode(AnIndex, AnIndentCount, ANode);
end;

procedure TcxTreeListReportLinkFormatter.DoInitializeFooterBandedRow(
  ARow: TdxReportCell; AIndentCount: Integer);
var
  ABandPlace: TcxTreeListCustomBandPlace;
  AIndex, ALastIndex: Integer;
begin
  SetViewParams(ARow, GetFooterRowViewParams);
  RegisterLookAndFeelItem(ARow, cesRaised);
  ABandPlace := TcxTreeListCustomBandPlace(ARow.Data);

  ARow.CellSides := csTopBottom;
  AIndex := ABandPlace.Controller.BottomIndexOf(ABandPlace);
  ALastIndex := ABandPlace.Controller.BottomItemCount - 1;
  if (AIndex = 0) or ABandPlace.Expandable and (AIndentCount > 0) then
    ARow.CellSides := ARow.CellSides + [csLeft];
  if (AIndex = ALastIndex) or
    ABandPlace.Controller.BottomItems[AIndex + 1].Expandable and (AIndentCount > 0) then
    ARow.CellSides := ARow.CellSides + [csRight];
end;

procedure TcxTreeListReportLinkFormatter.DoInitializeFooterRow(ARow: TdxReportCell);
begin
  ARow.Transparent := True;
  ARow.Data := Integer(TcxTreeListFooterAttribute);
  ARow.CellSides := csLeftRight;
end;

procedure TcxTreeListReportLinkFormatter.DoReportLinkInitializeFooterCell(AnItem: TAbstractdxReportCellData; 
  AColumnIndex, ACellIndex: Integer);
begin
  ReportLink.DoInitializeFooterCell(Columns[AColumnIndex], ACellIndex,
    TdxReportCellString(AnItem));
end;  

function TcxTreeListReportLinkFormatter.GetFooterCellBounds(AColumn: TcxTreeListColumn;
  ACellIndex, AIndent: Integer): TRect;
var
  AItem: TcxTreeListColumnPlace;
  AColumnAccess: TcxTreeListColumnAccess;
begin
  AItem := ItemPlaceController.ItemsByColumn[AColumn];
  if AItem <> nil then
  begin
    Result := AItem.FooterCellBounds[ACellIndex];
    AColumnAccess := TcxTreeListColumnAccess(AColumn);
    if AColumnAccess.HasIndent then
      Inc(Result.Left, AIndent);
  end
  else
    Result := dxPSGlbl.NullRect;
end;

function TcxTreeListReportLinkFormatter.GetFooterCellClass: TdxReportCellTextClass; 
begin
  Result := TdxReportCellString;
end;

function TcxTreeListReportLinkFormatter.GetFooterCellViewParams(AColumn: TcxTreeListColumn): TdxReportItemViewParams;
begin
  FillChar(Result, SizeOf(Result), 0);
  if ReportLink.OptionsFormatting.UseNativeStyles then 
    ReportLink.Styles.GetColumnFooterParams(nil, AColumn, Result.NativeParams)
  else
    Result.NativeParams := Adapter.GetColumnFooterViewParams(AColumn);

  if UseLookAndFeelColors and Adapter.CanUseLookAndFeelColors then
    if AColumn <> nil then
    begin
      Result.NativeParams.Color := Adapter.ThemedFooterItemColor;
      Result.NativeParams.TextColor := Adapter.ThemedFooterItemTextColor;
    end;
    
  Result.CellSides := csAll;
  Result.FontStyle := [];    
  Result.Transparent := IsColorTransparent(Result.NativeParams.Color);
end;

function TcxTreeListReportLinkFormatter.GetNodeFooterIndentTreeLineMode(AnIndex, AnIndentCount: Integer;
  ANode: TcxTreeListNode): TdxPSTreeLineMode;

  function GetParentWithCertainLevel(ALevel: Integer): TcxTreeListNode;
  begin
    Result := ANode;
    while Result.Level > ALevel do
      Result := Result.Parent;
  end;

begin
  if not Adapter.ShowRoot then
    Inc(AnIndex);
  if IsNodeLastChild(GetParentWithCertainLevel(AnIndex)) then
    Result := tlmNone
  else
    Result := tlmVertical
end;

function TcxTreeListReportLinkFormatter.GetFooterRowViewParams: TdxReportItemViewParams;
begin
  FillChar(Result, SizeOf(Result), 0);
  if ReportLink.OptionsFormatting.UseNativeStyles then 
    ReportLink.Styles.GetFooterRowParams(Result.NativeParams)
  else
    Result.NativeParams := Adapter.GetFooterRowViewParams; 
    
  Result.CellSides := csAll;
  Result.FontStyle := [];
  Result.Transparent := IsColorTransparent(Result.NativeParams.Color);
end;

procedure TcxTreeListReportLinkFormatter.DoInitializeHeaderItem(AnItem: TAbstractdxReportCellData;
  AnIndex: Integer);
var
  AColumn: TcxTreeListColumn;
begin
  AColumn := Columns[AnIndex];
  SetViewParams(AnItem, GetHeaderItemViewParams(AColumn));
  RegisterLookAndFeelItem(AnItem, cesRaised);
  if HasBackgroundBitmap(tlsv_ColumnHeader) then
    AnItem.BackgroundBitmapIndex := GetBackgroundBitmapIndex(tlsv_ColumnHeader);

  with AnItem as TdxReportCellImage do
  begin
    Data := Integer(AColumn);
    EndEllipsis := AColumn.Caption.ShowEndEllipsis;
    if not AColumn.Caption.Glyph.Empty then
    begin
      Image := AColumn.Caption.Glyph;
      ImageLayout := HeaderImageLayoutMap[AColumn.Caption.GlyphAlignHorz, AColumn.Caption.GlyphAlignVert];
      IsTextDrawnForCenteredImage := True;
      IsTextShiftedForHorizontallyCenteredImage := not (ImageLayout in [ilImageTopCenter, ilImageCenterCenter, ilImageBottomCenter]);
    end;
    Multiline := AColumn.Caption.MultiLine;
    SortOrder := SortOrderMap[AColumn.SortOrder];
    Text := AColumn.Caption.Text;
    TextAlignX := TextAlignXMap[AColumn.Caption.AlignHorz];
    TextAlignY := TextAlignYMap[AColumn.Caption.AlignVert];
  end;
end;

procedure TcxTreeListReportLinkFormatter.DoInitializeHeaderRow(ARow: TdxReportCell);
begin
  SetViewParams(ARow, GetHeaderItemViewParams(nil));
  ARow.Data := Integer(TcxTreeListHeaderAttribute);
end;

procedure TcxTreeListReportLinkFormatter.DoReportLinkInitializeHeaderItem(AnItem: TAbstractdxReportCellData; 
  AIndex: Integer);
begin
  ReportLink.DoInitializeHeaderCell(Columns[AIndex], TdxReportCellImage(AnItem));
end;

function TcxTreeListReportLinkFormatter.GetHeaderItemBounds(AnIndex: Integer): TRect;
var
  AItem: TcxTreeListColumnPlace;
begin
  AItem := ItemPlaceController.ItemsByColumn[Columns[AnIndex]];
  if AItem <> nil then
    Result := AItem.HeaderCellBounds
  else
    Result := dxPSGlbl.NullRect;
end;

function TcxTreeListReportLinkFormatter.GetHeaderItemClass(AnIndex: Integer): TdxReportCellTextClass; 
begin
  Result := TdxReportCellImage;
end;

function TcxTreeListReportLinkFormatter.GetHeaderItemViewParams(AColumn: TcxTreeListColumn): TdxReportItemViewParams;
begin
  FillChar(Result, SizeOf(Result), 0);
  if ReportLink.OptionsFormatting.UseNativeStyles then 
    ReportLink.Styles.GetColumnHeaderParams(AColumn, Result.NativeParams)
  else
    Result.NativeParams := Adapter.GetColumnHeaderViewParams(AColumn);

  if UseLookAndFeelColors and Adapter.CanUseLookAndFeelColors then
    if AColumn <> nil then
    begin
      Result.NativeParams.Color := Adapter.ThemedHeaderItemColor; 
      Result.NativeParams.TextColor := Adapter.ThemedHeaderItemTextColor; 
    end;
    
  Result.CellSides := csAll;
  Result.FontStyle := [];
  Result.Transparent := IsColorTransparent(Result.NativeParams.Color); //ReportLink.FixedTransparent;
end;

procedure TcxTreeListReportLinkFormatter.DoInitializeNodeImage(AnItem: TdxReportCellGraphic; 
  ANode: TcxTreeListNode; AnIndex: Integer);
begin
  SetViewParams(AnItem, GetNodeImageViewParams(ANode, AnIndex));
  if HasBackgroundBitmap(tlsv_Content) then 
    AnItem.BackgroundBitmapIndex := GetBackgroundBitmapIndex(tlsv_Content);

  AnItem.Data := MakeIndentIndex(AnIndex);
  AnItem.DrawMode := gdmCenter;
  AnItem.ImageIndex := ANode.ImageIndex;
  AnItem.ImageList := Adapter.Images;
  AnItem.ImageTransparent := True;          
end;

procedure TcxTreeListReportLinkFormatter.DoReportLinkInitializeNodeImage(AnItem: TAbstractdxReportCellData; 
  ANode: TcxTreeListNode; AnIndex: Integer);
begin
  ReportLink.DoInitializeIndentCell(ANode, AnIndex, AnItem);
end;  

function TcxTreeListReportLinkFormatter.GetNodeImageCellSides(ANode: TcxTreeListNode; 
  AnIndex: Integer): TdxCellSides;
begin
  Result := [];
  if ReportLink.OptionsView.Borders then
      Result := [csRight];
end;

function TcxTreeListReportLinkFormatter.GetNodeImageClass: TdxReportCellGraphicClass;
begin
  Result := TdxReportCellGraphic;
end;

function TcxTreeListReportLinkFormatter.GetNodeImageViewParams(ANode: TcxTreeListNode; 
  AnIndex: Integer): TdxReportItemViewParams;
begin
  FillChar(Result, SizeOf(Result), 0);
  if ReportLink.OptionsFormatting.UseNativeStyles then
    if CanProcessSelectionStyle(ANode) then
      ReportLink.Styles.GetSelectionParams(Result.NativeParams)
    else
      ReportLink.Styles.GetImagesParams(ANode, Result.NativeParams)
  else
    if CanProcessSelectionStyle(ANode) then
      Result.NativeParams := Adapter.GetSelectionViewParams
    else
      Result.NativeParams := Adapter.GetIndentViewParams(ANode, AnIndex);
    
  Result.CellSides := GetNodeImageCellSides(ANode, AnIndex);
  Result.Transparent := IsColorTransparent(Result.NativeParams.Color); // ReportLink.FixedTransparent;
end;
  
procedure TcxTreeListReportLinkFormatter.DoInitializeNodeIndent(AnItem: TdxReportCellExpandButton; 
  AnIndex, AnIndentCount: Integer; ANode: TcxTreeListNode);
begin
  SetViewParams(AnItem, GetNodeIndentViewParams(ANode, AnIndex, AnIndentCount));
  if HasBackgroundBitmap(tlsv_Content) then 
    AnItem.BackgroundBitmapIndex := GetBackgroundBitmapIndex(tlsv_Content);

  AnItem.Data := MakeIndentIndex(AnIndex); 
  AnItem.ShowButton := (AnIndex = AnIndentCount - 1) and ANode.HasChildren and ReportLink.OptionsView.ExpandButtons;
  if AnItem.ShowButton then
    DoInitializeExpandButton(AnItem, AnIndex, AnIndentCount, ANode);
  if ReportLink.OptionsView.TreeLines then 
    AnItem.TreeLineMode := GetNodeIndentTreeLineMode(AnIndex, AnIndentCount, ANode);
end;

procedure TcxTreeListReportLinkFormatter.DoInitializeExpandButton(AnItem: TdxReportCellExpandButton; 
  AnIndex, AnIndentCount: Integer; ANode: TcxTreeListNode);
begin
  with AnItem do 
  begin
    ButtonExpanded := IsNodeExpanded(ANode);
    ButtonSize := ExpandButtonSize;
    ButtonInteriorColor := ExpandButtonColor;
    ButtonTransparent := IsColorTransparent(ButtonInteriorColor);
  end;
end;

procedure TcxTreeListReportLinkFormatter.DoReportLinkInitializeNodeIndent(AnItem: TAbstractdxReportCellData;
  AnIndex, AnIndentCount: Integer; ANode: TcxTreeListNode);
begin
  ReportLink.DoInitializeIndentCell(ANode, AnIndex, AnItem);
end;  
  
function TcxTreeListReportLinkFormatter.GetNodeIndentCellSides(ANode: TcxTreeListNode; 
  AnIndex, AnIndentCount: Integer): TdxCellSides;
begin
  Result := [];
  if ReportLink.OptionsView.Borders and (AnIndex = AnIndentCount - 1) and
    not Adapter.HasStateImages(ANode) and not Adapter.HasImages(ANode) and not
      Adapter.HasCheck(ANode) then
      Result := [csRight];
end;
    
function TcxTreeListReportLinkFormatter.GetNodeIndentClass: TdxReportCellExpandButtonClass;
begin
  Result := TdxReportCellExpandButton;
end;

function TcxTreeListReportLinkFormatter.GetNodeIndentTreeLineMode(AnIndex, 
  AnIndentCount: Integer; ANode: TcxTreeListNode): TdxPSTreeLineMode;
var
  Level: Integer;
  Parent: TcxTreeListNode;
begin
  Level := AnIndentCount - AnIndex - 1;
  Parent := GetNodeParent(ANode, Level);

  if Parent = ANode then 
    if IsNodeLastChild(ANode) then
      Result := tlmBottomRightCorner
    else
      if not HasParent(ANode) and IsNodeFirstChild(ANode) then          
        Result := tlmTopRightCorner  
      else
        Result := tlmCross
  else
    if IsNodeLastChild(Parent) then
      Result := tlmNone
    else
      Result := tlmVertical;
end;
  
function TcxTreeListReportLinkFormatter.GetNodeIndentViewParams(ANode: TcxTreeListNode; 
  AnIndex, AnIndentCount: Integer): TdxReportItemViewParams;
begin
  FillChar(Result, 0, SizeOf(Result));
  if ReportLink.OptionsFormatting.UseNativeStyles then
    if CanProcessSelectionStyle(ANode) then
      ReportLink.Styles.GetSelectionParams(Result.NativeParams)
    else
      ReportLink.Styles.GetIndentParams(ANode, AnIndex, Result.NativeParams)
  else
    if CanProcessSelectionStyle(ANode) then
      Result.NativeParams := Adapter.GetSelectionViewParams
    else
      Result.NativeParams := Adapter.GetIndentViewParams(ANode, AnIndex);
      
//  if not CanProcessSelectionStyle(ANode) and not IsNodeColorUsedForIndents then 
//    Result.Color := ReportLink.Color;  

  Result.CellSides := GetNodeIndentCellSides(ANode, AnIndex, AnIndentCount);
  Result.FontStyle := [];    
  Result.Transparent := IsColorTransparent(Result.NativeParams.Color); //ReportLink.FixedTransparent
end;

procedure TcxTreeListReportLinkFormatter.DoInitializeNodeBandedRow(ARow: TdxReportCell);
const
  CellSidesMap: array[Boolean] of TdxCellSides = ([], csAll);
begin
  ARow.CellSides := CellSidesMap[ReportLink.OptionsView.Borders];
  ARow.Transparent := True;
end;

procedure TcxTreeListReportLinkFormatter.DoInitializeNodeRow(ARow: TdxReportCell;
  ANode: TcxTreeListNode);
const
  CellSidesMap: array[Boolean] of TdxCellSides = ([], csLeftRight);
begin
  ARow.CellSides := CellSidesMap[ReportLink.OptionsView.Borders];
  ARow.Data := Integer(ANode);
  ARow.Transparent := True;
  
  ReportLink.AddReportRow(ARow);
end;

procedure TcxTreeListReportLinkFormatter.DoInitializeNodeItem(AnItem: TAbstractdxReportCellData; 
  AColumn: TcxTreeListColumn; ANode: TcxTreeListNode; AnIsPreview: Boolean = False);

  function GetViewParams: TdxReportItemViewParams;
  begin
    if AnIsPreview then
      Result := GetPreviewViewParams(AColumn, ANode)
    else
      Result := GetNodeItemViewParams(AColumn, ANode);
  end;

var
  Properties: TcxCustomEditProperties;
  ViewParams: TdxReportItemViewParams;
  CellValue: TcxEditValue;
begin
  Properties := Adapter.GetProperties(AColumn, ANode);
  ViewParams := GetViewParams;
  CellValue := GetCellValue(Properties, AColumn, ANode);
  dxPScxCommon.dxPSDataMaps.InitializeItem(AnItem, Properties, CellValue, Self, ViewParams, AnIsPreview{, ANode.RecordIndex});
  dxPScxCommon.dxPSDataMaps.GetImageLists(Properties, ReportLink.AppendImageList);
  SetViewParams(AnItem, ViewParams);

  with ViewParams, NativeParams do
    if (Bitmap <> nil) and not Bitmap.Empty then
      AnItem.BackgroundBitmapIndex := ReportLink.AddBackgroundBitmapToPool(Bitmap);

  AnItem.Data := Integer(AColumn);
end;

procedure TcxTreeListReportLinkFormatter.DoReportLinkInitializeNodeItem(AnItem: TAbstractdxReportCellData; 
  AColumn: TcxTreeListColumn; ANode: TcxTreeListNode);
begin
  ReportLink.DoInitializeCell(ANode, AColumn, AnItem);
end;

function TcxTreeListReportLinkFormatter.GetCellValue(AProperties: TcxCustomEditProperties; 
  AColumn: TcxTreeListColumn; ANode: TcxTreeListNode): TcxEditValue;
begin
  if AProperties.GetEditValueSource(False) = evsValue then
    Result := ANode.Values[AColumn.ItemIndex]
  else
    Result := ANode.Texts[AColumn.ItemIndex];
end;

function TcxTreeListReportLinkFormatter.GetNodeBackgroundBitmapStyleIndex(ANode: TcxTreeListNode): Integer;

  function HasBackgroundBitmap(AStyle: TcxStyle): Boolean;
  begin
    Result := (AStyle <> nil) and (svBitmap in AStyle.AssignedValues);
  end;
  
begin
  Result := tlsv_Content;
  if IsOddNode(ANode) and HasBackgroundBitmap(ReportLink.Styles.StylesByCaption[cxGetResourceString(@sdxContentOddStyle)]) then
    Result := tlsv_ContentOdd
  else 
    if not IsOddNode(ANode) and HasBackgroundBitmap(ReportLink.Styles.StylesByCaption[cxGetResourceString(@sdxContentEvenStyle)]) then
      Result := tlsv_ContentEven
end;

function TcxTreeListReportLinkFormatter.GetNodeItemBounds(ANode: TcxTreeListNode;
  AIndex: Integer): TRect;
var
  AItem: TcxTreeListColumnPlace;
begin
  AItem := ItemPlaceController.ItemsByColumn[Columns[AIndex]];
  if AItem <> nil then
    Result := AItem.CellBounds[ANode]
  else
    Result := dxPSGlbl.NullRect;
end;

function TcxTreeListReportLinkFormatter.GetNodeItemCellSides(AColumn: TcxTreeListColumn; 
  ANode: TcxTreeListNode): TdxCellSides;
begin
  if ReportLink.OptionsView.Borders then
    Result := csAll
  else
    Result := [];
end;

function TcxTreeListReportLinkFormatter.GetNodeItemClass(AColumn: TcxTreeListColumn;
  ANode: TcxTreeListNode; AnIsPreview: Boolean = False): TdxReportCellDataClass;
begin
  Result := dxPSDataMaps.ItemClass(Adapter.GetProperties(AColumn, ANode), AnIsPreview);
end;

function TcxTreeListReportLinkFormatter.GetNodeItemViewParams(AColumn: TcxTreeListColumn;
  ANode: TcxTreeListNode): TdxReportItemViewParams;
begin
  FillChar(Result, 0, SizeOf(Result));
  if ReportLink.OptionsFormatting.UseNativeStyles then
    if CanProcessSelectionStyle(ANode) then
      ReportLink.Styles.GetSelectionParams(Result.NativeParams)
    else
      ReportLink.Styles.GetContentParams(ANode, AColumn, Result.NativeParams)
  else
    if CanProcessSelectionStyle(ANode) then
      Result.NativeParams := Adapter.GetSelectionViewParams
    else
      Result.NativeParams := Adapter.GetContentViewParams(ANode, AColumn);

  Result.CellSides := GetNodeItemCellSides(AColumn, ANode);
  Result.FontStyle := [];
  Result.Transparent := IsColorTransparent(Result.NativeParams.Color); //ReportLink.Transparent;

end;

procedure TcxTreeListReportLinkFormatter.DoInitializePreview(AnItem: TAbstractdxReportCellData;
  AColumn: TcxTreeListColumn; ANode: TcxTreeListNode);
begin
  DoInitializeNodeItem(AnItem, AColumn, ANode, True);
end;

function TcxTreeListReportLinkFormatter.GetPreviewCellSides(ANode: TcxTreeListNode): TdxCellSides;
const
  CellSidesMap: array[Boolean] of TdxCellSides = ([], csAll);
begin
  Result := CellSidesMap[ReportLink.OptionsView.Borders];
end;

function TcxTreeListReportLinkFormatter.GetPreviewClass(AColumn: TcxTreeListColumn;
  ANode: TcxTreeListNode): TdxReportCellDataClass;
begin
  Result := GetNodeItemClass(AColumn, ANode, True);
end;
  
function TcxTreeListReportLinkFormatter.GetPreviewViewParams(AColumn: TcxTreeListColumn; 
  ANode: TcxTreeListNode): TdxReportItemViewParams;
begin
  FillChar(Result, SizeOf(Result), 0);
  if ReportLink.OptionsFormatting.UseNativeStyles then 
    if CanProcessSelectionStyle(ANode) then
      ReportLink.Styles.GetSelectionParams(Result.NativeParams)
    else
      ReportLink.Styles.GetPreviewParams(ANode, AColumn, Result.NativeParams)
  else
    if CanProcessSelectionStyle(ANode) then
      Result.NativeParams := Adapter.GetSelectionViewParams
    else
      Result.NativeParams := Adapter.GetPreviewViewParams(ANode, AColumn);

  Result.CellSides := GetPreviewCellSides(ANode);
  Result.FontStyle := [];
  Result.Transparent := {True;//}IsColorTransparent(Result.NativeParams.Color); //ReportLink.Transparent;
end;

procedure TcxTreeListReportLinkFormatter.DoInitializeNodeSeparator(AnItem: TAbstractdxReportCellData);
begin
  with TdxReportCellBox(AnItem) do
  begin
    CellSides := csAll;
    Color := NodeSeparatorColor;
    Transparent := False;
  end;  
end;

procedure TcxTreeListReportLinkFormatter.DoInitializeNodeSeparatorRow(ARow: TdxReportCell);
begin
end;

function TcxTreeListReportLinkFormatter.GetNodeSeparatorClass: TdxReportCellBoxClass;
begin
  Result := TdxReportCellBox;
end;

{ state images }

procedure TcxTreeListReportLinkFormatter.DoInitializeNodeStateImage(AnItem: TdxReportCellGraphic; 
  ANode: TcxTreeListNode; AnIndex: Integer);
begin
  SetViewParams(AnItem, GetNodeStateImageViewParams(ANode, AnIndex));
  if HasBackgroundBitmap(tlsv_Content) then 
    AnItem.BackgroundBitmapIndex := GetBackgroundBitmapIndex(tlsv_Content);

  AnItem.Data := MakeIndentIndex(AnIndex);
  AnItem.DrawMode := gdmCenter;
  AnItem.ImageIndex := ANode.StateIndex;
  AnItem.ImageList := Adapter.StateImages;
  AnItem.ImageTransparent := True;
end;

procedure TcxTreeListReportLinkFormatter.DoReportLinkInitializeNodeStateImage(AnItem: TAbstractdxReportCellData;
  ANode: TcxTreeListNode; AnIndex: Integer);
begin
  ReportLink.DoInitializeIndentCell(ANode, AnIndex, AnItem);
end;  

function TcxTreeListReportLinkFormatter.GetNodeStateImageCellSides(ANode: TcxTreeListNode; 
  AnIndex: Integer): TdxCellSides;
begin
  Result := [];
  if ReportLink.OptionsView.Borders and not Adapter.HasImages(ANode) then
      Result := [csRight];
end;

function TcxTreeListReportLinkFormatter.GetNodeStateImageClass: TdxReportCellGraphicClass;
begin
  Result := TdxReportCellGraphic;
end;

function TcxTreeListReportLinkFormatter.GetNodeStateImageViewParams(ANode: TcxTreeListNode; 
  AnIndex: Integer): TdxReportItemViewParams;
begin
  FillChar(Result, SizeOf(Result), 0);
  if ReportLink.OptionsFormatting.UseNativeStyles then
    if CanProcessSelectionStyle(ANode) then
      ReportLink.Styles.GetSelectionParams(Result.NativeParams)
    else
      ReportLink.Styles.GetImagesParams(ANode, Result.NativeParams)
  else
    if CanProcessSelectionStyle(ANode) then
      Result.NativeParams := Adapter.GetSelectionViewParams
    else
      Result.NativeParams := Adapter.GetIndentViewParams(ANode, AnIndex);

  Result.CellSides := GetNodeStateImageCellSides(ANode, AnIndex);
  Result.Transparent := IsColorTransparent(Result.NativeParams.Color); // ReportLink.FixedTransparent;
end;

function TcxTreeListReportLinkFormatter.QueryInterface(const IID: TGUID; out Obj): HResult;
begin
  if GetInterface(IID, Obj) then
    Result := 0
  else
    Result := E_NOINTERFACE;
end;

function TcxTreeListReportLinkFormatter._AddRef: Integer;
begin
  Result := 1;
end;

function TcxTreeListReportLinkFormatter._Release: Integer;
begin
  Result := 1;
end;

function TcxTreeListReportLinkFormatter.IdxPSCellParams_GetAutoHeight: Boolean;
begin 
  Result := Adapter.CellAutoHeight;
end;

function TcxTreeListReportLinkFormatter.IdxPSCellParams_GetDC: HDC;
begin
  Result := Self.DC;
end;

function TcxTreeListReportLinkFormatter.IdxPSCellParams_GetDisplayGraphicsAsText: Boolean;
begin 
  Result := ReportLink.OptionsRefinements.DisplayGraphicsAsText;
end;

function TcxTreeListReportLinkFormatter.IdxPSCellParams_GetEndEllipsis: Boolean;
begin 
  Result := Adapter.CellEndEllipsis;
end;

function TcxTreeListReportLinkFormatter.IdxPSCellParams_GetFlatCheckMarks: Boolean;
begin 
  Result := ReportLink.OptionsRefinements.FlatCheckMarks;
end;

function TcxTreeListReportLinkFormatter.IdxPSCellParams_GetGraphicsText: string;
begin 
  Result := ReportLink.OptionsRefinements.GraphicsText;
end;

function TcxTreeListReportLinkFormatter.IdxPSCellParams_GetMultiline: Boolean;
begin
  Result := Adapter.CellMultiline;
end;

function TcxTreeListReportLinkFormatter.IdxPSCellParams_GetTransparentGraphics: Boolean;
begin 
  Result := ReportLink.OptionsRefinements.TransparentGraphics;
end;

function TcxTreeListReportLinkFormatter.IdxPSCellParams2_GetPreviewMarginLeft: Integer;
begin
  Result := Adapter.PreviewLeftIndent;
end;

function TcxTreeListReportLinkFormatter.IdxPSCellParams2_GetPreviewMarginRight: Integer;
begin
  Result := Adapter.PreviewRightIndent;
end;

function TcxTreeListReportLinkFormatter.IdxPSCellParams2_GetPreviewMaxHeight: Integer;
begin
  if PreviewAutoHeight then
    Result := -1
  else  
    Result := PreviewLineHeight * PreviewMaxLineCount;
end;

function TcxTreeListReportLinkFormatter.IdxPSCellParams2_GetPreviewMaxLineCount: Integer;
begin
  Result := PreviewMaxLineCount;
end;

function TcxTreeListReportLinkFormatter.IdxPSCellParams2_GetRichEditGraphicClass: TGraphicClass;
const
  GraphicClasses: array[Boolean] of TGraphicClass = (TMetafile, TBitmap);
begin
  Result := GraphicClasses[IdxPSCellParams2_GetRichEditTransparent];
end;

function TcxTreeListReportLinkFormatter.IdxPSCellParams2_GetRichEditTransparent: Boolean;
begin
 {$IFDEF DXVER500}
  Result := ReportLink.OptionsRefinements.TransparentRichEdits;
 {$ELSE}
  Result := False;
 {$ENDIF} 
end;

procedure TcxTreeListReportLinkFormatter.AddDelimiters;
begin
  with ReportLink.OptionsPagination do
  begin
    if Band or Column then AddHorizontalDelimiters;
    if Node then AddVerticalDelimiters;
  end;
end;

procedure TcxTreeListReportLinkFormatter.AddHorizontalDelimiters;
var
  I: Integer;
  R: TRect;
  AColumnPlace: TcxTreeListColumnPlace;
  ABandPlace: TcxTreeListCustomBandPlace;
begin
  if ReportLink.OptionsPagination.Band then 
  begin
    for I := 0 to BandCount - 1 do
    begin
      ABandPlace := ItemPlaceController.ItemsByBand[Bands[I]];
      if ABandPlace <> nil then
      begin
        R := ABandPlace.Bounds;
        ReportLink.AddHorizontalDelimiter(R.Left);
        ReportLink.AddHorizontalDelimiter(R.Right);
      end;
    end;
  end
  else
    for I := 0 to ColumnCount - 1 do
    begin
      AColumnPlace := ItemPlaceController.ItemsByColumn[Columns[I]];
      if AColumnPlace <> nil then
      begin
        R := AColumnPlace.HeaderCellBounds;
        ReportLink.AddHorizontalDelimiter(R.Left);
        ReportLink.AddHorizontalDelimiter(R.Right);
      end;
    end;
end;

procedure TcxTreeListReportLinkFormatter.AddVerticalDelimiters;
var
  I: Integer;
begin
  for I := 0 to Builder.ReportRowCount - 1 do
    ReportLink.AddVerticalDelimiter(Builder.ReportRows[I]);
end;
                                           
procedure TcxTreeListReportLinkFormatter.AfterBuilding; 
begin
  if not Builder.IsAborted then
  begin
    FormatLookAndFeelItems;  
    AddDelimiters;
    Builder.ReportCells.BorderColor := GridLinesColor;
    Builder.ReportCells.TreeLineColor := Adapter.TreeLinesColor;
    Builder.ReportCells.TreeLineStyle := TreeLinesStyleMap[Adapter.TreeLinesStyle];
  end;  
end;

procedure TcxTreeListReportLinkFormatter.BeforeBuilding;
begin
  CreateItems;
  Adapter.Calculate;
  CalculateLineHeights;
  ItemPlaceController.Refresh;
  ItemPlaceController.Calculate;
end;

procedure TcxTreeListReportLinkFormatter.CalculateLineHeights;
var
  I: Integer; 
  AColumn: TcxTreeListColumn;
begin
  FBandLineHeight := 0;
  if Adapter.IsDefaultRowHeightAssigned then
    FDetailsLineHeight := Adapter.DefaultRowHeight
  else
    FDetailsLineHeight := DefaultDataRowLineHeight;
  FFooterLineHeight := 0;
  FHeaderLineHeight := 0;

  for I := 0 to ColumnCount - 1 do
  begin
    AColumn := Columns[I];
    CalculateHeight(GetFooterCellViewParams(AColumn), FFooterLineHeight);
    CalculateHeight(GetHeaderItemViewParams(AColumn), FHeaderLineHeight);
    if not Adapter.IsDefaultRowHeightAssigned and not AColumn.IsPreview then
      CalculateNodeHeight(nil, GetNodeItemViewParams(AColumn, Nodes[0]), FDetailsLineHeight);
  end;
  Inc(FFooterLineHeight, 2 * FooterItemInflateVert);

  FPreviewLineHeight := Adapter.DefaultRowHeight;
  if PreviewColumn <> nil then
    CalculateHeight(GetPreviewViewParams(PreviewColumn, Nodes[0]), FPreviewLineHeight);
  
  for I := 0 to BandCount - 1 do
    CalculateHeight(GetBandItemViewParams(Bands[I]), FBandLineHeight);  
end;

function TcxTreeListReportLinkFormatter.CanProcessSelectionStyle(ANode: TcxTreeListNode): Boolean;
begin  
  Result := (ANode <> nil) and ReportLink.OptionsFormatting.ConsumeSelectionStyle and IsSelectedNode(ANode);
  if Result and not ReportLink.OptionsFormatting.UseNativeStyles then
    Result := Adapter.HasSelectionStyle;
end;

procedure TcxTreeListReportLinkFormatter.CreateNodeList;

  function IsNodeProcessed(ANode: TcxTreeListNode): Boolean;
  var
    Helper: TcxTreeListNodeHelper;
  begin
    Helper := Adapter.Helpers[ANode];
    Result := not Adapter.MultiSelection or not ReportLink.OptionsSelection.ProcessSelection or 
      (ANode.Selected or Helper.HasSelectedChildren or 
      (not ReportLink.OptionsSelection.ProcessExactSelection and Helper.HasSelectedParents));
  end;
  
  procedure ProcessNode(ANode: TcxTreeListNode);
  var
    I: Integer;
    Node: TcxTreeListNode;
  begin
    FNodes.Add(ANode);
    if (ANode.Count > 0) and (ReportLink.OptionsExpanding.ExplicitlyExpandNodes or 
      (ANode.Expanded or (ReportLink.OptionsExpanding.AutoExpandNodes and ANode.CanExpand))) then 
      for I := 0 to ANode.Count - 1 do 
      begin
        Node := ANode[I];
        if IsNodeProcessed(Node) then ProcessNode(Node);
      end;
  end;
  
var
  I: Integer;
  Node: TcxTreeListNode;
begin
  FNodes.Clear;
  for I := 0 to Adapter.NodeCount - 1 do
  begin
    Node := Adapter.Nodes[I];
    if IsNodeProcessed(Node) then ProcessNode(Node);
  end;
end;

function TcxTreeListReportLinkFormatter.IsSelectedNode(ANode: TcxTreeListNode): Boolean;
begin
  Result := ReportLink.OptionsSelection.ProcessSelection or ANode.Selected;
end;

function TcxTreeListReportLinkFormatter.GetBackgroundBitmap(Index: Integer): TBitmap;
begin
  if ReportLink.OptionsFormatting.UseNativeStyles then
    Result := ReportLink.Styles.GetBitmap(MapStyleBackgroundBitmapIndex(Index))
  else
    Result := Adapter.GetBackgroundBitmap(Index);
end;

function TcxTreeListReportLinkFormatter.GetBackgroundBitmapIndex(Index: Integer): Integer;
begin
  Result := ReportLink.AddBackgroundBitmapToPool(GetBackgroundBitmap(Index));
end;

function TcxTreeListReportLinkFormatter.HasBackgroundBitmap(Index: Integer): Boolean;
var
  Bitmap: TBitmap;
begin
  if not ReportLink.OptionsFormatting.SuppressBackgroundBitmaps then
  begin
    Bitmap := GetBackgroundBitmap(Index);
    Result := (Bitmap <> nil) and not Bitmap.Empty;
  end
  else
    Result := False;
end;

function TcxTreeListReportLinkFormatter.MapStyleBackgroundBitmapIndex(ATreeListBackgroundBitmapIndex: Integer): Integer;
begin
  case ATreeListBackgroundBitmapIndex of
    tlsv_BandBackground:
      Result := vspsTreeListBandBackground;
    tlsv_BandHeader:
      Result := vspsTreeListBandHeader;
    tlsv_Content:
      Result := vspsTreeListContent;
    tlsv_ContentOdd:
      Result := vspsTreeListContentOdd;
    tlsv_ContentEven:
      Result := vspsTreeListContentEven;
    tlsv_ColumnFooter:
      Result := vspsTreeListFooter;
    tlsv_ColumnHeader:
      Result := vspsTreeListHeader;
    tlsv_Footer:
      Result := vspsTreeListFooterRow;
    tlsv_Preview:
      Result := vspsTreeListPreview;
  else
    Result := 0;    
  end;
end;

procedure TcxTreeListReportLinkFormatter.CalculateHeight(const AParams: TdxReportItemViewParams;
  var AHeight: Integer);
begin
  AHeight := Max(AHeight, CalculatePatternHeight(AParams));
end;

procedure TcxTreeListReportLinkFormatter.CalculateNodeHeight(ANode: TcxTreeListNode;
  const AParams: TdxReportItemViewParams; var AHeight: Integer);
begin
  AHeight := Max(Max(Max(AHeight, CalculatePatternHeight(AParams)),
    Adapter.GetImagesHeight(ANode)), Adapter.GetStateImagesHeight(ANode));
end;

function TcxTreeListReportLinkFormatter.CalculatePatternHeight(const AParams: TdxReportItemViewParams): Integer;
begin
  Result := Renderer.CalcTextPatternHeight(DC, AParams.NativeParams.Font);
end;

procedure TcxTreeListReportLinkFormatter.CreateBands;
var
  I: Integer;
  Band: TcxTreeListBand;
begin
  FBands.Clear;
  for I := 0 to Adapter.BandCount - 1 do
  begin
    Band := Adapter.Bands[I];
    if Band.ActuallyVisible then FBands.Add(Band);
  end;
end;

procedure TcxTreeListReportLinkFormatter.CreateColumns;
var
  I: Integer;
  AColumn: TcxTreeListColumn;
begin
  FColumns.Clear;
  for I := 0 to Adapter.ColumnCount - 1 do
  begin
    AColumn := Adapter.Columns[I];
    if AColumn.ActuallyVisible then FColumns.Add(AColumn);
  end;
end;

procedure TcxTreeListReportLinkFormatter.CreateItems;
begin
  CreateColumns;
  CreateBands;
  CreateSummaryItems;
end;

procedure TcxTreeListReportLinkFormatter.CreateSummaryItems;

  procedure InternalCreateSummaryItems(AColumnIndex: Integer;
    AVisibleSummaryItems: TcxTreeListReportLinkSummaryItems; ASummaryItems: TcxTreeListSummaryItems);
  var
    ASummaryIndex, AVisibleIndex: Integer;
  begin
    AVisibleIndex := 0;
    SetLength(AVisibleSummaryItems[AColumnIndex], ASummaryItems.VisibleCount);
    for ASummaryIndex := 0 to ASummaryItems.Count - 1 do
      if ASummaryItems[ASummaryIndex].Visible and (ASummaryItems[ASummaryIndex].Kind <> skNone) then
        begin
          AVisibleSummaryItems[AColumnIndex, AVisibleIndex] := ASummaryItems[ASummaryIndex];
          Inc(AVisibleIndex);
        end;
  end;

var
  I: Integer;
begin
  SetLength(FGroupFooterSummaryItems, ColumnCount);
  SetLength(FFooterSummaryItems, ColumnCount);
  for I := 0 to ColumnCount - 1 do
  begin
    InternalCreateSummaryItems(I, FFooterSummaryItems,
      Columns[I].Summary.FooterSummaryItems);
    InternalCreateSummaryItems(I, FGroupFooterSummaryItems,
      Columns[I].Summary.GroupFooterSummaryItems);
  end;
end;

function TcxTreeListReportLinkFormatter.GetFooterCellCount(AColumn: TcxTreeListColumn; ANode: TcxTreeListNode): Integer;
begin
  if HasFooterCell(AColumn, ANode) then
    Result := IfThen(Adapter.FMultiRows, 1, Length(GetSummaryItems(ANode)[FColumns.IndexOf(AColumn)]))
  else
    Result := 0;
end;

function TcxTreeListReportLinkFormatter.GetNodeIndent(ANode: TcxTreeListNode): Integer;
begin
  Result := Adapter.IndentWidth * IndentCounts[ANode] + Adapter.GetImagesWidth(ANode) +
    Adapter.GetStateImagesWidth(ANode) + Adapter.GetCheckWidth(ANode);
end;

function TcxTreeListReportLinkFormatter.GetNodeParent(ANode: TcxTreeListNode;
  ALevel: Integer): TcxTreeListNode;
begin
  Result := ANode;
  while ALevel > 0 do 
  begin
    Result := Result.Parent;
    Dec(ALevel);
  end;
end;

function TcxTreeListReportLinkFormatter.GetNextNode(ANode: TcxTreeListNode): TcxTreeListNode;
var
  Index: Integer;
begin
  Index := IndexOfNode(ANode);
  if Index < NodeCount - 1 then
    Result := Nodes[Index + 1]
  else
    Result := nil;  
end;

function TcxTreeListReportLinkFormatter.GetPrevNode(ANode: TcxTreeListNode): TcxTreeListNode;
var
  Index: Integer;
begin
  Index := IndexOfNode(ANode);
  if Index > 0 then
    Result := Nodes[Index - 1]
  else
    Result := nil;  
end;

function TcxTreeListReportLinkFormatter.GetStyleFontIndex(const AParams: TdxReportItemViewParams): Integer;
begin
  if AParams.NativeParams.Font <> nil then
  begin
    FFont.Assign(AParams.NativeParams.Font);
    if not dxPSUtl.dxIsTrueTypeFont(FFont) then
      FFont.Name := ReportLink.Font.Name;
    FFont.Color := ColorToRGB(AParams.NativeParams.TextColor);
    FFont.Style := FFont.Style + AParams.FontStyle;
    Result := ReportLink.AddFontToPool(FFont);
  end
  else
    Result := 0;
end;

function TcxTreeListReportLinkFormatter.GetSummaryItems(ANode: TcxTreeListNode): TcxTreeListReportLinkSummaryItems;
begin
  if ANode = Adapter.TreeList.Root then
    Result := FFooterSummaryItems
  else
    Result := FGroupFooterSummaryItems;
end;

function TcxTreeListReportLinkFormatter.HasFooterCell(AColumn: TcxTreeListColumn; ANode: TcxTreeListNode): Boolean;
begin
  if ANode = Adapter.TreeList.Root then
    Result := AColumn.Options.Footer
  else
    Result := AColumn.Options.GroupFooter;
  Result := Result and (Length(GetSummaryItems(ANode)[FColumns.IndexOf(AColumn)]) > 0);
end;

function TcxTreeListReportLinkFormatter.HasParent(ANode: TcxTreeListNode): Boolean;
begin
  Result := ANode.Level > 0;
end;

function TcxTreeListReportLinkFormatter.IndexOfNode(ANode: TcxTreeListNode): Integer;
begin
  Result := FNodes.IndexOf(ANode);
end;

function TcxTreeListReportLinkFormatter.IsColorTransparent(AColor: TColor): Boolean;
begin
  Result := ColorToRGB(AColor) = ColorToRGB(TransparentColor);
end;

function TcxTreeListReportLinkFormatter.IsFirstNode(ANode: TcxTreeListNode): Boolean; 
begin
  Result := ANode = FNodes.First;
end;

function TcxTreeListReportLinkFormatter.IsLastNode(ANode: TcxTreeListNode): Boolean; 
begin
  Result := ANode = FNodes.Last;
end;

function TcxTreeListReportLinkFormatter.IsNodeExpanded(ANode: TcxTreeListNode): Boolean;
var
  NextNode: TcxTreeListNode;
begin
  Result := ANode.Expanded;
  if not Result then
  begin
    NextNode := GetNextNode(ANode);
    Result := (NextNode <> nil) and (NextNode.Level > ANode.Level);
  end;
end;

function TcxTreeListReportLinkFormatter.IsNodeFirstChild(ANode: TcxTreeListNode): Boolean;
begin
  Result := ANode.GetPrevSiblingVisible = nil;
end;

function TcxTreeListReportLinkFormatter.IsNodeLastChild(ANode: TcxTreeListNode): Boolean;
begin                                             
  Result := ANode.GetNextSiblingVisible = nil;
end;

function TcxTreeListReportLinkFormatter.IsOddNode(ANode: TcxTreeListNode): Boolean;
begin
  Result := Odd(FNodes.IndexOf(ANode));
end;

function TcxTreeListReportLinkFormatter.IsNodeSelected(ANode: TcxTreeListNode): Boolean;
begin
  Result := ANode.Selected; 
end;

procedure TcxTreeListReportLinkFormatter.RegisterLookAndFeelItem(AnItem: TdxReportVisualItem; 
  AEdgeStyle: TdxCellEdgeStyle);
begin
  AnItem.EdgeMode := cem3DEffects;
  AnItem.Edge3DStyle := AEdgeStyle;
  FLookAndFeelItems.Add(AnItem);
end;

procedure TcxTreeListReportLinkFormatter.SetViewParams(AnItem: TdxReportVisualItem; 
  const AParams: TdxReportItemViewParams);
begin
  with AnItem do 
  begin
    CellSides := AParams.CellSides;
    Color := ColorToRGB(AParams.NativeParams.Color);
    FontIndex := GetStyleFontIndex(AParams);
    Transparent := AParams.Transparent;
  end;
end;

function TcxTreeListReportLinkFormatter.MakeIndentIndex(AnIndex: Integer): DWORD;
begin
  Result := ReportLink.MakeIndentIndex(AnIndex);
end;

function TcxTreeListReportLinkFormatter.GetAutoWidth: Boolean;
begin
  Result := ReportLink.OptionsSize.AutoWidth;
end;

function TcxTreeListReportLinkFormatter.GetAvailableWidth: Integer;
var
  AControllerIntf: IdxReportLinkController;
  R: TRect;
begin
  if AutoWidth then
    if ReportLink.IsAggregated and
      Supports(TObject(ReportLink.Controller), IdxReportLinkController, AControllerIntf) then
      R := AControllerIntf.GetControlSiteBounds(ReportLink.TreeList)
    else
      R := ReportLink.RealPrinterPage.PaintRectPixels
  else
    R := Adapter.TreeList.ClientBounds;

  Result := R.Right - R.Left - 1;
end;

function TcxTreeListReportLinkFormatter.GetBandCount: Integer;
begin
  Result := FBands.Count;
end;

function TcxTreeListReportLinkFormatter.GetBands(AIndex: Integer): TcxTreeListBand;
begin
  Result := FBands[AIndex];
end;

function TcxTreeListReportLinkFormatter.GetColumnCount: Integer;
begin
  Result := FColumns.Count;
end;

function TcxTreeListReportLinkFormatter.GetColumns(AIndex: Integer): TcxTreeListColumn;
begin
  Result := FColumns[AIndex];
end;

function TcxTreeListReportLinkFormatter.GetDC: HDC;
begin
  Result := ReportLink.ScreenDC;
end;

function TcxTreeListReportLinkFormatter.GetExpandButtonColor: TColor;
begin
  Result := ExpandButtonInteriorColors[Adapter.TreeLinesStyle = tllsSolid];
end;

function TcxTreeListReportLinkFormatter.GetExpandButtonSize: Integer;
begin
  Result := DefaultExpandButtonSize;
end;

function TcxTreeListReportLinkFormatter.GetGridLinesColor: TColor;
begin
  Result := ReportLink.OptionsFormatting.GridLineColor;
  if Result = clDefault then
    Result := Adapter.GridLinesColor;
end;

function TcxTreeListReportLinkFormatter.GetHasNodeSeparator: Boolean;
begin
  Result := NodeSeparatorThickness > 0;
end;

function TcxTreeListReportLinkFormatter.GetHasPreview: Boolean;
begin
  Result := Adapter.HasPreview and ShowPreview and (PreviewAutoHeight or (PreviewMaxLineCount > 0));
end;

function TcxTreeListReportLinkFormatter.GetIndentCount(Node: TcxTreeListNode): Integer;
begin
  Result := Node.Level;
  if Adapter.ShowRoot then Inc(Result);
end;

function TcxTreeListReportLinkFormatter.GetIsNodeColorUsedForIndents: Boolean;
begin
  Result := Adapter.IsNodeColorUsedForIndents;
end;

function TcxTreeListReportLinkFormatter.GetLookAndFeelItem(Index: Integer): TdxReportVisualItem;
begin
  Result := TdxReportVisualItem(FLookAndFeelItems[Index]);
end;

function TcxTreeListReportLinkFormatter.GetLookAndFeelItemCount: Integer;
begin
  Result := FLookAndFeelItems.Count;
end;

function TcxTreeListReportLinkFormatter.GetNode(Index: Integer): TcxTreeListNode;
begin
  Result := TcxTreeListNode(FNodes[Index]);
end;

function TcxTreeListReportLinkFormatter.GetNodeCount: Integer;
begin
  Result := FNodes.Count;
end;

function TcxTreeListReportLinkFormatter.GetNodeSeparatorColor: TColor;
begin
  Result := ReportLink.OptionsFormatting.ActualNodeSeparatorColor;
end;

function TcxTreeListReportLinkFormatter.GetNodeSeparatorThickness: Integer;
begin
  Result := ReportLink.OptionsFormatting.NodeSeparatorThickness;
end;

function TcxTreeListReportLinkFormatter.GetPreviewAutoHeight: Boolean;
begin
  Result := ReportLink.OptionsPreview.AutoHeight;
end;

function TcxTreeListReportLinkFormatter.GetPreviewColumn: TcxTreeListColumn;
begin
  Result := Adapter.PreviewColumn;
end;

function TcxTreeListReportLinkFormatter.GetPreviewMaxLineCount: Integer;
begin
  Result := ReportLink.OptionsPreview.MaxLineCount;
end;

function TcxTreeListReportLinkFormatter.GetRenderer: TdxPSReportRenderer;
begin
  Result := ReportLink.Renderer;
end;

function TcxTreeListReportLinkFormatter.GetShowBandHeaders: Boolean;
begin
  Result := ReportLink.OptionsView.BandHeaders;
end;

function TcxTreeListReportLinkFormatter.GetShowFooters: Boolean;
begin
 Result := ReportLink.OptionsView.Footers;
end;

function TcxTreeListReportLinkFormatter.GetShowHeaders: Boolean;
begin
  Result := ReportLink.OptionsView.Headers;
end;

function TcxTreeListReportLinkFormatter.GetShowPreview: Boolean;
begin
  Result := ReportLink.OptionsPreview.Visible;
end;

function TcxTreeListReportLinkFormatter.GetUseLookAndFeelColors: Boolean;
begin
  Result := ReportLink.OptionsFormatting.UseLookAndFeelColors;
end;

function TcxTreeListReportLinkFormatter.GetViewWidth: Integer;
begin
  Result := ItemPlaceController.Width;
end;

function TcxTreeListReportLinkFormatter.GetTreeLinesColor: TColor;
begin
  Result := Adapter.TreeLinesColor;
end;

function TcxTreeListReportLinkFormatter.GetTreeLinesStyle: TcxTreeListTreeLineStyle;
begin
  Result := Adapter.TreeLinesStyle;
end;

procedure TcxTreeListReportLinkFormatter.FormatLookAndFeelItems;
const
  Borders3D: array[TdxCellEdgeStyle, Boolean] of TdxPSCellBorderClass = 
   ((TdxPSCellRaisedBorder, TdxPSCellRaisedSoftBorder), 
    (TdxPSCellSunkenBorder, TdxPSCellSunkenSoftBorder));
var
  I: Integer;
begin
  for I := 0 to LookAndFeelItemCount - 1 do
    with LookAndFeelItems[I] do 
      if ReportLink.Effects3D then
        BorderClass := Borders3D[Edge3DStyle, ReportLink.Soft3D]
      else
        BorderClass := TdxPSCellUltraFlatBorder;
end;

{ TcxTreeListReportLinkOptionsExpanding }

procedure TcxTreeListReportLinkOptionsExpanding.Assign(Source: TPersistent);
begin
  if Source is TcxTreeListReportLinkOptionsExpanding then 
    with TcxTreeListReportLinkOptionsExpanding(Source) do 
    begin
      Self.AutoExpandNodes := AutoExpandNodes;
      Self.ExplicitlyExpandNodes := ExplicitlyExpandNodes;
    end;
  inherited;
end;

procedure TcxTreeListReportLinkOptionsExpanding.RestoreDefaults;
begin
  inherited;
  AutoExpandNodes := False;
  ExplicitlyExpandNodes := False;
end;

function TcxTreeListReportLinkOptionsExpanding.DesignerTabIndex: Integer;
begin
  Result := 1;
end;

function TcxTreeListReportLinkOptionsExpanding.GetReportLink: TcxTreeListCustomReportLink;
begin
  Result := inherited ReportLink as TcxTreeListCustomReportLink;
end;

procedure TcxTreeListReportLinkOptionsExpanding.SetAutoExpandNodes(Value: Boolean);
begin
  if FAutoExpandNodes <> Value then 
  begin
    FAutoExpandNodes := Value;
    Changed;
  end;
end;

procedure TcxTreeListReportLinkOptionsExpanding.SetExplicitlyExpandNodes(Value: Boolean);
begin
  if FExplicitlyExpandNodes <> Value then 
  begin
    FExplicitlyExpandNodes := Value;
    Changed;
  end;
end;

{ TcxTreeListReportLinkOptionsFormatting }

procedure TcxTreeListReportLinkOptionsFormatting.Assign(Source: TPersistent);
begin
  if Source is TcxTreeListReportLinkOptionsFormatting then 
    with TcxTreeListReportLinkOptionsFormatting(Source) do 
    begin
      Self.ConsumeSelectionStyle := ConsumeSelectionStyle;
      Self.NodeSeparatorColor := NodeSeparatorColor;
      Self.NodeSeparatorThickness := NodeSeparatorThickness;
    end;
  inherited;
end;

procedure TcxTreeListReportLinkOptionsFormatting.RestoreDefaults;
begin
  inherited;
  ConsumeSelectionStyle := False;
  NodeSeparatorColor := clDefault;
  NodeSeparatorThickness := 0;
end;

function TcxTreeListReportLinkOptionsFormatting.DesignerTabIndex: Integer;
begin
  Result := 2;
end;

function TcxTreeListReportLinkOptionsFormatting.GetActualNodeSeparatorColor: TColor;
begin
  Result := NodeSeparatorColor;
  if Result = clDefault then
    Result := dxPSDefaultTreeListNodeSeparatorColor;
end;

function TcxTreeListReportLinkOptionsFormatting.GetReportLink: TcxTreeListCustomReportLink;
begin
  Result := inherited ReportLink as TcxTreeListCustomReportLink;
end;

procedure TcxTreeListReportLinkOptionsFormatting.SetConsumeSelectionStyle(Value: Boolean);
begin
  if FConsumeSelectionStyle <> Value then
  begin
    FConsumeSelectionStyle := Value;
    Changed;
  end;
end;

procedure TcxTreeListReportLinkOptionsFormatting.SetNodeSeparatorColor(Value: TColor);
begin
  if FNodeSeparatorColor <> Value then
  begin
    FNodeSeparatorColor := Value;
    if NodeSeparatorThickness <> 0 then Changed;
  end;
end;

procedure TcxTreeListReportLinkOptionsFormatting.SetNodeSeparatorThickness(Value: Integer);
begin
  if Value < 0 then Value := 0;
  if FNodeSeparatorThickness <> Value then
  begin
    FNodeSeparatorThickness := Value;
    Changed;
  end;
end;

{ TcxTreeListReportLinkOptionsOnEveryPage }

function TcxTreeListReportLinkOptionsOnEveryPage.DesignerTabIndex: Integer;
begin
  Result := 0;
end;

function TcxTreeListReportLinkOptionsOnEveryPage.GetReportLink: TcxTreeListCustomReportLink;
begin
  Result := inherited ReportLink as TcxTreeListCustomReportLink;
end;

{ TcxTreeListReportLinkOptionsPagination }

function TcxTreeListReportLinkOptionsPagination.DesignerTabIndex: Integer;
begin
  Result := 0;
end;

function TcxTreeListReportLinkOptionsPagination.GetNode: Boolean;
begin
  Result := inherited Row;
end;

function TcxTreeListReportLinkOptionsPagination.GetReportLink: TcxTreeListCustomReportLink;
begin
  Result := inherited ReportLink as TcxTreeListCustomReportLink;
end;

procedure TcxTreeListReportLinkOptionsPagination.SetNode(Value: Boolean);
begin
  inherited Row := Value;
end;

{ TcxTreeListReportLinkOptionsPreview }

function TcxTreeListReportLinkOptionsPreview.DesignerTabIndex: Integer;
begin
  Result := 4;
end;

function TcxTreeListReportLinkOptionsPreview.GetReportLink: TcxTreeListCustomReportLink;
begin
  Result := inherited ReportLink as TcxTreeListCustomReportLink;
end;

{ TcxTreeListReportLinkOptionsRefinements }

function TcxTreeListReportLinkOptionsRefinements.DesignerTabIndex: Integer;
begin
  Result := 2;
end;

function TcxTreeListReportLinkOptionsRefinements.GetReportLink: TcxTreeListCustomReportLink;
begin
  Result := inherited ReportLink as TcxTreeListCustomReportLink;
end;

{ TcxTreeListReportLinkOptionsSelection }

function TcxTreeListReportLinkOptionsSelection.DesignerTabIndex: Integer;
begin
  Result := 1;
end;

function TcxTreeListReportLinkOptionsSelection.GetReportLink: TcxTreeListCustomReportLink;
begin
  Result := inherited ReportLink as TcxTreeListCustomReportLink;
end;

{ TcxTreeListReportLinkOptionsSize }

function TcxTreeListReportLinkOptionsSize.DesignerTabIndex: Integer;
begin
  Result := 1;
end;

function TcxTreeListReportLinkOptionsSize.GetReportLink: TcxTreeListCustomReportLink;
begin
  Result := inherited ReportLink as TcxTreeListCustomReportLink;
end;

{ TcxTreeListReportLinkOptionsView }

procedure TcxTreeListReportLinkOptionsView.Assign(Source: TPersistent);
begin
  if Source is TcxTreeListReportLinkOptionsView then 
    with TcxTreeListReportLinkOptionsView(Source) do 
    begin
      Self.Borders := Borders;
      Self.TreeLines := TreeLines;
    end;
  inherited;
end;

procedure TcxTreeListReportLinkOptionsView.RestoreDefaults;
begin
  inherited;
  Borders := True;
  TreeLines := True;
end;

function TcxTreeListReportLinkOptionsView.DesignerTabIndex: Integer;
begin
  Result := 0;
end;

function TcxTreeListReportLinkOptionsView.GetReportLink: TcxTreeListCustomReportLink;
begin
  Result := inherited ReportLink as TcxTreeListCustomReportLink;
end;

procedure TcxTreeListReportLinkOptionsView.SetBorders(Value: Boolean);
begin
  if FBorders <> Value then 
  begin
    FBorders := Value;
    Changed;
  end;
end;

procedure TcxTreeListReportLinkOptionsView.SetTreeLines(Value: Boolean);
begin
  if FTreeLines <> Value then 
  begin
    FTreeLines := Value;
    Changed;
  end;  
end;

{ TcxTreeListReportLinkStyles }

procedure TcxTreeListReportLinkStyles.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TcxTreeListReportLinkStyles then
    with TcxTreeListReportLinkStyles(Source) do
    begin
      Self.BandHeader := BandHeader;
      Self.Content := Content;
      Self.ContentEven := ContentEven;
      Self.ContentOdd := ContentOdd;
      Self.Footer := Footer;
      Self.FooterRow := FooterRow;
      Self.Header := Header;
      Self.Preview := Preview;
    end;
end;

procedure TcxTreeListReportLinkStyles.GetBandHeaderParams(ABand: TcxTreeListBand;
  out AParams: TcxViewParams);
begin
  GetViewParams(vspsTreeListBandHeader, ABand, nil, AParams);
end;

procedure TcxTreeListReportLinkStyles.GetColumnFooterParams(ANode: TcxTreeListNode;
  AColumn: TcxTreeListColumn; out AParams: TcxViewParams);
begin
  GetViewParams(vspsTreeListFooter, ANode, nil, AParams);
end;

procedure TcxTreeListReportLinkStyles.GetColumnHeaderParams(AColumn: TcxTreeListColumn;
  out AParams: TcxViewParams);
begin
  if AColumn <> nil then
    GetViewParams(vspsTreeListHeader, nil, nil, AParams)
  else
    GetViewParams(vspsTreeListBandBackground, nil, nil, AParams);
end;

procedure TcxTreeListReportLinkStyles.GetContentParams(ANode: TcxTreeListNode;
  AColumn: TcxTreeListColumn; out AParams: TcxViewParams);

  function IsOddNode(ANode: TcxTreeListNode): Boolean;
  var
    Builder: TcxTreeListReportLinkBuilder;
  begin
    Builder := ReportLink.Builder;
    if Builder <> nil then 
      Result := Builder.Formatter.IsOddNode(ANode)
    else
      Result := Odd(ANode.VisibleIndex);
  end;

const
  StyleIndexes: array[Boolean] of Integer = (vspsTreeListContentEven, vspsTreeListContentOdd);
begin
  if (ANode <> nil) and (GetValue(StyleIndexes[IsOddNode(ANode)]) <> nil) then
    GetViewParams(StyleIndexes[IsOddNode(ANode)], ANode, nil, AParams)
  else
    GetViewParams(vspsTreeListContent, ANode, nil, AParams);
end;

procedure TcxTreeListReportLinkStyles.GetFooterRowParams(out AParams: TcxViewParams);
begin
  GetViewParams(vspsTreeListFooterRow, nil, nil, AParams);
end;

procedure TcxTreeListReportLinkStyles.GetImagesParams(ANode: TcxTreeListNode; 
  out AParams: TcxViewParams);
begin
  GetContentParams(ANode, nil, AParams);
end;  

procedure TcxTreeListReportLinkStyles.GetIndentParams(ANode: TcxTreeListNode; 
  AnIndent: Integer; out AParams: TcxViewParams);
  
  function IsNodeColorUsedForIndents: Boolean;
  var
    Builder: TcxTreeListReportLinkBuilder;
  begin
    Builder := ReportLink.Builder;
    Result := (Builder <> nil) and Builder.Formatter.IsNodeColorUsedForIndents;
  end;
  
begin
  if IsNodeColorUsedForIndents then 
    GetContentParams(ANode, nil, AParams)
  else
    GetViewParams(vspsTreeListIndent, ANode, nil{AnIndent}, AParams);
end;  

procedure TcxTreeListReportLinkStyles.GetPreviewParams(ANode: TcxTreeListNode;
  AColumn: TcxTreeListColumn; out AParams: TcxViewParams);
begin
  GetViewParams(vspsTreeListPreview, ANode, nil, AParams);
end;

procedure TcxTreeListReportLinkStyles.GetSelectionParams(out AParams: TcxViewParams); 
begin
  GetViewParams(vspsTreeListSelection, nil, nil, AParams);
end;

function TcxTreeListReportLinkStyles.DesignerTabIndex: Integer;
begin
  Result := 3;
end;

procedure TcxTreeListReportLinkStyles.GetDefaultViewParams(Index: Integer; AData: TObject; 
  out AParams: TcxViewParams);
const
  FixedParts = [vspsTreeListBandHeader, vspsTreeListFooter, vspsTreeListFooterRow, 
    vspsTreeListHeader, vspsTreeListSelection];
begin
  inherited;
  if ReportLink <> nil then
    with AParams do 
    begin
      if Index in FixedParts then
        Color := dxPSCore.dxDefaultFixedColor
      else
        Color := dxPSCore.dxDefaultContentColor; //TreeListReportLink.Color;  // ???

      Font := ReportLink.Font;
      TextColor := Font.Color;
    end;  
end;
                         
class function TcxTreeListReportLinkStyles.GetStyleCaption(AnIndex: Integer): string;
begin
  case AnIndex of
    vspsTreeListBandBackground:
      Result := cxGetResourceString(@sdxBandBackgroundStyle);
    vspsTreeListBandHeader:
      Result := cxGetResourceString(@sdxBandHeaderStyle);
    vspsTreeListContent:
      Result := cxGetResourceString(@sdxContentStyle);
    vspsTreeListContentEven:
      Result := cxGetResourceString(@sdxContentEvenStyle);
    vspsTreeListContentOdd:
      Result := cxGetResourceString(@sdxContentOddStyle);
    vspsTreeListFooter:
      Result := cxGetResourceString(@sdxFooterStyle);
    vspsTreeListFooterRow:
      Result := cxGetResourceString(@sdxFooterRowStyle);
    vspsTreeListHeader:
      Result := cxGetResourceString(@sdxHeaderStyle);
    vspsTreeListIndent:
      Result := cxGetResourceString(@sdxIndentStyle);
    vspsTreeListPreview:
      Result := cxGetResourceString(@sdxPreviewStyle);
  else  
    Result := cxGetResourceString(@sdxSelectionStyle);
  end;
end;

function TcxTreeListReportLinkStyles.GetStyleIndexByCaption(const Caption: string): Integer;
begin
  for Result := vspsTreeListFirst to vspsTreeListLast do
    if dxPSUtl.dxSameText(Caption, GetStyleCaption(Result)) then 
      Exit;
  Result := -1;
end;

function TcxTreeListReportLinkStyles.GetReportLink: TcxTreeListCustomReportLink;
begin
  Result := inherited ReportLink as TcxTreeListCustomReportLink;
end;

{ TcxTreeListReportLinkStyleSheet }

class function TcxTreeListReportLinkStyleSheet.GetStylesClass: TcxCustomStylesClass;
begin
  Result := TcxTreeListReportLinkStyles; 
end;

function TcxTreeListReportLinkStyleSheet.GetStylesValue: TcxTreeListReportLinkStyles;
begin
  if GetStyles is TcxTreeListReportLinkStyles then
    Result := TcxTreeListReportLinkStyles(GetStyles)
  else
    Result := nil;
end;

procedure TcxTreeListReportLinkStyleSheet.SetStylesValue(Value: TcxTreeListReportLinkStyles);
begin
  SetStyles(Value);
end;

{ TcxTreeListAttributeHostInfo }

procedure TcxTreeListAttributeHostInfo.Initialize(AParent: TdxReportCell);
begin                    
  Origin := NullPoint;
  FParent := AParent;
end;

{ TcxTreeListAttributeHostInfoServices }

constructor TcxTreeListAttributeHostInfoServices.Create(AReportLink: TcxTreeListCustomReportLink);
begin
  inherited Create;
  FReportLink := AReportLink;
  CreateHostInfos;
end;

destructor TcxTreeListAttributeHostInfoServices.Destroy;
begin
  DestroyHostInfos;
  inherited;
end;

procedure TcxTreeListAttributeHostInfoServices.InitializeHostInfos;
begin
  PageDetailsHostInfo.Initialize(PageDetails);
  PageFootersHostInfo.Initialize(PageFooters);
  PageHeadersHostInfo.Initialize(PageHeaders);
end;

procedure TcxTreeListAttributeHostInfoServices.CreateHostInfos;
begin
  FPageDetailsHostInfo := TcxTreeListAttributeHostInfo.Create;
  FPageFootersHostInfo := TcxTreeListAttributeHostInfo.Create;
  FPageHeadersHostInfo := TcxTreeListAttributeHostInfo.Create;
end;

procedure TcxTreeListAttributeHostInfoServices.DestroyHostInfos;
begin
  FreeAndNil(FPageHeadersHostInfo);
  FreeAndNil(FPageFootersHostInfo);
  FreeAndNil(FPageDetailsHostInfo);
end;

function TcxTreeListAttributeHostInfoServices.GetBandHeadersHostInfo: TcxTreeListAttributeHostInfo;
begin
  if CanUseBandHeadersOnEveyPage then
    Result := PageHeadersHostInfo
  else
    Result := PageDetailsHostInfo;
end;

function TcxTreeListAttributeHostInfoServices.GetFootersHostInfo: TcxTreeListAttributeHostInfo;
begin
  if CanUseFootersOnEveryPage then 
    Result := PageFootersHostInfo
  else
    Result := PageDetailsHostInfo;
end;

function TcxTreeListAttributeHostInfoServices.GetHeadersHostInfo: TcxTreeListAttributeHostInfo;
begin
  if CanUseHeadersOnEveryPage then 
    Result := PageHeadersHostInfo
  else
    Result := PageDetailsHostInfo;
end;

function TcxTreeListAttributeHostInfoServices.GetInconsistentStateText: string;
begin
  if ReportLink.IsAggregated then
    Result := cxGetResourceString(@sdxCannotUseOnEveryPageModeInAggregatedState)
  else
    if IsInconsistentHeadersState then
      Result := cxGetResourceString(@sdxTLIncorrectHeadersState)
    else
      Result := '';
end;

function TcxTreeListAttributeHostInfoServices.GetIsInconsistentState: Boolean;
begin
  Result := ReportLink.IsAggregated or IsInconsistentHeadersState;
end;

function TcxTreeListAttributeHostInfoServices.HasCells: Boolean;
begin
  Result := ReportLink.ReportCells <> nil;
end;

function TcxTreeListAttributeHostInfoServices.GetArePageFootersAssigned: Boolean;
begin
  Result := FootersHostInfo.Parent = ReportLink.ReportCells.FooterCells;
end;

function TcxTreeListAttributeHostInfoServices.GetArePageHeadersAssigned: Boolean;
begin
  with ReportLink.ReportCells do 
    Result := (BandHeadersHostInfo.Parent = HeaderCells) or (HeadersHostInfo.Parent = HeaderCells);
end;

function TcxTreeListAttributeHostInfoServices.GetCanUseBandHeadersOnEveyPage: Boolean;
begin
  Result := not ReportLink.IsAggregated and OptionsOnEveryPage.BandHeaders;
end;

function TcxTreeListAttributeHostInfoServices.GetCanUseFootersOnEveryPage: Boolean;
begin
  Result := not ReportLink.IsAggregated and OptionsOnEveryPage.Footers;
end;

function TcxTreeListAttributeHostInfoServices.GetCanUseHeadersOnEveryPage: Boolean;
begin
  Result := not ReportLink.IsAggregated and OptionsOnEveryPage.Headers and 
    ((BandHeadersHostInfo = PageHeadersHostInfo) or not OptionsView.BandHeaders);
end;

function TcxTreeListAttributeHostInfoServices.GetIsInconsistentHeadersState: Boolean;
begin
  Result := OptionsOnEveryPage.Headers and OptionsView.Headers and OptionsView.BandHeaders and not OptionsOnEveryPage.BandHeaders;
end;

function TcxTreeListAttributeHostInfoServices.GetOptionsOnEveryPage: TcxTreeListReportLinkOptionsOnEveryPage;
begin
  Result := ReportLink.OptionsOnEveryPage;
end;

function TcxTreeListAttributeHostInfoServices.GetOptionsView: TcxTreeListReportLinkOptionsView;
begin
  Result := ReportLink.OptionsView;
end;

function TcxTreeListAttributeHostInfoServices.GetPageDetails: TdxReportCell;
begin
  if HasCells then 
    Result := ReportLink.ReportCells.Cells
  else  
    Result := nil;
end;

function TcxTreeListAttributeHostInfoServices.GetPageFooters: TdxReportCell;
begin
  if HasCells then
    Result := ReportLink.ReportCells.FooterCells
  else
    Result := PageDetails;
end;

function TcxTreeListAttributeHostInfoServices.GetPageHeaders: TdxReportCell;
begin
  if HasCells then
    Result := ReportLink.ReportCells.HeaderCells
  else
    Result := PageDetails;
end;

{ TcxTreeListCustomReportLink }

constructor TcxTreeListCustomReportLink.Create(AOwner: TComponent);
begin
  inherited;
  FDelimitersHardVert := TList.Create;
  FHostInfoServices := TcxTreeListAttributeHostInfoServices.Create(Self);      
  FReportRows := TList.Create;
  InternalRestoreDefaults;
  LinkModified(False);
end;

destructor TcxTreeListCustomReportLink.Destroy;
begin
  FreeAndNil(FReportRows);
  FreeAndNil(FHostInfoServices);
  FreeAndNil(FDelimitersHardVert);
  inherited;
end;

procedure TcxTreeListCustomReportLink.AddPageBreak(ANode: TcxTreeListNode);
var
  ReportRow: TdxReportCell; 
begin
  ReportRow := ReportRowsByNode[ANode];
  if ReportRow <> nil then
    AddVerticalHardDelimiter(ReportRow);
end;

procedure TcxTreeListCustomReportLink.AddPageBreak(const ANodes: array of TcxTreeListNode);
var
  I: Integer;
begin
  for I := Low(ANodes) to High(ANodes) do
    AddPageBreak(ANodes[I]);
end;

procedure TcxTreeListCustomReportLink.AddPageBreak(const ANodes: TcxTreeListNodeArray);
var
  I: Integer;
begin
  for I := 0 to Length(ANodes) - 1 do
    AddPageBreak(ANodes[I]);
end;

procedure TcxTreeListCustomReportLink.AddPageBreak(ANodes: TList);
var
  I: Integer;
  P:  Pointer ;
begin
  for I := 0 to ANodes.Count - 1 do
  begin
    P := ANodes[I];
    if TObject(P) is TcxTreeListNode then 
      AddPageBreak(TcxTreeListNode(P));
  end;    
end;

procedure TcxTreeListCustomReportLink.ConstructReport(AReportCells: TdxReportCells);

  function HasData: Boolean;
  begin
    Result := (CustomTreeList_GetVisibleColumnCount(TreeList) <> 0) and
     (TreeList.Count <> 0);
  end;

  procedure Build;
  begin
    FBuilder := CreateBuilder;
    try
      FBuilder.Build;
    finally
      FreeAndNil(FBuilder);
    end;
  end;         

  procedure CalculateSizes;
  
    procedure CalculateReportPartSizes(ACell: TdxReportCell);
    var
      Width, I, V: Integer;
    begin
      if ACell.CellCount > 0 then   
      begin
        Width := 0;
        for I := 0 to ACell.CellCount - 1 do
        begin
          V := ACell.Cells[I].Width;
          if Width < V then Width := V;
        end;
        ACell.BoundsRect := MakeRect(0, 0, Width, ACell[ACell.CellCount - 1].BoundsRect.Bottom);
      end;  
    end;
  
  begin
    with AReportCells do 
    begin
      CalculateReportPartSizes(Cells);
      if AreFooterCellsAllocated then CalculateReportPartSizes(FooterCells);
      if AreHeaderCellsAllocated then CalculateReportPartSizes(HeaderCells);
    end;
  end; 
  
begin
  if TreeList = nil then Exit;
  inherited;
  if not HasData then Exit;
  
  PrepareConstruct;
  try
    Build;
    if not AbortBuilding then CalculateSizes;
  finally
    UnprepareConstruct;
  end;  
end;

procedure TcxTreeListCustomReportLink.ConvertCoords;
begin
  inherited;
  ConvertDelimiters(DelimitersHardVert);
end;

procedure TcxTreeListCustomReportLink.CustomDraw(AItem: TAbstractdxReportCellData;
  ACanvas: TCanvas; ABoundsRect, AClientRect: TRect; var ADone: Boolean);
var
  DrawInfo: TcxTreeListCellCustomDrawInfo;
begin
  GetItemCustomDrawInfo(AItem, DrawInfo);
  with DrawInfo do
    case AttributeID of 
      cxTreeListBandID:
        DoCustomDrawBandCell(ACanvas, Band, TdxReportCellImage(AItem), ADone);
      cxTreeListFooterID:
        DoCustomDrawFooterCell(ACanvas, Column, TdxReportCellString(AItem), ADone);
      cxTreeListHeaderID:
        DoCustomDrawHeaderCell(ACanvas, Column, TdxReportCellImage(AItem), ADone);
      cxTreeListIndentID:
        DoCustomDrawIndentCell(ACanvas, Node, Index, AItem, ADone);
      cxTreeListNodeID:
        DoCustomDrawCell(ACanvas, Node, Column, AItem, ADone);      
    end;
end;

function TcxTreeListCustomReportLink.GetBreakPagesByHardDelimiters: Boolean;
begin
  Result := OptionsPagination.Custom;
end;

procedure TcxTreeListCustomReportLink.GetImageLists(AProc: TdxPSGetImageListProc);
begin
  inherited;
  AProc(CustomTreeList_GetImages(TreeList));
  AProc(CustomTreeList_GetStateImages(TreeList));
end;

function TcxTreeListCustomReportLink.GetRebuildOnPageParamsChange(AUpdateCodes: TdxPrinterPageUpdateCodes): Boolean; 
begin
  Result := (AUpdateCodes * uaMarginsVert  <> []) and OptionsSize.AutoWidth;          
end;

function TcxTreeListCustomReportLink.GetUseHardVertDelimiters: Boolean;
begin
  Result := OptionsPagination.Custom;
end;

procedure TcxTreeListCustomReportLink.InternalRestoreFromOriginal;
var
  TreeListOptionsView: TcxTreeListOptionsView;
  TreeListPreview: TcxTreeListPreview;
begin
  inherited;
  if TreeList <> nil then 
  begin
    OptionsFormatting.LookAndFeelKind := CustomTreeList_GetLookAndFeel(TreeList).Kind;

    TreeListPreview := CustomTreeList_GetPreview(TreeList);
    with OptionsPreview do 
    begin
      AutoHeight := TreeListPreview.AutoHeight;
      MaxLineCount := TreeListPreview.MaxLineCount;
      Visible := TreeListPreview.Visible;
    end;
    
    TreeListOptionsView :=  CustomTreeList_GetOptionsView(TreeList);
    with OptionsView do 
    begin
      BandHeaders := TreeListOptionsView.Bands;
      ExpandButtons := TreeListOptionsView.Buttons;
      Footers := TreeListOptionsView.Footer;
      Headers := TreeListOptionsView.Headers;
      TreeLines := TreeListOptionsView.TreeLineStyle <> tllsNone;
    end;
    OptionsSize.AutoWidth := TreeListOptionsView.ColumnAutoWidth;
  end;  
end;
                                    
function TcxTreeListCustomReportLink.IsDrawFootersOnEveryPage: Boolean;
begin
  Result := HostInfoServices.ArePageFootersAssigned;
end;

function TcxTreeListCustomReportLink.IsDrawHeadersOnEveryPage: Boolean;
begin
  Result := HostInfoServices.ArePageHeadersAssigned;
end;

function TcxTreeListCustomReportLink.IsSupportedCustomDraw(Item: TAbstractdxReportCellData): Boolean;
var
  DrawInfo: TcxTreeListCellCustomDrawInfo;
begin
  Result := inherited IsSupportedCustomDraw(Item) and 
    (Item <> nil) and IsCustomDrawn(GetItemCustomDrawInfo(Item, DrawInfo));
end;

procedure TcxTreeListCustomReportLink.MakeHardDelimiters(AReportCells: TdxReportCells; 
  AVertDelimiters: TList);
begin
  inherited;
  
  if OptionsPagination.Custom then 
  try
    DoGetCustomPageBreaks;
  except
    Application.HandleException(Self);
  end;
  dxPSUtl.dxCopyList(DelimitersHardVert, AVertDelimiters);
end;

function TcxTreeListCustomReportLink.GetAreNativeStylesAvailable: Boolean;
begin
  Result := OptionsFormatting.UseNativeStyles;
end;
   
function TcxTreeListCustomReportLink.GetStylesClass: TdxCustomReportLinkStylesClass;
begin
  Result := TcxTreeListReportLinkStyles;
end;

function TcxTreeListCustomReportLink.GetStyleSheetClass: TdxCustomReportLinkStyleSheetClass;
begin
  Result := TcxTreeListReportLinkStyleSheet;
end;

function TcxTreeListCustomReportLink.GetStyleSheetPrototype: TdxCustomReportLinkStyleSheet;
begin
  Result := DefaultdxPScxTreeListLinkStyleSheet;
end;

procedure TcxTreeListCustomReportLink.PrepareConstruct;
begin
  inherited;
  DelimitersHardVert.Clear;
  FReportRows.Clear;
  
  ReportCells.LookAndFeel := nil;//CreateGroupLookAndFeel(TdxPSReportGroupNullLookAndFeel);
  
  HostInfoServices.InitializeHostInfos;
  if OptionsExpanding.ExplicitlyExpandNodes then
    TreeList.FullExpand;
end;

procedure TcxTreeListCustomReportLink.DoCustomDrawBandCell(ACanvas: TCanvas; 
  ABand: TcxTreeListBand; AnItem: TdxReportCellImage; var ADone: Boolean);
begin
  if Assigned(FOnCustomDrawBandCell) then
    FOnCustomDrawBandCell(Self, ACanvas, ABand, AnItem, ADone);
end;
  
procedure TcxTreeListCustomReportLink.DoCustomDrawCell(ACanvas: TCanvas; 
  ANode: TcxTreeListNode; AColumn: TcxTreeListColumn; 
  AnItem: TAbstractdxReportCellData; var ADone: Boolean);
begin
  if Assigned(FOnCustomDrawCell) then
    FOnCustomDrawCell(Self, ACanvas, ANode, AColumn, AnItem, ADone);
end;
  
procedure TcxTreeListCustomReportLink.DoCustomDrawFooterCell(ACanvas: TCanvas; 
  AColumn: TcxTreeListColumn; AnItem: TdxReportCellString; var ADone: Boolean);
begin
  if Assigned(FOnCustomDrawFooterCell) then
    FOnCustomDrawFooterCell(Self, ACanvas, AColumn, AnItem, ADone);
end;
  
procedure TcxTreeListCustomReportLink.DoCustomDrawHeaderCell(ACanvas: TCanvas; 
  AColumn: TcxTreeListColumn; AnItem: TdxReportCellImage; var ADone: Boolean);
begin
  if Assigned(FOnCustomDrawHeaderCell) then
    FOnCustomDrawHeaderCell(Self, ACanvas, AColumn, AnItem, ADone);
end;

procedure TcxTreeListCustomReportLink.DoCustomDrawIndentCell(ACanvas: TCanvas; 
  ANode: TcxTreeListNode; AnIndex: Integer; AnItem: TAbstractdxReportCellData;
  var ADone: Boolean);
begin
  if Assigned(FOnCustomDrawIndentCell) then
    FOnCustomDrawIndentCell(Self, ACanvas, ANode, AnIndex, AnItem, ADone);
end;  

procedure TcxTreeListCustomReportLink.DoGetCustomPageBreaks;
begin
  if Assigned(FOnGetCustomPageBreaks) then FOnGetCustomPageBreaks(Self);
end;

procedure TcxTreeListCustomReportLink.DoInitializeBandCell(ABand: TcxTreeListBand; 
  AnItem: TdxReportCellImage);
begin
  if Assigned(FOnInitializeBandCell) then 
    FOnInitializeBandCell(Self, ABand, AnItem);
end;  
  
procedure TcxTreeListCustomReportLink.DoInitializeCell(ANode: TcxTreeListNode; 
  AColumn: TcxTreeListColumn; AnItem: TAbstractdxReportCellData);
begin
  if Assigned(FOnInitializeCell) then 
    FOnInitializeCell(Self, ANode, AColumn, AnItem);
end;  

procedure TcxTreeListCustomReportLink.DoInitializeFooterCell(AColumn: TcxTreeListColumn; 
  ASummaryCellIndex: Integer; AnItem: TdxReportCellString);
begin
  if Assigned(FOnInitializeFooterCell) then
    FOnInitializeFooterCell(Self, ASummaryCellIndex, AColumn, AnItem);
end;  
  
procedure TcxTreeListCustomReportLink.DoInitializeHeaderCell(AColumn: TcxTreeListColumn; 
  AnItem: TdxReportCellImage);
begin
  if Assigned(FOnInitializeHeaderCell) then 
    FOnInitializeHeaderCell(Self, AColumn, AnItem);
end;  

procedure TcxTreeListCustomReportLink.DoInitializeIndentCell(ANode: TcxTreeListNode; 
  AnIndex: Integer; AnItem: TAbstractdxReportCellData);
begin
  if Assigned(FOnInitializeIndentCell) then 
    FOnInitializeIndentCell(Self, ANode, AnIndex, AnItem);
end;  

function TcxTreeListCustomReportLink.GetOptionsExpandingClass: TdxCustomReportLinkOptionsExpandingClass;
begin
  Result := TcxTreeListReportLinkOptionsExpanding;
end;

function TcxTreeListCustomReportLink.GetOptionsFormattingClass: TdxCustomReportLinkOptionsFormattingClass;
begin
  Result := TcxTreeListReportLinkOptionsFormatting;
end;

function TcxTreeListCustomReportLink.GetOptionsOnEveryPageClass: TdxCustomTableControlReportLinkOptionsOnEveryPageClass;
begin
  Result := TcxTreeListReportLinkOptionsOnEveryPage;
end;

function TcxTreeListCustomReportLink.GetOptionsPaginationClass: TdxCustomReportLinkOptionsPaginationClass;
begin
  Result := TcxTreeListReportLinkOptionsPagination;
end;

function TcxTreeListCustomReportLink.GetOptionsPreviewClass: TdxCustomTableControlReportLinkOptionsPreviewClass; 
begin
  Result := TcxTreeListReportLinkOptionsPreview;
end;

function TcxTreeListCustomReportLink.GetOptionsRefinementsClass: TdxCustomReportLinkOptionsRefinementsClass;
begin
  Result := TcxTreeListReportLinkOptionsRefinements;
end;

function TcxTreeListCustomReportLink.GetOptionsSelectionClass: TdxCustomTableControlReportLinkOptionsSelectionClass; 
begin
  Result := TcxTreeListReportLinkOptionsSelection;
end;

function TcxTreeListCustomReportLink.GetOptionsSizeClass: TdxCustomReportLinkOptionsSizeClass;
begin
  Result := TcxTreeListReportLinkOptionsSize;
end;

function TcxTreeListCustomReportLink.GetOptionsViewClass: TdxCustomReportLinkOptionsViewClass;
begin
  Result := TcxTreeListReportLinkOptionsView;
end;

procedure TcxTreeListCustomReportLink.AddReportRow(AReportRow: TdxReportCell);
begin
  FReportRows.Add(AReportRow);
end;

procedure TcxTreeListCustomReportLink.AddVerticalHardDelimiter(ADelimiter: TdxReportCell);
begin
  AddVerticalHardDelimiter(ADelimiter.AbsoluteRect.Top);
end;

procedure TcxTreeListCustomReportLink.AddVerticalHardDelimiter(ADelimiter: Integer);
begin
  FDelimitersHardVert.Add(TObject(ADelimiter));
end;

function TcxTreeListCustomReportLink.CreateBuilder: TcxTreeListReportLinkBuilder;
begin
  Result := GetBuilderClass.Create(Self);
end;

class function TcxTreeListCustomReportLink.GetBuilderClass: TcxTreeListReportLinkBuilderClass;
begin
  Result := TcxTreeListReportLinkBuilder;
end;

function TcxTreeListCustomReportLink.ExtractIndentIndex(AData: Integer): Integer;
begin
  Result := (AData and NodeIndentMask) shr NodeIndentOffset;
end;

function TcxTreeListCustomReportLink.GetItemCustomDrawInfo(AnItem: TdxReportVisualItem; 
  out ADrawInfo: TcxTreeListCellCustomDrawInfo): TcxTreeListAttributeID;

  function IsBand(AData: DWORD): Boolean;
  begin
    try
      Result := IsDelphiObject(AData) and (TObject(AData) is TcxTreeListBand);
    except
      Result := False;
    end;
    if Result then  
    begin    
      ADrawInfo.Band := TcxTreeListBand(AData);
      ADrawInfo.AttributeID := cxTreeListBandID; 
    end;  
  end;
  
  function IsColumn(AData: DWORD): Boolean;
  begin
    try
      Result := IsDelphiObject(AData) and (TObject(AData) is TcxTreeListColumn);
    except
      Result := False;
    end;   
    if Result then
      ADrawInfo.Column := TcxTreeListColumn(AData);
  end;

  function IsFooter(AData: DWORD): Boolean;
  begin
    try
      Result := TClass(AData) = TcxTreeListFooterAttribute;
    except
      Result := False;
    end;
    if Result then
      ADrawInfo.AttributeID := cxTreeListFooterID;
  end;
  
  function IsHeader(AData: Integer): Boolean;
  begin
    try
      Result := IsDelphiObject(AData) and TClass(AData).InheritsFrom(TcxTreeListHeaderAttribute);
    except
      Result := False;
    end;
    if Result then
      ADrawInfo.AttributeID := cxTreeListHeaderID;
  end;

  function IsIndent(AData: DWORD): Boolean;
  begin
    Result := True;
    ADrawInfo.Index := ExtractIndentIndex(AData);
    ADrawInfo.AttributeID := cxTreeListIndentID;
  end;
  
  function IsNode(AData: DWORD): Boolean;
  begin
    try
      Result := IsDelphiObject(AData) and (TObject(AData) is TcxTreeListNode);
    except
      Result := False;
    end;
    if Result then
    begin
      ADrawInfo.Node := TcxTreeListNode(AData);
      ADrawInfo.AttributeID := cxTreeListNodeID;
    end;  
  end;

var
  Data: DWORD;  
begin     
  FillChar(ADrawInfo, SizeOf(ADrawInfo), 0);
  try
    try
      Data := AnItem.Data;
      if IsColumn(Data) then
      begin
        if AnItem.Parent <> nil then
        begin
          Data := AnItem.Parent.Data;
          if not IsNode(Data) then 
            if not IsHeader(Data) then IsFooter(Data);
        end;
      end
      else
        if not IsBand(Data) then IsIndent(Data);
    except
      FillChar(ADrawInfo, SizeOf(ADrawInfo), 0);
    end;  
  finally
     Result := ADrawInfo.AttributeID;
  end;  
end;

function TcxTreeListCustomReportLink.IsCustomDrawn(AnAttributeID: TcxTreeListAttributeID): Boolean;
begin
  Result := False;
  case AnAttributeID of
    cxTreeListBandID:
      Result := Assigned(FOnCustomDrawBandCell);
    cxTreeListFooterID:
      Result := Assigned(FOnCustomDrawFooterCell);
    cxTreeListHeaderID:
      Result := Assigned(FOnCustomDrawHeaderCell);
    cxTreeListIndentID:
      Result := Assigned(FOnCustomDrawIndentCell);
    cxTreeListNodeID:
      Result := Assigned(FOnCustomDrawCell);
  end;    
end;

function TcxTreeListCustomReportLink.MakeIndentIndex(AnIndex: Integer): DWORD;
begin
  Result := AnIndex shl NodeIndentOffset;
end;

function TcxTreeListCustomReportLink.GetActiveStyles: TcxTreeListReportLinkStyles;
begin
  Result := inherited ActiveStyles as TcxTreeListReportLinkStyles;
end;

function TcxTreeListCustomReportLink.GetDesignWindow: TdxfmTreeListReportLinkDesignWindow;
begin
  Result := inherited DesignWindow as TdxfmTreeListReportLinkDesignWindow;
end;

function TcxTreeListCustomReportLink.GetReportRow(Index: Integer): TdxReportCell;
begin
  Result := FReportRows[Index];
end;

function TcxTreeListCustomReportLink.GetReportRowByNode(Node: TcxTreeListNode): TdxReportCell;
var
  I: Integer;
begin
  if (Node <> nil) and not Node.IsFirstVisible then
    for I := 0 to ReportRowCount - 1 do 
    begin
      Result := ReportRows[I];
      if Result.Data = Integer(Node) then Exit;
    end;
  Result := nil;  
end;

function TcxTreeListCustomReportLink.GetReportRowCount: Integer;
begin
  Result := FReportRows.Count;
end;

function TcxTreeListCustomReportLink.GetOptionsExpanding: TcxTreeListReportLinkOptionsExpanding;
begin
  Result := inherited OptionsExpanding as TcxTreeListReportLinkOptionsExpanding;
end;

function TcxTreeListCustomReportLink.GetOptionsFormatting: TcxTreeListReportLinkOptionsFormatting;
begin
  Result := inherited OptionsFormatting as TcxTreeListReportLinkOptionsFormatting;
end;

function TcxTreeListCustomReportLink.GetOptionsOnEveryPage: TcxTreeListReportLinkOptionsOnEveryPage;
begin
  Result := inherited OptionsOnEveryPage as TcxTreeListReportLinkOptionsOnEveryPage;
end;

function TcxTreeListCustomReportLink.GetOptionsPagination: TcxTreeListReportLinkOptionsPagination;
begin
  Result := inherited OptionsPagination as TcxTreeListReportLinkOptionsPagination;
end;

function TcxTreeListCustomReportLink.GetOptionsPreview: TcxTreeListReportLinkOptionsPreview;
begin
  Result := inherited OptionsPreview as TcxTreeListReportLinkOptionsPreview;
end;

function TcxTreeListCustomReportLink.GetOptionsRefinements: TcxTreeListReportLinkOptionsRefinements;
begin
  Result := inherited OptionsRefinements as TcxTreeListReportLinkOptionsRefinements;
end;

function TcxTreeListCustomReportLink.GetOptionsSelection: TcxTreeListReportLinkOptionsSelection;
begin
  Result := inherited OptionsSelection as TcxTreeListReportLinkOptionsSelection;
end;

function TcxTreeListCustomReportLink.GetOptionsSize: TcxTreeListReportLinkOptionsSize;
begin
  Result := inherited OptionsSize as TcxTreeListReportLinkOptionsSize;
end;

function TcxTreeListCustomReportLink.GetOptionsView: TcxTreeListReportLinkOptionsView;
begin
  Result := inherited OptionsView as TcxTreeListReportLinkOptionsView;
end;

function TcxTreeListCustomReportLink.GetStyles: TcxTreeListReportLinkStyles;
begin
  Result := inherited Styles as TcxTreeListReportLinkStyles;
end;

function TcxTreeListCustomReportLink.GetTreeList: TcxCustomTreeList;
begin
  Result := TcxCustomTreeList(Component);
end;

procedure TcxTreeListCustomReportLink.SetOnCustomDrawBandCell(Value: TcxTreeListReportLinkCustomDrawBandCellEvent);
begin
  if @FOnCustomDrawBandCell <> @Value then 
  begin
    FOnCustomDrawBandCell := Value;
    if SupportedCustomDraw then LinkModified(True);
  end;
end;

procedure TcxTreeListCustomReportLink.SetOnCustomDrawCell(Value: TcxTreeListReportLinkCustomDrawCellEvent);
begin
  if @FOnCustomDrawCell <> @Value then 
  begin
    FOnCustomDrawCell := Value;
    if SupportedCustomDraw then LinkModified(True);
  end;
end;

procedure TcxTreeListCustomReportLink.SetOnCustomDrawFooterCell(Value: TcxTreeListReportLinkCustomDrawFooterCellEvent);
begin
  if @FOnCustomDrawFooterCell <> @Value then 
  begin
    FOnCustomDrawFooterCell := Value;
    if SupportedCustomDraw then LinkModified(True);
  end;
end;

procedure TcxTreeListCustomReportLink.SetOnCustomDrawHeaderCell(Value: TcxTreeListReportLinkCustomDrawHeaderCellEvent);
begin
  if @FOnCustomDrawHeaderCell <> @Value then 
  begin
    FOnCustomDrawHeaderCell := Value;
    if SupportedCustomDraw then LinkModified(True);
  end;
end;

procedure TcxTreeListCustomReportLink.SetOnCustomDrawIndentCell(Value: TcxTreeListReportLinkCustomDrawIndentCellEvent);
begin
  if @FOnCustomDrawIndentCell <> @Value then 
  begin
    FOnCustomDrawIndentCell := Value;
    if SupportedCustomDraw then LinkModified(True);
  end;
end;

procedure TcxTreeListCustomReportLink.SetOptionsExpanding(Value: TcxTreeListReportLinkOptionsExpanding);
begin
  inherited OptionsExpanding := Value;
end;

procedure TcxTreeListCustomReportLink.SetOptionsFormatting(Value: TcxTreeListReportLinkOptionsFormatting);    
begin
  inherited OptionsFormatting := Value;
end;

procedure TcxTreeListCustomReportLink.SetOptionsOnEveryPage(Value: TcxTreeListReportLinkOptionsOnEveryPage);
begin
  inherited OptionsOnEveryPage := Value;
end;

procedure TcxTreeListCustomReportLink.SetOptionsPagination(Value: TcxTreeListReportLinkOptionsPagination);
begin
  inherited OptionsPagination := Value;
end;

procedure TcxTreeListCustomReportLink.SetOptionsPreview(Value: TcxTreeListReportLinkOptionsPreview);
begin
  inherited OptionsPreview := Value;
end;

procedure TcxTreeListCustomReportLink.SetOptionsRefinements(Value: TcxTreeListReportLinkOptionsRefinements);
begin
  inherited OptionsRefinements := Value;
end;

procedure TcxTreeListCustomReportLink.SetOptionsSelection(Value: TcxTreeListReportLinkOptionsSelection);
begin
  inherited OptionsSelection := Value;
end;

procedure TcxTreeListCustomReportLink.SetOptionsSize(Value: TcxTreeListReportLinkOptionsSize);
begin
  inherited OptionsSize := Value;
end;

procedure TcxTreeListCustomReportLink.SetOptionsView(Value: TcxTreeListReportLinkOptionsView);
begin
  inherited OptionsView := Value;
end;

procedure TcxTreeListCustomReportLink.SetStyles(Value: TcxTreeListReportLinkStyles);
begin
  inherited Styles := Value;
end;

{ TcxTreeListReportLink }

function TcxTreeListReportLink.GetTreeList: TcxTreeList;
begin
  Result := TcxTreeList(Component);
end;

{ TcxDBTreeListReportLink }

function TcxDBTreeListReportLink.GetDBTreeList: TcxDBTreeList;
begin
  Result := TcxDBTreeList(Component);
end;

{ TcxVirtualTreeListReportLink }

function TcxVirtualTreeListReportLink.GetVirtualTreeList: TcxVirtualTreeList;
begin
  Result := TcxVirtualTreeList(Component);
end;

{ TdxfmTreeListReportLinkDesignWindow }

constructor TdxfmTreeListReportLinkDesignWindow.Create(AOwner: TComponent);
begin
  HelpContext := dxPSGlbl .dxhccxTreeListReportLinkDesigner;
  inherited;
  CreateControls;
  SetActivePage;
end;

destructor TdxfmTreeListReportLinkDesignWindow.Destroy;
begin
  dxPSPopupMan.dxPSPopupMenuController.UnregisterControl(lbxStyles);
  inherited;
end;

procedure TdxfmTreeListReportLinkDesignWindow.DoInitialize;
begin
  lbxStyles.ReportLinkStyles := ReportLink.ActiveStyles;
  inherited DoInitialize;
  RefreshStylesList;
  
  InitializePreviewTreeList;
  InitializePreviewTreeListStyles;
  LoadDataIntoPreviewTreeList;

 (*{$IFNDEF DXVER500} {.3}
  chbxTransparentRichEdits.Visible := False;
  bvlRefinementsSeparator.Top := bvlRefinementsSeparator.Top - 15;
  chbxSuppressBackgroundBitmaps.Top := chbxSuppressBackgroundBitmaps.Top - 15;
  chbxConsumeSelectionStyle.Top := chbxConsumeSelectionStyle.Top - 15;
 {$ENDIF} *)

  with ReportLink.OptionsView do
  begin
    chbxShowBands.Checked := BandHeaders;
    chbxShowBorders.Checked := Borders;
    chbxShowExpandButtons.Checked := ExpandButtons;
    chbxShowFooters.Checked := Footers;
    chbxShowHeaders.Checked := Headers;
    chbxShowTreeLines.Checked := TreeLines;
  end;

  with ReportLink.OptionsOnEveryPage do 
  begin
    chbxBandsOnEveryPage.Checked := BandHeaders;
    chbxFootersOnEveryPage.Checked := Footers;
    chbxHeadersOnEveryPage.Checked := Headers;
  end;

  with cbxLookAndFeel do 
  begin
    Items.Clear;
    Items.AddObject(cxGetResourceString(@sdxLookAndFeelFlat), TObject(lfFlat));
    Items.AddObject(cxGetResourceString(@sdxLookAndFeelStandard), TObject(lfStandard));
    Items.AddObject(cxGetResourceString(@sdxLookAndFeelUltraFlat), TObject(lfUltraFlat));
    
    ItemIndex := Items.IndexOfObject(TObject(ReportLink.OptionsFormatting.LookAndFeelKind));
  end;

  with ReportLink.OptionsFormatting do
  begin
    ccbxSeparatorColor.ColorValue := ActualNodeSeparatorColor;
    seSeparatorThickness.AsInteger := NodeSeparatorThickness;
    chbxConsumeSelectionStyle.Checked := ConsumeSelectionStyle;
    chbxSuppressBackgroundBitmaps.Checked := SuppressBackgroundBitmaps;
    chbxUseNativeStyles.Checked := UseNativeStyles;
  end;
    
  with ReportLink.OptionsSelection do
  begin
    chbxProcessSelection.Checked := ProcessSelection;
    chbxProcessExactSelection.Checked := ProcessExactSelection;
  end;  

  with ReportLink.OptionsExpanding do
  begin
    chbxExpandNodes.Checked := AutoExpandNodes;
    chbxExplicitlyExpandNodes.Checked := ExplicitlyExpandNodes;
  end;  

  with ReportLink.OptionsSize do
  begin
    chbxAutoWidth.Checked := AutoWidth;
  end;  

  with ReportLink.OptionsRefinements do
  begin
    chbxTransparentGraphics.Checked := TransparentGraphics;
    chbxDisplayGraphicsAsText.Checked := DisplayGraphicsAsText;
    chbxFlatCheckMarks.Checked := FlatCheckMarks;
   (*{$IFDEF DXVER500} {.3}
    chbxTransparentRichEdits.Checked := TransparentRichEdits;
   {$ENDIF} *)
  end;

  with ReportLink.OptionsPreview do 
  begin
    chbxPreviewVisible.Checked := Visible;
    chbxPreviewAutoHeight.Checked := AutoHeight;
    sePreviewMaxLineCount.AsInteger := MaxLineCount;
  end;
end;

{$IFDEF DELPHI7}
function TdxfmTreeListReportLinkDesignWindow.GetPreviewHost: TCustomPanel;
begin
  Result := pnlPreview;
end;
{$ENDIF}

procedure TdxfmTreeListReportLinkDesignWindow.LoadStrings;

  procedure AdjustBevelSize(ABevel: TBevel; ALabel: TControl);
  var
    Right: Integer;
  begin
    Right := ABevel.BoundsRect.Right;
    ABevel.Left := ALabel.Left + ALabel.Width + 10;
    ABevel.Width := Right - ABevel.Left;
  end;
  
begin
  inherited;
  
  lblPreviewWindow.Caption := DropAmpersand(cxGetResourceString(@sdxPreview));
  
  tshView.Caption := cxGetResourceString(@sdxViewTab);
  
  lblShow.Caption := cxGetResourceString(@sdxShow);
  AdjustBevelSize(bvlShow, lblShow);
  chbxShowBands.Caption := cxGetResourceString(@sdxBands);
  chbxShowHeaders.Caption := cxGetResourceString(@sdxHeaders);
  chbxShowFooters.Caption := cxGetResourceString(@sdxFooters);
  Bevel2.Width := bvlShow.Width - (Bevel2.Left - bvlShow.Left);
  chbxShowBorders.Caption := cxGetResourceString(@sdxBorders);
  chbxShowExpandButtons.Caption := cxGetResourceString(@sdxExpandButtons);
  chbxShowTreeLines.Caption := cxGetResourceString(@sdxTreeLines);

  lblOnEveryPage.Caption := cxGetResourceString(@sdxOnEveryPage);
  AdjustBevelSize(bvlOnEveryPage, lblOnEveryPage);
  chbxBandsOnEveryPage.Caption := DropAmpersand(cxGetResourceString(@sdxBands));
  chbxHeadersOnEveryPage.Caption := DropAmpersand(cxGetResourceString(@sdxHeaders));
  chbxFootersOnEveryPage.Caption := DropAmpersand(cxGetResourceString(@sdxFooters));
  
  tshBehaviors.Caption := cxGetResourceString(@sdxBehaviorsTab);
  
  lblSelection.Caption := cxGetResourceString(@sdxSelection);
  AdjustBevelSize(bvlSelection, lblSelection);
  chbxProcessSelection.Caption := cxGetResourceString(@sdxProcessSelection);
  chbxProcessExactSelection.Caption := cxGetResourceString(@sdxProcessExactSelection); 
  
  lblExpanding.Caption := cxGetResourceString(@sdxExpanding);
  AdjustBevelSize(bvlExpanding, lblExpanding);  
  chbxExpandNodes.Caption := cxGetResourceString(@sdxNodes);
  chbxExplicitlyExpandNodes.Caption := cxGetResourceString(@sdxExplicitlyExpandNodes);
  
  lblSize.Caption := cxGetResourceString(@sdxSize);
  AdjustBevelSize(bvlSize, lblSize);
  chbxAutoWidth.Caption := cxGetResourceString(@sdxAutoWidth);

  tshFormatting.Caption := cxGetResourceString(@sdxFormatting);
  lblLookAndFeel.Caption := cxGetResourceString(@sdxLookAndFeel);
  AdjustBevelSize(bvlLookAndFeel, lblLookAndFeel);

  lblRefinements.Caption := cxGetResourceString(@sdxRefinements);
  AdjustBevelSize(bvlRefinements, lblRefinements);
  chbxTransparentGraphics.Caption := cxGetResourceString(@sdxTransparentGraphics);
  chbxDisplayGraphicsAsText.Caption := DropAmpersand(cxGetResourceString(@sdxDisplayGraphicsAsText));
  chbxFlatCheckMarks.Caption := cxGetResourceString(@sdxFlatCheckMarks);
  //chbxTransparentRichEdits.Caption := cxGetResourceString(@sdxTransparentRichEdits); {.3}
  chbxSuppressBackgroundBitmaps.Caption := cxGetResourceString(@sdxSuppressBackgroundBitmaps);
  chbxConsumeSelectionStyle.Caption := cxGetResourceString(@sdxConsumeSelectionStyle);

  lblSeparators.Caption := cxGetResourceString(@sdxSeparators);
  AdjustBevelSize(bvlSeparator, lblSeparators);
  lblSeparatorsColor.Caption := cxGetResourceString(@sdxColor);
  lblSeparatorsThickness.Caption := cxGetResourceString(@sdxThickness);

  tshStyles.Caption := cxGetResourceString(@sdxStyles);
  lblUseNativeStyles.Caption := cxGetResourceString(@sdxUseNativeStyles);
  AdjustBevelSize(bvlStyles, lblUseNativeStyles);
  btnStyleColor.Caption := cxGetResourceString(@sdxBtnColor);
  btnStyleFont.Caption := cxGetResourceString(@sdxBtnFont);
  btnStyleBackgroundBitmap.Caption := cxGetResourceString(@sdxBtnTexture);
  btnStyleBackgroundBitmapClear.Caption := cxGetResourceString(@sdxBtnTextureClear);
  btnStyleRestoreDefaults.Caption := cxGetResourceString(@sdxBtnRestoreDefaults);
  btnStylesSaveAs.Caption := cxGetResourceString(@sdxBtnSaveAs);

  btnStyleSheetNew.Caption := cxGetResourceString(@sdxBtnNew);
  btnStyleSheetCopy.Caption := cxGetResourceString(@sdxBtnCopy);
  btnStyleSheetDelete.Caption := cxGetResourceString(@sdxBtnDelete);
  btnStyleSheetRename.Caption := cxGetResourceString(@sdxBtnRename);    

  miStyleColor.Caption := cxGetResourceString(@sdxBtnColor);
  miStyleFont.Caption := cxGetResourceString(@sdxBtnFont);
  miStyleBackgroundBitmap.Caption := cxGetResourceString(@sdxBtnTexture);
  miStyleBackgroundBitmapClear.Caption := cxGetResourceString(@sdxBtnTextureClear);
  miStyleRestoreDefaults.Caption := cxGetResourceString(@sdxBtnRestoreDefaults);
  miStylesSelectAll.Caption := cxGetResourceString(@sdxSelectAll);
  miStylesSaveAs.Caption := cxGetResourceString(@sdxBtnSaveAs);
  
  tshPreview.Caption := cxGetResourceString(@sdxPreviewTab);
  lblPreviewOptions.Caption := cxGetResourceString(@sdxOptions);
  AdjustBevelSize(bvlPreviewOptions, lblPreviewOptions);
  chbxPreviewVisible.Caption := cxGetResourceString(@sdxVisible);
  chbxPreviewAutoHeight.Caption := cxGetResourceString(@sdxPreviewAutoHeight);
  lblPreviewMaxLineCount.Caption := cxGetResourceString(@sdxPreviewMaxLineCount);
  lblStyleSheets.Caption := cxGetResourceString(@sdxStyleSheets);
end;

procedure TdxfmTreeListReportLinkDesignWindow.UpdateControlsState;
begin
  inherited;
  chbxProcessExactSelection.Enabled := chbxProcessSelection.Checked;
  chbxExplicitlyExpandNodes.Enabled := chbxExpandNodes.Checked;
  
  lbxStyles.Enabled := AreNativeStylesAvailable;
  btnStyleColor.Enabled := AreNativeStylesAvailable and HasSelectedStyles;
  btnStyleFont.Enabled := AreNativeStylesAvailable and HasSelectedStyles;
  btnStyleBackgroundBitmap.Enabled := AreNativeStylesAvailable and HasSelectedStyles;
  btnStyleBackgroundBitmapClear.Enabled := AreNativeStylesAvailable and HasSelectedStylesWithAssignedBitmap;
  btnStyleRestoreDefaults.Enabled := AreNativeStylesAvailable and HasSelectedStyles;
  btnStylesSaveAs.Enabled := CanSaveStyles;

  lblStyleSheets.Enabled := AreNativeStylesAvailable;
  cbxStyleSheets.Enabled := AreNativeStylesAvailable;
  btnStyleSheetNew.Enabled := CanCreateStyleSheet;
  btnStyleSheetCopy.Enabled := CanCopyStyleSheet;
  btnStyleSheetDelete.Enabled := CanDeleteStyleSheet;
  btnStyleSheetRename.Enabled := CanRenameStyleSheet;

  WarningPaneUpdate;
end;

procedure TdxfmTreeListReportLinkDesignWindow.UpdatePreview;
const
  TransparentsMap: array[Boolean] of TcxImageTransparency = (gtOpaque, gtTransparent);
  TreeLineStylesMap: array[Boolean] of TcxTreeListTreeLineStyle = (tllsNone, tllsDot);
begin
  PreviewTreeList.Enabled := False;
  PreviewTreeList.LookAndFeel.Kind := ReportLink.OptionsFormatting.LookAndFeelKind;
  PreviewTreeList.LookAndFeel.NativeStyle := False; 
  PreviewTreeList.Font := ReportLink.Font;
  
  chbxBandsOnEveryPage.Enabled := not ReportLink.IsAggregated;
  chbxHeadersOnEveryPage.Enabled := not ReportLink.IsAggregated;
  chbxFootersOnEveryPage.Enabled := not ReportLink.IsAggregated;
  
  TcxImageProperties(colManufacturerLogo.Properties).GraphicTransparency := 
    TransparentsMap[ReportLink.OptionsRefinements.TransparentGraphics];

  PreviewTreeList.OptionsView.Bands := ReportLink.OptionsView.BandHeaders;
  PreviewTreeList.OptionsView.Footer := ReportLink.OptionsView.Footers;    
  PreviewTreeList.OptionsView.Headers := ReportLink.OptionsView.Headers;
  PreviewTreeList.OptionsView.Buttons := ReportLink.OptionsView.ExpandButtons;
  PreviewTreeList.OptionsView.TreeLineStyle := TreeLineStylesMap[ReportLink.OptionsView.TreeLines];
  PreviewTreeList.OptionsView.ShowRoot := (ReportLink.TreeList <> nil) and 
    CustomTreeList_GetOptionsView(ReportLink.TreeList).ShowRoot;
  PreviewTreeList.Preview.Visible := ReportLink.OptionsPreview.Visible;

  if ReportLink.TreeList <> nil then
    PreviewTreeList.OptionsView.UseNodeColorForIndent := 
      CustomTreeList_GetOptionsView(ReportLink.TreeList).UseNodeColorForIndent;
    
  PreviewTreeList.Invalidate;
end;

function TdxfmTreeListReportLinkDesignWindow.GetDesignerTabIndex: Integer;
begin
  Result := PageControl1.ActivePage.TabIndex;
end;

procedure TdxfmTreeListReportLinkDesignWindow.SetDesignerTabIndex(Value: Integer);
begin
  if Value < 0 then Value := 0;
  if Value > PageControl1.PageCount - 1 then 
    Value := PageControl1.PageCount - 1;
  PageControl1.ActivePage := PageControl1.Pages[Value];
end;

procedure TdxfmTreeListReportLinkDesignWindow.DoActiveStyleSheetChanged;
begin
  lbxStyles.ReportLinkStyles := ReportLink.ActiveStyles;
  inherited;
  with cbxStyleSheets do 
    ItemIndex := Items.IndexOfObject(ActiveStyleSheet);

  if not LockControlsUpdate then 
  begin
    Modified := True;
    UpdatePreview;
  end;  
end;

procedure TdxfmTreeListReportLinkDesignWindow.DoFormActivated(AnActive: Boolean);
begin
  inherited;
  if not AnActive then lbxStyles.HideToolTips;
end;

procedure TdxfmTreeListReportLinkDesignWindow.DoRefreshStylesList;
var
  Styles: TcxTreeListReportLinkStyles;
  List: TList;
begin
  Styles := ReportLink.ActiveStyles;
  with lbxStyles.Items do 
  begin
    BeginUpdate;
    try
      List := TList.Create;
      try
        SaveSelectedStyles(List);
        try
          Clear;
          AddObject(cxGetResourceString(@sdxBandBackgroundStyle), Styles.BandBackground);
          AddObject(cxGetResourceString(@sdxBandHeaderStyle), Styles.BandHeader);
          AddObject(cxGetResourceString(@sdxContentStyle), Styles.Content);
          AddObject(cxGetResourceString(@sdxContentEvenStyle), Styles.ContentEven);
          AddObject(cxGetResourceString(@sdxContentOddStyle), Styles.ContentOdd);
          AddObject(cxGetResourceString(@sdxFooterStyle), Styles.Footer);
          AddObject(cxGetResourceString(@sdxFooterRowStyle), Styles.FooterRow);
          AddObject(cxGetResourceString(@sdxHeaderStyle), Styles.Header);
          AddObject(cxGetResourceString(@sdxPreviewStyle), Styles.Preview);
          AddObject(cxGetResourceString(@sdxSelectionStyle), Styles.Selection);
        finally  
          RestoreSelectedStyles(List);
        end;  
      finally
        List.Free;
      end;
    finally
      EndUpdate;
    end;  
  end;
  InitializePreviewTreeListStyles;
end;

procedure TdxfmTreeListReportLinkDesignWindow.DoStyleChanged(const ACaption: string; 
  AStyle: TcxStyle);
begin
  inherited;
  UpdatePreviewTreeListStyles(ACaption, AStyle);  
end;

procedure TdxfmTreeListReportLinkDesignWindow.DoStylesChanged(AStrings: TStrings; 
  ARecreate: Boolean);
begin
  if ARecreate then 
    RecreateStylesListBox
  else
    lbxStyles.Invalidate;  
  Modified := True;
  UpdatePreview;
end;

procedure TdxfmTreeListReportLinkDesignWindow.GetSelectedStyleNames(AStrings: TStrings);
var
  I: Integer;
begin
  AStrings.Clear;
  with lbxStyles do
    for I := 0 to Items.Count - 1 do
      if Selected[I] then 
        AStrings.AddObject(Items[I], Items.Objects[I]);
end;

procedure TdxfmTreeListReportLinkDesignWindow.GetStyleNames(out AStrings: TStrings);
begin
  AStrings := lbxStyles.Items;
end;
  
procedure TdxfmTreeListReportLinkDesignWindow.GetStyleSheetNames(out AStrings: TStrings);
begin
  AStrings := cbxStyleSheets.Items;
end;

function TdxfmTreeListReportLinkDesignWindow.GetActiveStyle: TcxStyle;
begin
  with lbxStyles do
    if ItemIndex <> -1 then
      Result := TcxStyle(Items.Objects[ItemIndex])
    else
      Result := nil;
end;

function TdxfmTreeListReportLinkDesignWindow.GetHasSelectedStyles: Boolean;
begin
  Result := lbxStyles.SelCount <> 0;
end;

function TdxfmTreeListReportLinkDesignWindow.GetHasSelectedStylesWithAssignedBitmap: Boolean;
var
  Styles: TStrings;
  I: Integer;
  Style: TcxStyle;
begin
  Result := True;
  Styles := TStringList.Create;
  try
    GetSelectedStyleNames(Styles);
    for I := 0 to Styles.Count - 1 do
    begin
      Style := TcxStyle(Styles.Objects[I]);
      if (Style <> nil) and (Style.Bitmap <> nil) and not Style.Bitmap.Empty then 
        Exit;
    end;  
  finally
    Styles.Free;
  end;  
  Result := False;
end;

function TdxfmTreeListReportLinkDesignWindow.GetReportLink: TcxTreeListCustomReportLink;
begin
  Result := inherited ReportLink as TcxTreeListCustomReportLink;
end;

procedure TdxfmTreeListReportLinkDesignWindow.PreviewMaxLineCountChanged(Sender: TObject);
begin
  if LockControlsUpdate then Exit;  
  ReportLink.OptionsPreview.MaxLineCount := TdxPSSpinEdit(Sender).AsInteger;
  Modified := True;
end;

procedure TdxfmTreeListReportLinkDesignWindow.SeparatorColorChanged(Sender: TObject);
begin
  if LockControlsUpdate then Exit;  
  if TdxPSColorCombo(Sender).IsAutoColorSelected then
    ReportLink.OptionsFormatting.NodeSeparatorColor := clDefault
  else
    ReportLink.OptionsFormatting.NodeSeparatorColor := TdxPSColorCombo(Sender).ColorValue;
  Modified := True;
end;

procedure TdxfmTreeListReportLinkDesignWindow.SeparatorThicknessChanged(Sender: TObject);
begin
  if LockControlsUpdate then Exit;  
  ReportLink.OptionsFormatting.NodeSeparatorThickness := TdxPSSpinEdit(Sender).AsInteger;
  Modified := True;
end;

function TdxfmTreeListReportLinkDesignWindow.CanSelectAllStyles: Boolean;
var
  I: Integer;
begin
  Result := AreNativeStylesAvailable;
  if Result then
  begin
    for I := 0 to lbxStyles.Items.Count - 1 do
      if not lbxStyles.Selected[I] then Exit;
    Result := False;  
  end;    
end;

procedure TdxfmTreeListReportLinkDesignWindow.CreateControls;

  function CreateSpin(AHost: TControl; ALabel: TLabel; ATabOrder: TTabOrder; 
    AMinValue, AMaxValue, AValue: Integer): TdxPSSpinEdit;
  begin
    Result := TdxPSSpinEdit.Create(Self);
    with Result do 
    begin
      Parent := AHost.Parent;
      BoundsRect := AHost.BoundsRect;
      TabOrder := ATabOrder;

      MinValue := AMinValue;
      MaxValue := AMaxValue;
      Value := AValue;    
      DefaultValue := AValue;
    end;
    ALabel.FocusControl := Result;
  end;
  
  function CreateColorCombo(AHost: TControl; ALabel: TLabel; ATabOrder: TTabOrder; 
    ATag: Integer; AAutoColor: TColor): TdxPSColorCombo;
  begin
    Result := TdxPSColorCombo.Create(Self);
    with TdxPSColorCombo(Result) do
    begin
      BoundsRect := AHost.BoundsRect;
      Tag := MakeTTag(ATag);
      Parent := AHost.Parent;
      TabOrder := ATabOrder;
      ColorTypes := [ctPure];
      ShowColorName := True;
      ShowAutoColor := True;
      AutoColor := AAutoColor;
    end;
    ALabel.FocusControl := Result;
    AHost.Visible := False;
  end;

  procedure CreateWarningPane;
  begin
    wpIncorrectOnEveryPageState := TdxPSWarningPane.Create(Self);
    wpIncorrectOnEveryPageState.Parent := tshView;
    wpIncorrectOnEveryPageState.BoundsRect := bvlWarningHost.BoundsRect;
    bvlWarningHost.Visible := False;
  end;

  procedure CreateStylesListBox;  
  begin
    lbxStyles := TdxStylesListBox.Create(Self);
    lbxStyles.Parent := tshStyles;
    lbxStyles.BoundsRect := bvlStylesHost.BoundsRect;
    lbxStyles.PopupMenu := pmStyles;
    lbxStyles.TabOrder := chbxUseNativeStyles.TabOrder + 1;
    lbxStyles.OnClick := lbxStylesClick;
    bvlStylesHost.Visible := False;
    
    dxPSPopupMan.dxPSPopupMenuController.RegisterControl(lbxStyles);
  end;
      
begin             
  sePreviewMaxLineCount := CreateSpin(bvlPreviewMaxLineCountHost, lblPreviewMaxLineCount, 
    chbxPreviewAutoHeight.TabOrder + 1, 0, 1000, 0);
  sePreviewMaxLineCount.OnChange := PreviewMaxLineCountChanged;

  seSeparatorThickness := CreateSpin(bvlSeparatorThicknessHost, lblSeparatorsThickness, 
    chbxConsumeSelectionStyle.TabOrder + 1, 0, 16, 0);
  seSeparatorThickness.OnChange := SeparatorThicknessChanged;   

  ccbxSeparatorColor := CreateColorCombo(bvlSeparatorColorHost, lblSeparatorsColor,
    seSeparatorThickness.TabOrder + 1, 0, dxPSDefaultTreeListNodeSeparatorColor);
  ccbxSeparatorColor.OnChange := SeparatorColorChanged;
  
  CreateWarningPane;
  CreateStylesListBox;
end;

procedure TdxfmTreeListReportLinkDesignWindow.CustomDrawBorders(ACanvas: TcxCanvas; 
  const R: TRect);
var
  GridLinesColor: TColor;
begin
  with ReportLink do
  begin
    GridLinesColor := PreviewTreeList.OptionsView.GridLineColor;
    {if TreeList <> nil then
      GridLinesColor := CustomTreeList_GetOptionsView(TreeList).GridLineColor
    else
      GridLinesColor := PreviewTreeList.OptionsView.GridLineColor;//clWindowText;}
    if GridLinesColor = clDefault then  
      GridLinesColor := CustomTreeList_GetLookAndFeelPainter(PreviewTreeList).DefaultGridLineColor;
  end;
  ACanvas.DrawComplexFrame(R, GridLinesColor, GridLinesColor, [bLeft, bBottom, bRight]);
end;

procedure TdxfmTreeListReportLinkDesignWindow.CustomDrawCheckMark(ACanvas: TcxCanvas;
  AViewInfo: TcxTreeListEditCellViewInfo);
const
  Painters: array[Boolean] of TcxCustomLookAndFeelPainterClass =
    (TcxStandardLookAndFeelPainter, TcxUltraFlatLookAndFeelPainter);
var
  PrevColor: TColor;
  R: TRect;
  Params: TcxViewParams;
  X, Y: Integer;
  CheckValue: Variant;
begin
  PrevColor := ACanvas.Brush.Color;
  R := AViewInfo.BoundsRect;
  Params := PreviewTreeList.Styles.GetContentParams(AViewInfo.Node, AViewInfo.Column);

  if Params.Bitmap = nil then
  begin
    ACanvas.Brush.Color := Params.Color;
    ACanvas.FillRect(R);
  end
  else
    dxBkgnd.DrawPicture(Params.Bitmap, ACanvas.Canvas, R, ppmTile, 1, 1, -R.Left, -R.Top);

  X := R.Left + (R.Right - R.Left - CheckWidth) div 2;
  Y := R.Top + (R.Bottom - R.Top - CheckWidth) div 2;
  R := MakeBounds(X, Y, CheckWidth, CheckWidth);
  CheckValue := cbsChecked;
  if AViewInfo.Node.Index = 0 then
    CheckValue := cbsUnchecked;
  with Painters[ReportLink.OptionsRefinements.FlatCheckMarks] do
    DrawCheckButton(ACanvas, R, cxbsDefault, CheckValue = cbsChecked);
  ACanvas.Brush.Color := PrevColor;
end;

procedure TdxfmTreeListReportLinkDesignWindow.CustomDrawFooter(ACanvas: TcxCanvas; 
  R: TRect; AViewInfo: TcxTreeListFooterCellViewInfo);
begin
  if AViewInfo.Hidden then Exit;
  case ReportLink.OptionsFormatting.LookAndFeelKind of
    lfStandard, 
    lfFlat:
      ACanvas.DrawComplexFrame(R, AViewInfo.ViewParams.TextColor, clBtnHighlight);
    lfUltraFlat:
      ACanvas.FrameRect(R, AViewInfo.ViewParams.TextColor);
  end;    

  InflateRect(R, -1, -1);
  with AViewInfo do
    CustomDrawTextRect(ACanvas, R, Text, AlignHorz, AlignVert, ViewParams);
end;

procedure TdxfmTreeListReportLinkDesignWindow.CustomDrawHeader(ACanvas: TcxCanvas; 
  R: TRect; AViewInfo: TcxTreeListHeaderCellViewInfo);
const  
  BottomRightColors: array[Boolean] of TColor = (clBtnFace, clBtnShadow);
begin
  ACanvas.FrameRect(R, clWindowText);//AViewInfo.ViewParams.TextColor);
  if ReportLink.OptionsFormatting.LookAndFeelKind <> lfUltraFlat then
  begin
    InflateRect(R, -1, -1);
    ACanvas.DrawComplexFrame(R, clBtnHighlight, 
      BottomRightColors[ReportLink.OptionsFormatting.LookAndFeelKind = lfStandard]);
  end;
  
  InflateRect(R, -1, -1);
  with AViewInfo do
    CustomDrawTextRect(ACanvas, R, Text, AlignHorz, AlignVert, ViewParams);
end;

procedure TdxfmTreeListReportLinkDesignWindow.CustomDrawTextRect(ACanvas: TcxCanvas; 
  R: TRect; const AText: string; AnAlignmentHorz: TAlignment; AnAlignmentVert: TcxAlignmentVert; 
  AParams: TcxViewParams);
const                                              
  AlignmentHorzMap: array[TAlignment] of Integer = (cxAlignLeft, cxAlignRight, cxAlignCenter);
  AlignmentVertMap: array[TcxAlignmentVert] of Integer = (cxAlignTop, cxAlignBottom, cxAlignVCenter);  
begin
  if AParams.Bitmap = nil then 
  begin
    ACanvas.Brush.Color := AParams.Color;
    ACanvas.FillRect(R);
  end
  else
    dxBkgnd.DrawPicture(AParams.Bitmap, ACanvas.Canvas, R, ppmTile, 1, 1, - R.Left - 0, - R.Top - 0);

  InflateRect(R, -2, -1); 
  if AParams.Font <> nil then 
    ACanvas.Font := AParams.Font;
  ACanvas.Font.Color := AParams.TextColor;
  ACanvas.Brush.Style := bsClear;
  ACanvas.DrawText(AText, R, 
    AlignmentHorzMap[AnAlignmentHorz] or AlignmentVertMap[AnAlignmentVert] or cxSingleLine);
  ACanvas.Brush.Style := bsSolid;
end;

function TdxfmTreeListReportLinkDesignWindow.ExtractAlignmentHorz(
  AViewInfo: TcxTreeListEditCellViewInfo): TAlignment;
begin
  with AViewInfo.Column do 
    if Properties <> nil then 
      Result := cxEditProperties_GetAlignment(Properties).Horz
    else
      Result := taLeftJustify;
end;

function TdxfmTreeListReportLinkDesignWindow.ExtractAlignmentVert(
  AViewInfo: TcxTreeListEditCellViewInfo): TcxAlignmentVert;
const
  EditAlignmentVertMap: array[TcxEditVertAlignment] of TcxAlignmentVert = 
    (vaTop, vaBottom, vaCenter);
begin
  with AViewInfo.Column do 
    if Properties <> nil then 
      Result := EditAlignmentVertMap[cxEditProperties_GetAlignment(Properties).Vert]
    else
      Result := vaCenter;
end;

procedure TdxfmTreeListReportLinkDesignWindow.InitializePreviewTreeList;

  procedure SetupDataBindings;

    function GetColumnCaption(AnIndex: Integer): string;
    begin
      case AnIndex of
        0: Result := cxGetResourceString(@sdxManufacturerNameColumnCaption);
        1: Result := cxGetResourceString(@sdxManufacturerLogoColumnCaption);
        2: Result := cxGetResourceString(@sdxManufacturerCountryColumnCaption);
        3: Result := cxGetResourceString(@sdxCarModelColumnCaption);
      else
        Result := cxGetResourceString(@sdxCarIsSUVColumnCaption);
      end;
    end;

  const
    ColumnProperties: array[0..4] of string = 
      ('TcxTextEditProperties', 'TcxImageProperties', 'TcxTextEditProperties',
       'TcxTextEditProperties', 'TcxCheckBoxProperties');
  var
    I: Integer;
  begin
    for I := 0 to PreviewTreeList.ColumnCount - 1 do
      with PreviewTreeList.Columns[I] do
      begin
        PropertiesClassName := ColumnProperties[I];
        Caption.Text := GetColumnCaption(I);
      end;  
  end;

var
  ASummaryItems: TcxTreeListSummaryItems;
begin
  SetupDataBindings;
  //TcxImageProperties(colManufacturerLogo.Properties).Stretch := True;
  PreviewTreeList.Bands[0].Caption.Text := cxGetResourceString(@sdxManufacturerBandCaption);
  PreviewTreeList.Bands[1].Caption.Text := cxGetResourceString(@sdxModelBandCaption);
  PreviewTreeList.OptionsView.Footer := True;
  ASummaryItems :=PreviewTreeList.Columns[0].Summary.FooterSummaryItems;
  if ASummaryItems.Count = 0 then
    ASummaryItems.Add;
  ASummaryItems[0].Kind := skCount;
  ASummaryItems[0].Format := cxGetResourceString(@sdxSummaryFormat);
end;

procedure TdxfmTreeListReportLinkDesignWindow.InitializePreviewTreeListStyles;

  procedure ResetEvents(AStyles: TcxTreeListStyles);
  begin
    with AStyles do 
    begin
      OnGetBandBackgroundStyle := nil;
      OnGetBandContentStyle := nil;
      OnGetBandHeaderStyle := nil;
      OnGetBandFooterStyle := nil;
      OnGetColumnFooterStyle := nil;
      OnGetColumnHeaderStyle := nil;
      OnGetContentStyle := nil;
      OnGetNodeIndentStyle := nil;
      OnGetPreviewStyle := nil;
    end;  
  end;
  
var
  Styles: TcxTreeListReportLinkStyles;
begin
  if ReportLink.OptionsFormatting.UseNativeStyles then
  begin
    Styles := ReportLink.ActiveStyles;
    dxPSResetStyles(PreviewTreeList.Styles);
    with PreviewTreeList.Styles do
    begin
      BandBackground := Styles.BandBackground;
      BandHeader := Styles.BandHeader;
      Content := Styles.Content;
      ContentEven := Styles.ContentEven;
      ContentOdd := Styles.ContentOdd;
      ColumnFooter := Styles.Footer;
      ColumnHeader := Styles.Header;
      Footer := Styles.FooterRow;
      Preview := Styles.Preview;
    end;
  end
  else
    if ReportLink.TreeList <> nil then 
      PreviewTreeList.Styles := CustomTreeList_GetStyles(ReportLink.TreeList)
    else
      dxPScxCommon.dxPSResetStyles(PreviewTreeList.Styles);
      
  ResetEvents(PreviewTreeList.Styles);
end;

procedure TdxfmTreeListReportLinkDesignWindow.LoadDataIntoPreviewTreeList;

  function GetManufacturerName(AnIndex: Integer): string;
  begin
    case AnIndex of 
      0: Result := cxGetResourceString(@sdxCarManufacturerName5);
      1: Result := cxGetResourceString(@sdxCarManufacturerName1);
      2: Result := cxGetResourceString(@sdxCarManufacturerName2);
    else
      Result := cxGetResourceString(@sdxCarManufacturerName4);
    end;
  end;
  
  function GetManufacturerCountry(AnIndex: Integer): string;
  begin
    case AnIndex of 
      0: Result := cxGetResourceString(@sdxCarManufacturerCountry5);
      1: Result := cxGetResourceString(@sdxCarManufacturerCountry1);
      2: Result := cxGetResourceString(@sdxCarManufacturerCountry2);
    else
      Result := cxGetResourceString(@sdxCarManufacturerCountry4);
    end;
  end;

  function GetCarModel(AnIndex: Integer): string;
  begin
    case AnIndex of 
      0: Result := cxGetResourceString(@sdxCarModel5);
      1: Result := cxGetResourceString(@sdxCarModel1);
      2: Result := cxGetResourceString(@sdxCarModel2);
    else
      Result := cxGetResourceString(@sdxCarModel4);
    end;
  end;
  
const
  RecordCount = 4;
  CarLogosIndexes: array[0..RecordCount - 1] of Integer = (4, 0, 1, 3);
  AreCarsSUV: array[0..RecordCount - 1] of string = ('False', 'True', 'True', 'True');
var                 
  I: Integer;
begin
  PreviewTreeList.Clear;
  for I := 0 to RecordCount - 1 do
    with PreviewTreeList.Add do 
    begin
      Values[0] := GetManufacturerName(I);
      Values[1] := dxPScxCommon.dxPSPreviewCarLogosAsString(CarLogosIndexes[I]);
      Values[2] := GetManufacturerCountry(I);
      Values[3] := GetCarModel(I);
      Values[4] := AreCarsSUV[I];
    end;  
end;

procedure TdxfmTreeListReportLinkDesignWindow.RecreateStylesListBox;
var
  List: TList;
begin
  List := TList.Create;
  try
    SaveSelectedStyles(List);
    dxPSUtl.dxRecreateWnd(lbxStyles);
    RestoreSelectedStyles(List);
  finally
    List.Free;
  end;  
end;

procedure TdxfmTreeListReportLinkDesignWindow.RestoreSelectedStyles(AList: TList);
var
  I: Integer;
begin
  for I := 0 to AList.Count - 1 do
    lbxStyles.Selected[Integer(AList[I])] := True;
end;

procedure TdxfmTreeListReportLinkDesignWindow.SaveSelectedStyles(AList: TList);
var
  I: Integer;
begin
  AList.Clear;
  for I := 0 to lbxStyles.Items.Count - 1 do
    if lbxStyles.Selected[I] then AList.Add(TObject(I));
end;

procedure TdxfmTreeListReportLinkDesignWindow.SetActivePage;
begin
  PageControl1.ActivePage := PageControl1.Pages[DesignerTabIndex];
end;

procedure TdxfmTreeListReportLinkDesignWindow.UpdatePreviewTreeListStyles(const ACaption: string; 
  AStyle: TcxStyle);
begin
  with PreviewTreeList.Styles do
  begin
    if dxPSUtl.dxSameText(ACaption, cxGetResourceString(@sdxBandBackgroundStyle)) then
      BandBackground := AStyle
    else if dxPSUtl.dxSameText(ACaption, cxGetResourceString(@sdxBandHeaderStyle)) then
      BandHeader := AStyle
    else if dxPSUtl.dxSameText(ACaption, cxGetResourceString(@sdxContentStyle)) then
      Content := AStyle
    else if dxPSUtl.dxSameText(ACaption, cxGetResourceString(@sdxContentEvenStyle)) then 
      ContentEven := AStyle
    else if dxPSUtl.dxSameText(ACaption, cxGetResourceString(@sdxContentOddStyle)) then
      ContentOdd := AStyle
    else if dxPSUtl.dxSameText(ACaption, cxGetResourceString(@sdxFooterStyle)) then
      ColumnFooter := AStyle
    else if dxPSUtl.dxSameText(ACaption, cxGetResourceString(@sdxHeaderStyle)) then
      ColumnHeader := AStyle
    else if dxPSUtl.dxSameText(ACaption, cxGetResourceString(@sdxFooterRowStyle)) then 
      Footer := AStyle
    else if dxPSUtl.dxSameText(ACaption, cxGetResourceString(@sdxPreviewStyle)) then
      Preview := AStyle
    else if dxPSUtl.dxSameText(ACaption, cxGetResourceString(@sdxSelectionStyle)) then
      Selection := AStyle
  end;
end;

procedure TdxfmTreeListReportLinkDesignWindow.WarningPaneUpdate;
begin
  with ReportLink.HostInfoServices do
    wpIncorrectOnEveryPageState.SetStateAndHint(IsInconsistentState, InconsistentStateText);
end;

procedure TdxfmTreeListReportLinkDesignWindow.SetOptionsExpandingByIndex(Index: Integer; 
  Value: Boolean);
begin
  if LockControlsUpdate then Exit;
  with ReportLink.OptionsExpanding do
    case Index of
      0: AutoExpandNodes := Value;
      1: ExplicitlyExpandNodes := Value;
    end;  
  Modified := True;
end;

procedure TdxfmTreeListReportLinkDesignWindow.SetOptionsFormattingByIndex(Index: Integer; 
  Value: Boolean);
begin
  if LockControlsUpdate then Exit;
  with ReportLink.OptionsFormatting do
    case Index of
      0: 
         begin
           UseNativeStyles := Value;
           InitializePreviewTreeListStyles;
         end;  
      1: SuppressBackgroundBitmaps := Value;
      2: ConsumeSelectionStyle := Value;
    end; 
  Modified := True;
  UpdatePreview;
end;

procedure TdxfmTreeListReportLinkDesignWindow.SetOptionsOnEveryPageByIndex(Index: Integer; 
  Value: Boolean);        
begin
  if LockControlsUpdate then Exit;
  with ReportLink.OptionsOnEveryPage do
    case Index of
      0: BandHeaders := Value;
      1: Headers := Value;
      2: Footers := Value;
    end;  
  Modified := True;
end;

procedure TdxfmTreeListReportLinkDesignWindow.SetOptionsRefinementsByIndex(Index: Integer; 
  Value: Boolean);
begin
  if LockControlsUpdate then Exit;
  with ReportLink.OptionsRefinements do
    case Index of
      0: TransparentGraphics := Value;
      1: DisplayGraphicsAsText := Value;
      2: FlatCheckMarks := Value;      
     {$IFDEF DXVER500}
      3: TransparentRichEdits := Value;
     {$ENDIF}    
    end;  
  Modified := True;
  UpdatePreview;
end;

procedure TdxfmTreeListReportLinkDesignWindow.SetOptionsSelectionByIndex(Index: Integer; 
  Value: Boolean);
begin
  if LockControlsUpdate then Exit;
  with ReportLink.OptionsSelection do
    case Index of
      0: ProcessSelection := Value;
      1: ProcessExactSelection := Value;
    end;  
  Modified := True;
end;

procedure TdxfmTreeListReportLinkDesignWindow.SetOptionsSizeByIndex(Index: Integer; 
  Value: Boolean);
begin
  if LockControlsUpdate then Exit;
  with ReportLink.OptionsSize do
    case Index of
      0: AutoWidth := Value;
    end;  
  Modified := True;
end;

procedure TdxfmTreeListReportLinkDesignWindow.SetOptionsViewByIndex(Index: Integer; 
  Value: Boolean);
begin
  if LockControlsUpdate then Exit;
  with ReportLink.OptionsView do 
    case Index of
      0: BandHeaders := Value;
      1: Headers := Value;
      2: Footers := Value;            
      3: ExpandButtons := Value;
      4: TreeLines := Value;
      5: Borders := Value;
    end;  
  Modified := True;
  UpdatePreview;
end;

procedure TdxfmTreeListReportLinkDesignWindow.LookAndFeelChange(Sender: TObject);
begin
  if LockControlsUpdate then Exit;
  with TComboBox(Sender) do
    ReportLink.OptionsFormatting.LookAndFeelKind := TcxLookAndFeelKind(Items.Objects[ItemIndex]);
  Modified := True;
  UpdatePreview;
end;

procedure TdxfmTreeListReportLinkDesignWindow.OptionsRefinementsClick(
  Sender: TObject);
begin
  with TCheckBox(Sender) do
    SetOptionsRefinementsByIndex(TTagToInt(Tag), Checked);
end;

procedure TdxfmTreeListReportLinkDesignWindow.PreviewVisibleClick(
  Sender: TObject);
begin
  if LockControlsUpdate then Exit;
  ReportLink.OptionsPreview.Visible := TCheckBox(Sender).Checked;
  Modified := True;
  UpdatePreview;
end;

procedure TdxfmTreeListReportLinkDesignWindow.PreviewAutoHeightClick(
  Sender: TObject);
begin
  if LockControlsUpdate then Exit;
  ReportLink.OptionsPreview.AutoHeight := TCheckBox(Sender).Checked;
  Modified := True;
end;

procedure TdxfmTreeListReportLinkDesignWindow.OptionsSelectionClick(
  Sender: TObject);
begin
  with TCheckBox(Sender) do
    SetOptionsSelectionByIndex(TTagToInt(Tag), Checked);
end;

procedure TdxfmTreeListReportLinkDesignWindow.OptionsExpandingClick(
  Sender: TObject);
begin
  with TCheckBox(Sender) do
    SetOptionsExpandingByIndex(TTagToInt(Tag), Checked);
end;

procedure TdxfmTreeListReportLinkDesignWindow.OptionsSizeClick(
  Sender: TObject);
begin
  with TCheckBox(Sender) do
    SetOptionsSizeByIndex(TTagToInt(Tag), Checked);
end;

procedure TdxfmTreeListReportLinkDesignWindow.OptionsViewClick(
  Sender: TObject);
begin
  with TCheckBox(Sender) do
    SetOptionsViewByIndex(TTagToInt(Tag), Checked);
end;

procedure TdxfmTreeListReportLinkDesignWindow.OptionsOnEveryPageClick(
  Sender: TObject);
begin
  with TCheckBox(Sender) do
    SetOptionsOnEveryPageByIndex(TTagToInt(Tag), Checked);
end;

procedure TdxfmTreeListReportLinkDesignWindow.OptionsFormattingClick(
  Sender: TObject);
begin
  with TCheckBox(Sender) do
    SetOptionsFormattingByIndex(TTagToInt(Tag), Checked);
end;

procedure TdxfmTreeListReportLinkDesignWindow.lblUseNativeStylesClick(
  Sender: TObject);
begin
  if chbxUseNativeStyles.CanFocus then ActiveControl := chbxUseNativeStyles;
  chbxUseNativeStyles.Checked := not chbxUseNativeStyles.Checked;
end;

procedure TdxfmTreeListReportLinkDesignWindow.pmStylesPopup(Sender: TObject);
begin
  lbxStyles.HideToolTips;
  miStyleColor.Enabled := AreNativeStylesAvailable and HasSelectedStyles;
  miStyleFont.Enabled := AreNativeStylesAvailable and HasSelectedStyles;
  miStyleBackgroundBitmap.Enabled := AreNativeStylesAvailable and HasSelectedStyles;
  miStyleBackgroundBitmapClear.Enabled := AreNativeStylesAvailable and HasSelectedStylesWithAssignedBitmap;
  miStyleRestoreDefaults.Enabled := AreNativeStylesAvailable and HasSelectedStyles;
  miStylesSelectAll.Enabled := CanSelectAllStyles;
  miStylesSaveAs.Enabled := CanSaveStyles;
end;

procedure TdxfmTreeListReportLinkDesignWindow.StyleColorClick(Sender: TObject);
begin
  PerformStylesChangeColor;
end;

procedure TdxfmTreeListReportLinkDesignWindow.StyleFontClick(Sender: TObject);
begin
  PerformStylesChangeFont;
end;

procedure TdxfmTreeListReportLinkDesignWindow.StyleBackgroundBitmapClick(
  Sender: TObject);
begin
  PerformStylesChangeBitmap;
end;

procedure TdxfmTreeListReportLinkDesignWindow.StyleBackgroundBitmapClearClick(
  Sender: TObject);
begin
  PerformStylesClearBitmap;
end;

procedure TdxfmTreeListReportLinkDesignWindow.StyleRestoreDefaultsClick(
  Sender: TObject);
begin
  PerformStylesRestoreDefaults;
end;

procedure TdxfmTreeListReportLinkDesignWindow.cbxStyleSheetsClick(Sender: TObject);
begin
  with TComboBox(Sender) do 
    ActiveStyleSheet := TcxCustomStyleSheet(Items.Objects[ItemIndex]);
end; 

procedure TdxfmTreeListReportLinkDesignWindow.btnStyleSheetNewClick(Sender: TObject);
begin
  PerformStyleSheetNew;
end;

procedure TdxfmTreeListReportLinkDesignWindow.btnStyleSheetCopyClick(Sender: TObject);
begin
  PerformStyleSheetCopy;
end;
                              
procedure TdxfmTreeListReportLinkDesignWindow.btnStyleSheetDeleteClick(Sender: TObject);
begin
  PerformStyleSheetDelete;
end;

procedure TdxfmTreeListReportLinkDesignWindow.btnStyleSheetRenameClick(Sender: TObject);
begin
  PerformStyleSheetRename;
end;

procedure TdxfmTreeListReportLinkDesignWindow.miStylesSelectAllClick(Sender: TObject);
begin
  lbxStyles.SelectAll;
  UpdateControlsState;
end;
     
procedure TdxfmTreeListReportLinkDesignWindow.StylesSaveAsClick(Sender: TObject);
begin
  PerformStylesSaveAsStyleSheet;
end;

procedure TdxfmTreeListReportLinkDesignWindow.cbxStyleSheetsKeyDown(Sender: TObject; 
  var Key: Word; Shift: TShiftState);
begin
  PerformStyleSheetKeyDown(Sender, Key, Shift);
end;

procedure TdxfmTreeListReportLinkDesignWindow.cbxStyleSheetsDrawItem(
  Control: TWinControl; Index: Integer; Rect: TRect;
  State: TOwnerDrawState);
begin
  PerformStyleSheetDrawItem(TComboBox(Control).Canvas, Index, Rect, State, Control.Enabled);
end;

procedure TdxfmTreeListReportLinkDesignWindow.lbxStylesClick(Sender: TObject);
begin
  if LockControlsUpdate then Exit;
  UpdateControlsState;  
end;

procedure TdxfmTreeListReportLinkDesignWindow.PageControl1Change(Sender: TObject);
begin
  lblPreviewWindow.Parent := TPageControl(Sender).ActivePage;
end;

procedure RegisterAssistants;
begin
  TcxTreeListNodeHelper.Register;
  TcxTreeListReportLinkStyleSheet.Register;
end;

procedure UnregisterAssistants;
begin
  TcxTreeListReportLinkStyleSheet.Unregister;
  TcxTreeListNodeHelperFactory.ReleaseInstance;
end;

procedure TdxfmTreeListReportLinkDesignWindow.PreviewTreeListCustomDrawBandHeaderCell(
  Sender: TcxCustomTreeList; ACanvas: TcxCanvas;
  AViewInfo: TcxTreeListHeaderCellViewInfo; var ADone: Boolean);
var
  R: TRect;
begin
  R := AViewInfo.BoundsRect;
  Dec(R.Top);
  Dec(R.Left);
  CustomDrawHeader(ACanvas, R, AViewInfo);

  ADone := True;
end;

procedure TdxfmTreeListReportLinkDesignWindow.PreviewTreeListCustomDrawDataCell(
  Sender: TcxCustomTreeList; ACanvas: TcxCanvas;
  AViewInfo: TcxTreeListEditCellViewInfo; var ADone: Boolean);
begin
  if AViewInfo.Column = colManufacturerLogo then
    if ReportLink.OptionsRefinements.DisplayGraphicsAsText then
    begin
      CustomDrawTextRect(ACanvas, AViewInfo.BoundsRect, ReportLink.OptionsRefinements.GraphicsText,
        ExtractAlignmentHorz(AViewInfo), ExtractAlignmentVert(AViewInfo), AViewInfo.ViewParams);
      CustomDrawBorders(ACanvas, AViewInfo.BoundsRect);
      ADone := True;
    end;

  if AViewInfo.Column = colCarIsSUV then
  begin
    CustomDrawCheckMark(ACanvas, AViewInfo);
    CustomDrawBorders(ACanvas, AViewInfo.BoundsRect);
    ADone := True;
  end;
end;

procedure TdxfmTreeListReportLinkDesignWindow.PreviewTreeListCustomDrawFooterCell(
  Sender: TcxCustomTreeList; ACanvas: TcxCanvas;
  AViewInfo: TcxTreeListFooterCellViewInfo; var ADone: Boolean);
begin
  CustomDrawFooter(ACanvas, AViewInfo.BoundsRect, TcxTreeListFooterCellViewInfo(AViewInfo));
  ADone := True;
end;

procedure TdxfmTreeListReportLinkDesignWindow.PreviewTreeListCustomDrawHeaderCell(
  Sender: TcxCustomTreeList; ACanvas: TcxCanvas;
  AViewInfo: TcxTreeListHeaderCellViewInfo; var ADone: Boolean);
var
  R: TRect;  
begin
  R := AViewInfo.BoundsRect;
  Dec(R.Top);
  Dec(R.Left);
  CustomDrawHeader(ACanvas, R, AViewInfo);
  
  ADone := True; 
end;

initialization
  RegisterAssistants;

  dxPSRegisterReportLink(TcxTreeListReportLink, TcxTreeList, TdxfmTreeListReportLinkDesignWindow);
  dxPSRegisterReportLink(TcxDBTreeListReportLink, TcxDBTreeList, TdxfmTreeListReportLinkDesignWindow);
  dxPSRegisterReportLink(TcxVirtualTreeListReportLink, TcxVirtualTreeList, TdxfmTreeListReportLinkDesignWindow);
  
finalization
  dxPSUnregisterReportLink(TcxVirtualTreeListReportLink, TcxVirtualTreeList, TdxfmTreeListReportLinkDesignWindow);
  dxPSUnregisterReportLink(TcxDBTreeListReportLink, TcxDBTreeList, TdxfmTreeListReportLinkDesignWindow);
  dxPSUnregisterReportLink(TcxTreeListReportLink, TcxTreeList, TdxfmTreeListReportLinkDesignWindow);

  UnregisterAssistants;
  
  FreeAndNil(FDefaultdxPScxTreeListLinkStyleSheet);

end.