david
0e3448cd2f
git-svn-id: https://192.168.0.254/svn/Componentes.Terceros.DevExpressVCL@25 05c56307-c608-d34a-929d-697000501d7a
5271 lines
180 KiB
ObjectPascal
5271 lines
180 KiB
ObjectPascal
{*******************************************************************}
|
|
{ }
|
|
{ Developer Express Visual Component Library }
|
|
{ ExpressNavBar }
|
|
{ }
|
|
{ Copyright (c) 2002-2008 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 EXPRESSNAVBAR 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 dxNavBarOffice11Views;
|
|
|
|
{$I cxVer.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
Windows, Classes, Graphics, Controls, Menus, ImgList, Contnrs, Forms,
|
|
dxNavBar, dxNavBarBase, dxNavBarStyles, dxNavBarCustomPainters, dxNavBarBaseViews,
|
|
dxNavBarOfficeViews, dxNavBarExplorerViews, dxNavBarCollns, cxAccessibility,
|
|
cxContainer, cxControls, cxGraphics;
|
|
|
|
const
|
|
nbOverflowPanelSign = 0;
|
|
nbOverflowPanelItem = 1;
|
|
nbHeaderSign = 2;
|
|
nbSplitter = 3;
|
|
nbItemPanelCollapseItem = 4;
|
|
nbItemPanelCollapseBar = 5;
|
|
|
|
type
|
|
TdxNavBarNavigationPaneViewInfo = class;
|
|
TdxNavBarNavigationPanePainter = class;
|
|
|
|
{ TdxNavBarOffice11ExplorerBar }
|
|
|
|
TdxNavBarOffice11LinkViewInfo = class(TdxNavBarLinkViewInfo)
|
|
public
|
|
function FontColor: TColor; override;
|
|
end;
|
|
|
|
TdxNavBarOffice11GroupViewInfo = class(TdxNavBarExplorerBarGroupViewInfo)
|
|
private
|
|
function IsDefaultBgColor: Boolean;
|
|
function IsDefaultCaptionColor: Boolean;
|
|
public
|
|
function BorderColor: TColor; override;
|
|
function BgBackColor: TColor; override;
|
|
function BgBackColor2: TColor; override;
|
|
function BgAlphaBlend: Byte; override;
|
|
function BgAlphaBlend2: Byte; override;
|
|
function BgGradientMode: TdxBarStyleGradientMode; override;
|
|
function CaptionBackColor: TColor; override;
|
|
function CaptionBackColor2: TColor; override;
|
|
function CaptionAlphaBlend: Byte; override;
|
|
function CaptionAlphaBlend2: Byte; override;
|
|
function CaptionGradientMode: TdxBarStyleGradientMode; override;
|
|
function CaptionFontColor: TColor; override;
|
|
end;
|
|
|
|
TdxNavBarOffice11ViewInfo = class(TdxNavBarExplorerBarViewInfo)
|
|
private
|
|
function IsDefaultBgColor: Boolean;
|
|
protected
|
|
procedure CreateColors; override;
|
|
procedure RefreshColors; override;
|
|
procedure ReleaseColors; override;
|
|
|
|
function GetGroupEdges: TPoint; override;
|
|
function GetGroupSeparatorWidth: Integer; override;
|
|
function GetLinksImageEdges: TRect; override;
|
|
public
|
|
function BgBackColor: TColor; override;
|
|
function BgBackColor2: TColor; override;
|
|
function BgAlphaBlend: Byte; override;
|
|
function BgAlphaBlend2: Byte; override;
|
|
function BgGradientMode: TdxBarStyleGradientMode; override;
|
|
|
|
procedure AssignDefaultBackgroundStyle; override;
|
|
procedure AssignDefaultGroupBackgroundStyle; override;
|
|
procedure AssignDefaultGroupHeaderStyle; override;
|
|
procedure AssignDefaultGroupHeaderActiveStyle; override;
|
|
procedure AssignDefaultItemStyle; override;
|
|
end;
|
|
|
|
TdxNavBarOffice11Painter = class(TdxNavBarExplorerBarPainter)
|
|
protected
|
|
class function GetViewInfoClass: TdxNavBarViewInfoClass; override;
|
|
class function GetGroupViewInfoClass: TdxNavBarGroupViewInfoClass; override;
|
|
class function GetLinkViewInfoClass: TdxNavBarLinkViewInfoClass; override;
|
|
|
|
class function ButtonPainterClass: TdxNavBarCustomButtonPainterClass; override;
|
|
class function SignPainterClass: TdxNavBarCustomSignPainterClass; override;
|
|
end;
|
|
|
|
TdxNavBarOffice11SignPainter = class(TdxNavBarExplorerBarSignPainter)
|
|
protected
|
|
class procedure PrepareBitmap(ACanvas: TCanvas; ABitmap: TBitmap;
|
|
ABackColor1, ABackColor2: TColor; AState: TdxNavBarObjectStates);
|
|
class procedure InternalDrawSign(ACanvas: TCanvas; ARect: TRect;
|
|
AForeColor, ABackColor1, ABackColor2: TColor; AState: TdxNavBarObjectStates); override;
|
|
end;
|
|
|
|
TdxNavBarOffice11ExplorerBarGroupViewInfo = class(TdxNavBarExplorerBarGroupViewInfo)
|
|
private
|
|
function IsDefaultCaptionColor: Boolean;
|
|
public
|
|
function CaptionBorderColor: TColor; override;
|
|
function CaptionBackColor: TColor; override;
|
|
function CaptionBackColor2: TColor; override;
|
|
function CaptionAlphaBlend: Byte; override;
|
|
function CaptionAlphaBlend2: Byte; override;
|
|
function CaptionGradientMode: TdxBarStyleGradientMode; override;
|
|
end;
|
|
|
|
TdxNavBarOffice11ExplorerBarViewInfo = class(TdxNavBarExplorerBarViewInfo)
|
|
protected
|
|
procedure CreateColors; override;
|
|
procedure RefreshColors; override;
|
|
procedure ReleaseColors; override;
|
|
|
|
function CanSelectLinkByRect: Boolean; override;
|
|
function GetGroupBorderOffsets: TRect; override;
|
|
function GetGroupCaptionHeightAddon: Integer; override;
|
|
class function GetGroupCaptionImageIndent: Integer; override;
|
|
function GetGroupEdges: TPoint; override;
|
|
function GetGroupSeparatorWidth: Integer; override;
|
|
public
|
|
procedure AssignDefaultBackgroundStyle; override;
|
|
procedure AssignDefaultButtonStyle; override;
|
|
procedure AssignDefaultGroupBackgroundStyle; override;
|
|
procedure AssignDefaultGroupHeaderStyle; override;
|
|
procedure AssignDefaultItemStyle; override;
|
|
procedure AssignDefaultItemDisabledStyle; override;
|
|
procedure AssignDefaultNavigationPaneHeaderStyle; override;
|
|
end;
|
|
|
|
TdxNavBarOffice11ExplorerBarControllerState = (ecsOverSizeGrip);
|
|
TdxNavBarOffice11ExplorerBarControllerStates = set of TdxNavBarOffice11ExplorerBarControllerState;
|
|
|
|
TdxNavBarOffice11ExplorerBarController = class(TdxNavBarExplorerBarController)
|
|
private
|
|
FInternalState: TdxNavBarOffice11ExplorerBarControllerStates;
|
|
function GetMouseOverSizeGrip: Boolean;
|
|
procedure SetMouseOverSizeGrip(AValue: Boolean);
|
|
property MouseOverSizeGrip: Boolean read GetMouseOverSizeGrip write SetMouseOverSizeGrip;
|
|
protected
|
|
procedure DoMouseDown(AButton: TMouseButton; AShift: TShiftState; const APoint: TPoint); override;
|
|
procedure DoMouseMove(AShift: TShiftState; const APoint: TPoint); override;
|
|
function GetCursor: HIcon; override;
|
|
end;
|
|
|
|
TdxNavBarOffice11ExplorerBarPainter = class(TdxNavBarExplorerBarPainter)
|
|
protected
|
|
class function GetViewInfoClass: TdxNavBarViewInfoClass; override;
|
|
class function GetGroupViewInfoClass: TdxNavBarGroupViewInfoClass; override;
|
|
function GetControllerClass: TdxNavBarControllerClass; override;
|
|
|
|
class function SignPainterClass: TdxNavBarCustomSignPainterClass; override;
|
|
public
|
|
procedure DrawNavBarControl; override;
|
|
procedure DrawGroupControlSplitter(AGroupViewInfo: TdxNavBarExplorerBarGroupViewInfo); override;
|
|
end;
|
|
|
|
TdxNavBarOffice11ExplorerBarSignPainter = class(TdxNavBarExplorerBarSignPainter)
|
|
protected
|
|
class procedure DrawSignSelection(ACanvas: TCanvas; ARect: TRect; AForeColor,
|
|
ABackColor1, ABackColor2: TColor; AState: TdxNavBarObjectStates); override;
|
|
end;
|
|
|
|
{ TdxNavBarNavigationPane }
|
|
|
|
TdxNavBarNavigationPaneGroupViewInfo = class(TdxNavBarGroupViewInfo)
|
|
private
|
|
function IsDefaultCaptionColor: Boolean;
|
|
public
|
|
function CaptionBorderColor: TColor; override;
|
|
function CaptionBackColor: TColor; override;
|
|
function CaptionBackColor2: TColor; override;
|
|
function CaptionAlphaBlend: Byte; override;
|
|
function CaptionAlphaBlend2: Byte; override;
|
|
function CaptionGradientMode: TdxBarStyleGradientMode; override;
|
|
end;
|
|
|
|
TdxNavBarOffice11NavPaneGroupViewInfo = class(TdxNavBarNavigationPaneGroupViewInfo);
|
|
|
|
TdxNavBarNavigationPaneCustomViewInfo = class(TdxNavBarCustomViewInfo)
|
|
private
|
|
FViewInfo: TdxNavBarViewInfo;
|
|
function GetViewInfo: TdxNavBarNavigationPaneViewInfo;
|
|
function GetPainter: TdxNavBarNavigationPanePainter;
|
|
protected
|
|
property ViewInfo: TdxNavBarNavigationPaneViewInfo read GetViewInfo;
|
|
property Painter: TdxNavBarNavigationPanePainter read GetPainter;
|
|
public
|
|
constructor Create(AViewInfo: TdxNavBarViewInfo); virtual;
|
|
end;
|
|
|
|
TdxNavBarOverflowPanelViewInfoItem = class
|
|
public
|
|
Group: TdxNavBarGroup;
|
|
Rect: TRect;
|
|
SelectionRect: TRect;
|
|
end;
|
|
|
|
TdxNavBarOverflowPanelViewInfo = class(TdxNavBarNavigationPaneCustomViewInfo)
|
|
private
|
|
FIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
FItems: TList;
|
|
FRect: TRect;
|
|
FSignRect: TRect;
|
|
FVisibleItemCount: Integer;
|
|
|
|
procedure ClearRects;
|
|
procedure ClearItems;
|
|
procedure OffsetElements(AHeightDifference: Integer);
|
|
|
|
function GetIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
|
|
function AddItem: TdxNavBarOverflowPanelViewInfoItem;
|
|
function GetItemCount: Integer;
|
|
function GetItems(AIndex: Integer): TdxNavBarOverflowPanelViewInfoItem;
|
|
protected
|
|
function GetAccessibilityHelperClass: TdxNavBarCustomAccessibilityHelperClass; virtual;
|
|
|
|
function GetHeight: Integer; virtual;
|
|
function GetImageHeight: Integer;
|
|
function GetImageWidth: Integer;
|
|
function GetImageList: TCustomImageList;
|
|
function GetImageIndex(AGroup: TdxNavBarGroup): Integer;
|
|
function GetItemIndexAtPos(const pt: TPoint): Integer;
|
|
function GetItemSelectionWidth: Integer;
|
|
function GetGroupAtPos(const pt: TPoint): TdxNavBarGroup;
|
|
|
|
// Calculation
|
|
procedure CalculateBounds(X, Y: Integer);
|
|
|
|
// Conditions
|
|
function IsVisible: Boolean;
|
|
|
|
// Indents
|
|
function GetImageWidthAddon: Integer; virtual;
|
|
function GetSignWidth: Integer; virtual;
|
|
function GetHeightAddon: Integer; virtual;
|
|
function GetPopupMenuImageIndent: Integer; virtual;
|
|
function GetPopupMenuTextIndent: Integer; virtual;
|
|
function GetSeparator: Integer; virtual;
|
|
|
|
function GetClientOffset: TRect; virtual;
|
|
|
|
property ItemCount: Integer read GetItemCount;
|
|
property Items[AIndex: Integer]: TdxNavBarOverflowPanelViewInfoItem read GetItems;
|
|
public
|
|
constructor Create(AViewInfo: TdxNavBarViewInfo); override;
|
|
destructor Destroy; override;
|
|
|
|
property Rect: TRect read FRect;
|
|
end;
|
|
TdxNavBarOverflowPanelViewInfoClass = class of TdxNavBarOverflowPanelViewInfo;
|
|
|
|
TdxNavBarItemPanelViewInfoItem = class
|
|
private
|
|
function GetCaption: string;
|
|
protected
|
|
procedure OffsetRects(dX, dY: Integer);
|
|
public
|
|
Index: Integer;
|
|
ItemLink: TdxNavBarItemLink;
|
|
Font: TFont;
|
|
Rect: TRect;
|
|
TextRect: TRect;
|
|
ImageRect: TRect;
|
|
ImageList: TCustomImageList;
|
|
ImageIndex: Integer;
|
|
|
|
property Caption: string read GetCaption;
|
|
end;
|
|
|
|
TdxNavBarItemPanelViewInfo = class(TdxNavBarNavigationPaneCustomViewInfo)
|
|
private
|
|
FIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
FCollapseBarGroup: TdxNavBarGroup;
|
|
FCollapseBarRect: TRect;
|
|
FRect: TRect;
|
|
FActiveGroupViewInfo: TdxNavBarGroupViewInfo;
|
|
FItems: TObjectList;
|
|
|
|
FIsCollapseMode: Boolean; //#DG TODO:
|
|
|
|
function GetCollapseBarIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
function GetIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
function GetItemCount: Integer;
|
|
function GetItemIAccessibilityHelper(AIndex: Integer): IdxNavBarAccessibilityHelper;
|
|
function GetItems(AIndex: Integer): TdxNavBarItemPanelViewInfoItem;
|
|
procedure SetActiveGroupViewInfo(AValue: TdxNavBarGroupViewInfo);
|
|
|
|
function AddItem: TdxNavBarItemPanelViewInfoItem;
|
|
procedure ClearItems;
|
|
procedure CreateItems;
|
|
protected
|
|
function GetMinHeight: Integer;
|
|
|
|
procedure CalculateBounds(var X, Y: Integer);
|
|
procedure CorrectBounds(AHeightDifference: Integer);
|
|
function GetCollapseBarFont: TFont;
|
|
function GetCollapseBarText: string;
|
|
function GetItemFont(AIndex: Integer): TFont;
|
|
function GetItemIndexAtPos(const pt: TPoint): Integer;
|
|
|
|
function GetCollapseBarCaptionIndent: Integer;
|
|
|
|
function GetAccessibilityHelperClass: TdxNavBarCustomAccessibilityHelperClass; virtual;
|
|
|
|
property IAccessibilityHelper: IdxNavBarAccessibilityHelper
|
|
read GetIAccessibilityHelper;
|
|
property ActiveGroupViewInfo: TdxNavBarGroupViewInfo read FActiveGroupViewInfo write SetActiveGroupViewInfo;
|
|
property CollapseBarFont: TFont read GetCollapseBarFont;
|
|
property CollapseBarText: string read GetCollapseBarText;
|
|
property CollapseBarRect: TRect read FCollapseBarRect;
|
|
property ItemCount: Integer read GetItemCount;
|
|
property Items[AIndex: Integer]: TdxNavBarItemPanelViewInfoItem read GetItems;
|
|
property Rect: TRect read FRect;
|
|
public
|
|
constructor Create(AViewInfo: TdxNavBarViewInfo); override;
|
|
destructor Destroy; override;
|
|
|
|
property CollapseBarIAccessibilityHelper: IdxNavBarAccessibilityHelper
|
|
read GetCollapseBarIAccessibilityHelper;
|
|
property ItemIAccessibilityHelpers[AIndex: Integer]: IdxNavBarAccessibilityHelper
|
|
read GetItemIAccessibilityHelper;
|
|
end;
|
|
|
|
TdxNavBarNavigationPaneViewInfo = class(TdxNavBarOffice3ViewInfo)
|
|
private
|
|
FActiveGroupCaptionPanelIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
FSizeGripRect: TRect;
|
|
FHeaderRect: TRect;
|
|
FHeaderSignIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
FHeaderSignRect: TRect;
|
|
FHeaderTextRect: TRect;
|
|
|
|
FOverflowPanelViewInfo: TdxNavBarOverflowPanelViewInfo;
|
|
FItemPanelViewInfo: TdxNavBarItemPanelViewInfo;
|
|
|
|
FSplitterRect: TRect;
|
|
FPopupMenu: TPopupMenu;
|
|
FImageList: TImageList;
|
|
|
|
FMaxImageSize: TSize;
|
|
FImageHeightPeer: Boolean;
|
|
|
|
function GetPainter: TdxNavBarNavigationPanePainter;
|
|
|
|
function GetActiveGroupCaptionPanelIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
function GetHeaderSignIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
function GetOverflowPanelIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
function GetOverflowPanelSignIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
function GetOverflowPanelItemIAccessibilityHelper(AIndex: Integer): IdxNavBarAccessibilityHelper;
|
|
function GetNavPanePartIAccessibilityHelper(const APart: TdxNavBarPart): IdxNavBarAccessibilityHelper;
|
|
|
|
function GetSmallImagesCount: Integer;
|
|
|
|
// OverflowPanel
|
|
function GetOverflowPanelItemCount: Integer;
|
|
function GetOverflowPanelItems(AIndex: Integer): TdxNavBarOverflowPanelViewInfoItem;
|
|
function GetOverflowPanelRect: TRect;
|
|
function GetOverflowPanelSignRect: TRect;
|
|
function GetOverflowPanelVisibleItemCount: Integer;
|
|
|
|
function IsActiveGroupVisible: Boolean;
|
|
function IsGroupReflectionNeeded: Boolean;
|
|
function GetRealGroupStartIndex: Integer;
|
|
function GetRealGroupCount: Integer;
|
|
|
|
function IsDefaultHeaderColor: Boolean;
|
|
function IsDefaultOverflowPanelColor: Boolean;
|
|
function IsDefaultBottomScrollButtonColor: Boolean;
|
|
function IsDefaultTopScrollButtonColor: Boolean;
|
|
procedure RecreateImageList;
|
|
// Menu items
|
|
procedure DoMoreButtonsClick(Sender: TObject);
|
|
procedure DoFewerButtonsClick(Sender: TObject);
|
|
procedure DoAddRemoveButtonsClick(Sender: TObject);
|
|
procedure DoHiddenGroupClick(Sender: TObject);
|
|
procedure DoMeasureItem(Sender: TObject; ACanvas: TCanvas; var Width, Height: Integer);
|
|
procedure DoDrawItem(Sender: TObject; ACanvas: TCanvas; ARect: TRect;
|
|
Selected: Boolean);
|
|
protected
|
|
procedure CreateColors; override;
|
|
procedure RefreshColors; override;
|
|
procedure ReleaseColors; override;
|
|
|
|
// Sizes
|
|
function GetGroupEdges: TPoint; override;
|
|
function GetGroupSeparatorWidth: Integer; override;
|
|
function GetGroupBorderOffsets: TRect; override;
|
|
class function GetGroupCaptionImageIndent: Integer; override;
|
|
function GetGroupCaptionHeightAddon: Integer; override;
|
|
function GetGroupHeaderTextIndent: Integer; virtual;
|
|
function GetHeaderClientOffset: TRect; virtual;
|
|
function GetHeaderSignIndents: TRect; virtual;
|
|
function GetNavBarCollapsedWidth: Integer; override;
|
|
function GetNavBarMinExpandedWidth: Integer; override;
|
|
|
|
// Conditions
|
|
function CanCollapse: Boolean; override;
|
|
function CanHasGroupViewAsIconView: Boolean; override;
|
|
function CanHasImageInGroupCaption: Boolean; override;
|
|
function CanGroupCaptionBoundsByImage: Boolean; override;
|
|
function IsBottomBorderNeeded: Boolean;
|
|
function IsHeaderVisible: Boolean;
|
|
function IsSplitterVisible: Boolean;
|
|
function IsTopBorderNeeded: Boolean;
|
|
|
|
// Correction
|
|
procedure CorrectBounds; override;
|
|
|
|
// Calculations
|
|
procedure DoCreateGroupsInfo; override;
|
|
procedure DoCalculateBounds(X, Y: Integer); override;
|
|
|
|
function GetItemPanelRect: TRect;
|
|
|
|
function GetBoundsUpdateType: TdxNavBarChangeType; override;
|
|
|
|
function GetActiveGroupCaptionPanelAccessibilityHelperClass: TdxNavBarCustomAccessibilityHelperClass; virtual;
|
|
function GetHeaderSignAccessibilityHelperClass: TdxNavBarCustomAccessibilityHelperClass; virtual;
|
|
function GetOverflowPanelViewInfoClass: TdxNavBarOverflowPanelViewInfoClass; virtual;
|
|
public
|
|
constructor Create(APainter: TdxNavBarPainter); override;
|
|
destructor Destroy; override;
|
|
|
|
procedure CreateInfo; override;
|
|
procedure CreateItemPanelViewInfo;
|
|
procedure CreateOverflowPanelInfo(AItemCount: Integer; AClearOld: Boolean); virtual;
|
|
procedure CalculateSizeGripBounds; virtual;
|
|
procedure CalculateHeaderBounds(var X, Y: Integer); virtual;
|
|
procedure CalculateMaxImageSize; virtual;
|
|
procedure CalculateSplitterBounds(var X, Y: Integer); virtual;
|
|
procedure ClearRects; override;
|
|
|
|
function GetHeaderHeight: Integer; virtual;
|
|
function GetGripSize: Integer; virtual;
|
|
function GetSplitterHeight: Integer; virtual;
|
|
|
|
function GetGroupViewInfoAtItemsPos(const pt: TPoint): TdxNavBarGroupViewInfo; override;
|
|
function GetViewInfoAtDragPosition(const pt: TPoint; var ItemGroup: TdxNavBarGroupViewInfo;
|
|
var Item1, Item2: TdxNavBarLinkViewInfo): Integer; override;
|
|
|
|
function IsPtIncNavigationPaneOverflowPanelItemCount(const pt: TPoint): Boolean;
|
|
function IsPtDecNavigationPaneOverflowPanelItemCount(const pt: TPoint): Boolean;
|
|
function IsPtNavigationPaneHeader(const pt: TPoint): Boolean;
|
|
function IsPtNavigationPaneHeaderSign(const pt: TPoint): Boolean;
|
|
function IsPtNavigationPaneOverflowPanel(const pt: TPoint): Boolean;
|
|
function IsPtNavigationPaneOverflowPanelSign(const pt: TPoint): Boolean;
|
|
function IsPtNavigationPaneSplitter(const pt: TPoint): Boolean;
|
|
function IsPtNavigationPaneItemPanel(const pt: TPoint): Boolean;
|
|
|
|
procedure DoShowPopupMenu(const APoint: TPoint);
|
|
procedure DoUpdatePopupMenu; virtual;
|
|
|
|
function FindGroupWithAccel(AKey: Word): TdxNavBarGroup; override;
|
|
function FindLinkWithAccel(AKey: Word): TdxNavBarItemLink; override;
|
|
|
|
function BorderWidth: Integer; virtual;
|
|
function BorderColor: TColor; override;
|
|
function CollapseBarFontColor: TColor; virtual;
|
|
|
|
function BottomScrollButtonBackColor: TColor; override;
|
|
function BottomScrollButtonBackColor2: TColor; override;
|
|
function BottomScrollButtonAlphaBlend: Byte; override;
|
|
function BottomScrollButtonAlphaBlend2: Byte; override;
|
|
function BottomScrollButtonGradientMode: TdxBarStyleGradientMode; override;
|
|
function TopScrollButtonBackColor: TColor; override;
|
|
function TopScrollButtonBackColor2: TColor; override;
|
|
function TopScrollButtonAlphaBlend: Byte; override;
|
|
function TopScrollButtonAlphaBlend2: Byte; override;
|
|
function TopScrollButtonGradientMode: TdxBarStyleGradientMode; override;
|
|
function HeaderBackColor: TColor; override;
|
|
function HeaderBackColor2: TColor; override;
|
|
function HeaderAlphaBlend: Byte; override;
|
|
function HeaderAlphaBlend2: Byte; override;
|
|
function HeaderGradientMode: TdxBarStyleGradientMode; override;
|
|
function HeaderFontColor: TColor; override;
|
|
function OverflowPanelBackColor: TColor; override;
|
|
function OverflowPanelBackColor2: TColor; override;
|
|
function OverflowPanelAlphaBlend: Byte; override;
|
|
function OverflowPanelAlphaBlend2: Byte; override;
|
|
function OverflowPanelGradientMode: TdxBarStyleGradientMode; override;
|
|
function SplitterBackColor: TColor; override;
|
|
function SplitterBackColor2: TColor; override;
|
|
function SplitterGradientMode: TdxBarStyleGradientMode; override;
|
|
|
|
procedure AssignDefaultBackgroundStyle; override;
|
|
procedure AssignDefaultButtonStyle; override;
|
|
procedure AssignDefaultGroupBackgroundStyle; override;
|
|
procedure AssignDefaultGroupHeaderStyle; override;
|
|
procedure AssignDefaultItemStyle; override;
|
|
procedure AssignDefaultItemDisabledStyle; override;
|
|
procedure AssignDefaultNavigationPaneHeaderStyle; override;
|
|
|
|
property HeaderRect: TRect read FHeaderRect;
|
|
property HeaderSignRect: TRect read FHeaderSignRect;
|
|
property ItemPanelRect: TRect read GetItemPanelRect;
|
|
|
|
property OverflowPanelItemCount: Integer read GetOverflowPanelItemCount;
|
|
property OverflowPanelItems[Index: Integer]: TdxNavBarOverflowPanelViewInfoItem read GetOverflowPanelItems;
|
|
property OverflowPanelRect: TRect read GetOverflowPanelRect;
|
|
property OverflowPanelSignRect: TRect read GetOverflowPanelSignRect;
|
|
property OverflowPanelVisibleItemCount: Integer read GetOverflowPanelVisibleItemCount;
|
|
|
|
property SizeGripRect: TRect read FSizeGripRect;
|
|
property SplitterRect: TRect read FSplitterRect;
|
|
|
|
property ActiveGroupCaptionPanelIAccessibilityHelper: IdxNavBarAccessibilityHelper
|
|
read GetActiveGroupCaptionPanelIAccessibilityHelper;
|
|
property ImageList: TImageList read FImageList;
|
|
property ItemPanelViewInfo: TdxNavBarItemPanelViewInfo read FItemPanelViewInfo;
|
|
property PopupMenu: TPopupMenu read FPopupMenu;
|
|
property Painter: TdxNavBarNavigationPanePainter read GetPainter;
|
|
|
|
property NavPanePartIAccessibilityHelpers[const APart: TdxNavBarPart]: IdxNavBarAccessibilityHelper
|
|
read GetNavPanePartIAccessibilityHelper;
|
|
property OverflowPanelSignIAccessibilityHelper: IdxNavBarAccessibilityHelper
|
|
read GetOverflowPanelSignIAccessibilityHelper;
|
|
property OverflowPanelIAccessibilityHelper: IdxNavBarAccessibilityHelper
|
|
read GetOverflowPanelIAccessibilityHelper;
|
|
property HeaderSignIAccessibilityHelper: IdxNavBarAccessibilityHelper
|
|
read GetHeaderSignIAccessibilityHelper;
|
|
end;
|
|
|
|
TdxNavBarOffice11NavPaneViewInfo = class(TdxNavBarNavigationPaneViewInfo);
|
|
|
|
TdxNavBarPopupControlViewInfo = class(TdxNavBarNavigationPaneCustomViewInfo)
|
|
private
|
|
FRect: TRect;
|
|
|
|
function GetClientRect: TRect;
|
|
protected
|
|
procedure CalculateBounds(AClientWidth: Integer); virtual;
|
|
function CalculatePosition: TPoint; virtual;
|
|
function GetBorderOffsets: TRect; virtual;
|
|
function GetMaxHeight: Integer; virtual;
|
|
function GetMinWidth: Integer; virtual;
|
|
function IsPtSizeGrip(const pt: TPoint): Boolean; virtual;
|
|
public
|
|
property ClientRect: TRect read GetClientRect;
|
|
property Rect: TRect read FRect;
|
|
end;
|
|
TdxNavBarPopupControlViewInfoClass = class of TdxNavBarPopupControlViewInfo;
|
|
|
|
TdxNavBarPopupControlState = (pcsSizing, pcsOverSizeGrip);
|
|
TdxNavBarPopupControlStates = set of TdxNavBarPopupControlState;
|
|
|
|
TdxNavBarPopupControl = class(TcxCustomPopupWindow)
|
|
private
|
|
FCapturePointOffset: Integer;
|
|
FNavBar: TdxCustomNavBar;
|
|
FOriginalWidth: Integer;
|
|
FInnerControl: TdxCustomNavBar; // TdxNavBarPopupInnerControl
|
|
FInternalState: TdxNavBarPopupControlStates;
|
|
FSizeFrame: TcxSizeFrame;
|
|
FViewInfo: TdxNavBarPopupControlViewInfo;
|
|
|
|
procedure CreateViewInfo;
|
|
function GetPainter: TdxNavBarNavigationPanePainter;
|
|
procedure SetNewWidth(AWidth: Integer);
|
|
|
|
function GetMouseOverSizeGrip: Boolean;
|
|
procedure SetMouseOverSizeGrip(AValue: Boolean);
|
|
|
|
property MouseOverSizeGrip: Boolean read GetMouseOverSizeGrip write SetMouseOverSizeGrip;
|
|
protected
|
|
function NeedAdjustWidth: Boolean;
|
|
function CalculatePosition: TPoint; override;
|
|
procedure CalculateSize; override;
|
|
procedure BeginResize(AControl: TControl; AButton: TMouseButton; AShift: TShiftState; const APoint: TPoint);
|
|
procedure EndResize(ACancel: Boolean = False);
|
|
procedure DoShowed; override;
|
|
procedure DrawSizeFrame(const R: TRect);
|
|
procedure InitPopup; override;
|
|
procedure Paint; override;
|
|
procedure RefreshPopupWindow;
|
|
|
|
procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
|
|
procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
|
|
procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;
|
|
function NeedIgnoreMouseMessageAfterCloseUp(AWnd: THandle; AMsg: Cardinal;
|
|
AShift: TShiftState; const APos: TPoint): Boolean; override;
|
|
procedure KeyDown(var Key: Word; Shift: TShiftState); override;
|
|
public
|
|
constructor Create(ANavBar: TdxCustomNavBar); reintroduce; virtual;
|
|
destructor Destroy; override;
|
|
procedure CloseUp; override;
|
|
procedure Popup(AFocusedControl: TWinControl); override;
|
|
|
|
property Painter: TdxNavBarNavigationPanePainter read GetPainter;
|
|
property ViewInfo: TdxNavBarPopupControlViewInfo read FViewInfo;
|
|
end;
|
|
|
|
{ TdxNavBarNavigationPaneController }
|
|
|
|
TdxNavBarNavPanePartState = (oisNormal, oisHot, oisPressed, oisChecked, oisHotCheck, oisDroppedDown);
|
|
TdxNavBarNavigationPaneControllerInternalState = (npsPopupShowLocked);
|
|
TdxNavBarNavigationPaneControllerInternalStates = set of TdxNavBarNavigationPaneControllerInternalState;
|
|
|
|
TdxNavBarNavigationPaneController = class(TdxNavBarNavigationBarController)
|
|
private
|
|
FInternalState: TdxNavBarNavigationPaneControllerInternalStates;
|
|
FPopupControl: TdxNavBarPopupControl;
|
|
|
|
FDroppedDownPart: TdxNavBarPart;
|
|
|
|
procedure CalcOverflowPanelHintRect(AItem: TObject; var ARect: TRect);
|
|
procedure ChangeNavBarCollapseState;
|
|
|
|
function IsAnyItemHotTracked: Boolean;
|
|
function IsPopupControlExists: Boolean;
|
|
function IsPopupControlVisible: Boolean;
|
|
function IsOverflowPanelGroupHotTracked: Boolean;
|
|
function GetNavPanePartState(const APart: TdxNavBarPart): TdxNavBarNavPanePartState;
|
|
function GetOriginalWidth: Integer;
|
|
function GetViewInfo: TdxNavBarNavigationPaneViewInfo;
|
|
|
|
function GetOverflowPanelGroup(AIndex: Integer): TdxNavBarGroup;
|
|
|
|
procedure SetDroppedDownPart(APart: TdxNavBarPart);
|
|
procedure SetOriginalWidth(AValue: Integer);
|
|
|
|
property OverflowPanelGroup[AIndex: Integer]: TdxNavBarGroup read GetOverflowPanelGroup;
|
|
protected
|
|
function CanFocusOnClick(const APoint: TPoint): Boolean; override;
|
|
function GetCursor: HIcon; override;
|
|
function GetPartAtPos(const APoint: TPoint): TdxNavBarPart; override;
|
|
|
|
procedure DoClick(const APart: TdxNavBarPart); override;
|
|
procedure DoCheckBounds(var ALeft, ATop, AWidth, AHeight: Integer); override;
|
|
procedure DoMouseDown(AButton: TMouseButton; AShift: TShiftState; const APoint: TPoint); override;
|
|
procedure DoMouseMove(AShift: TShiftState; const APoint: TPoint); override;
|
|
procedure DoMouseLeave; override;
|
|
procedure DoSetHotPart(const APart: TdxNavBarPart); override;
|
|
procedure DoSetPressedPart(const APart: TdxNavBarPart); override;
|
|
|
|
procedure DoShowHint(var AHintInfo: THintInfo); override;
|
|
procedure DoShowOverflowPanelHint(var AHintInfo: THintInfo); virtual;
|
|
function GetNavPaneItemHintRect(const ACursorPos: TPoint): TRect; virtual;
|
|
function GetNavPaneItemHintText: string; virtual;
|
|
function GetNavPaneItemHintCursorRect: TRect; virtual;
|
|
|
|
procedure DoOverflowPanelItemClick;
|
|
procedure DoOverflowPanelSignClick;
|
|
procedure DoHeaderSignClick;
|
|
procedure DoCollapseBarClick;
|
|
procedure DoCollapseItemClick;
|
|
procedure DoSplitterDrag(const APoint: TPoint);
|
|
|
|
function Collapsible: Boolean;
|
|
function Collapsed: Boolean;
|
|
procedure CollapseStateChaged(Sender: TObject);
|
|
|
|
property OriginalWidth: Integer read GetOriginalWidth write SetOriginalWidth;
|
|
property PopupControl: TdxNavBarPopupControl read FPopupControl;
|
|
public
|
|
constructor Create(ANavBar: TdxCustomNavBar); override;
|
|
destructor Destroy; override;
|
|
|
|
procedure ClosePopupControl;
|
|
procedure ShowPopupControl;
|
|
|
|
property DroppedDownPart: TdxNavBarPart read FDroppedDownPart write SetDroppedDownPart;
|
|
property ViewInfo: TdxNavBarNavigationPaneViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
TdxNavBarNavigationPanePainter = class(TdxNavBarOffice3Painter)
|
|
private
|
|
function GetController: TdxNavBarNavigationPaneController;
|
|
function GetOverflowPanelViewInfo: TdxNavBarOverflowPanelViewInfo;
|
|
function GetViewInfo: TdxNavBarNavigationPaneViewInfo;
|
|
|
|
procedure DrawItemPanelPartFocusRect(const APartRect: TRect);
|
|
procedure DrawVertivalText(AFont: TFont; const AText: string; const ARect: TRect; AState: TdxNavBarNavPanePartState);
|
|
procedure DrawOverflowPanelItemBackground(ACanvas: TCanvas; AState: TdxNavBarNavPanePartState; const ARect: TRect); overload;
|
|
procedure DrawOverflowPanelItemBackground(ACanvas: TCanvas; const APart: TdxNavBarPart; const ARect: TRect); overload;
|
|
protected
|
|
function CreatePopupControlViewInfo: TdxNavBarPopupControlViewInfo;
|
|
class function ButtonPainterClass: TdxNavBarCustomButtonPainterClass; override;
|
|
class function GetViewInfoClass: TdxNavBarViewInfoClass; override;
|
|
class function GetGroupViewInfoClass: TdxNavBarGroupViewInfoClass; override;
|
|
function GetControllerClass: TdxNavBarControllerClass; override;
|
|
class function GetPopupControlViewInfoClass: TdxNavBarPopupControlViewInfoClass; virtual;
|
|
|
|
function GetNavPanePartState(const APart: TdxNavBarPart): TdxNavBarNavPanePartState;
|
|
|
|
procedure DoDrawHeader; virtual;
|
|
procedure DoDrawOverflowPanel; virtual;
|
|
procedure DoDrawSplitter; virtual;
|
|
public
|
|
procedure DrawNavBarControl; override;
|
|
procedure DrawGroupCaption(AGroupViewInfo: TdxNavBarGroupViewInfo); override;
|
|
procedure DrawSizeGrip(ACanvas: TCanvas; const ARect: TRect); virtual;
|
|
procedure DrawHintWindow(AHintWindow: TdxNavBarHintWindow); override;
|
|
procedure DrawItemPanel; virtual;
|
|
procedure DrawGroupCaptionButton(AGroupViewInfo: TdxNavBarGroupViewInfo); override;
|
|
procedure DrawCollapseBar(AItemPanelViewInfo: TdxNavBarItemPanelViewInfo); virtual;
|
|
procedure DrawCollapseElementBackground(const ARect: TRect; AState: TdxNavBarNavPanePartState); virtual;
|
|
procedure DrawCollapseItem(AItemViewInfo: TdxNavBarItemPanelViewInfoItem; AState: TdxNavBarNavPanePartState); virtual;
|
|
procedure DrawBorder; virtual;
|
|
procedure DrawHeader; virtual;
|
|
procedure DrawHeaderBackground; virtual;
|
|
procedure DrawHeaderSign; virtual;
|
|
procedure DrawHeaderText; virtual;
|
|
procedure DrawOverflowPanel; virtual;
|
|
procedure DrawOverflowPanelBackground; virtual;
|
|
procedure DrawOverflowPanelSign; virtual;
|
|
procedure DrawOverflowPanelItems; virtual;
|
|
procedure DrawOverflowPanelHintWindow(ACanvas: TCanvas; const ARect: TRect); virtual;
|
|
procedure DrawPopupControl(ACanvas: TcxCanvas; AViewInfo: TdxNavBarPopupControlViewInfo); virtual;
|
|
procedure DrawSplitter; virtual;
|
|
procedure DrawSplitterSign; virtual;
|
|
procedure DrawPopupMenuItem(ACanvas: TCanvas; ARect: TRect; AImageList: TCustomImageList;
|
|
AImageIndex: Integer; AText: string; State: TdxNavBarObjectStates); virtual;
|
|
|
|
property Controller: TdxNavBarNavigationPaneController read GetController;
|
|
property OverflowPanelViewInfo: TdxNavBarOverflowPanelViewInfo read GetOverflowPanelViewInfo;
|
|
property ViewInfo: TdxNavBarNavigationPaneViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
TdxNavBarNavigationPaneButtonPainter = class(TdxNavBarCustomButtonPainter)
|
|
protected
|
|
class procedure InternalDrawButton(ACanvas: TCanvas; ARect: TRect; APicture: TPicture;
|
|
AColor1, AColor2: TColor; AAlphaBlend1, AAlphaBlend2: Byte;
|
|
AGradientMode: TdxBarStyleGradientMode; ABorderColor: TColor;
|
|
AState: TdxNavBarObjectStates); override;
|
|
end;
|
|
|
|
TdxNavBarOffice11NavPaneButtonPainter = class(TdxNavBarNavigationPaneButtonPainter);
|
|
|
|
TdxNavBarOffice11NavPanePainter = class(TdxNavBarNavigationPanePainter)
|
|
protected
|
|
class function GetGroupViewInfoClass: TdxNavBarGroupViewInfoClass; override;
|
|
class function GetViewInfoClass: TdxNavBarViewInfoClass; override;
|
|
class function ButtonPainterClass: TdxNavBarCustomButtonPainterClass; override;
|
|
end;
|
|
|
|
TdxNavBarOffice11NavPaneGroupButtonPainter = class(TdxNavBarCustomButtonPainter)
|
|
protected
|
|
class procedure InternalDrawButton(ACanvas: TCanvas; ARect: TRect; APicture: TPicture;
|
|
AColor1, AColor2: TColor; AAlphaBlend1, AAlphaBlend2: Byte;
|
|
AGradientMode: TdxBarStyleGradientMode; ABorderColor: TColor;
|
|
AState: TdxNavBarObjectStates); override;
|
|
end;
|
|
|
|
{ TdxNavBarItemCollectionItemAccessibilityHelper }
|
|
|
|
TdxNavBarItemCollectionItemAccessibilityHelper = class(TdxNavBarCustomAccessibilityHelper)
|
|
private
|
|
FItemIndex: Integer;
|
|
public
|
|
property ItemIndex: Integer read FItemIndex write FItemIndex;
|
|
end;
|
|
|
|
TdxNavBarItemCollectionItemAccessibilityHelperClass = class of TdxNavBarItemCollectionItemAccessibilityHelper;
|
|
|
|
{ TdxNavBarItemCollectionAccessibilityHelper }
|
|
|
|
TdxNavBarItemCollectionAccessibilityHelper = class(TdxNavBarCustomAccessibilityHelper)
|
|
private
|
|
FItemIAccessibilityHelpers: TInterfaceList;
|
|
function GetItemIAccessibilityHelper(AIndex: Integer): IdxNavBarAccessibilityHelper;
|
|
function GetItemIAccessibilityHelperCount: Integer;
|
|
procedure SetItemIAccessibilityHelperCount(Value: Integer);
|
|
protected
|
|
function GetChild(AIndex: Integer): TcxAccessibilityHelper; override;
|
|
function GetChildCount: Integer; override;
|
|
|
|
function GetActualItemCount: Integer; virtual; abstract;
|
|
function GetItemAccessibilityHelperClass: TdxNavBarItemCollectionItemAccessibilityHelperClass; virtual; abstract;
|
|
function IsContainer: Boolean; override;
|
|
public
|
|
constructor Create(AOwnerObject: TObject;
|
|
AOwnerObjectControl: TWinControl); override;
|
|
destructor Destroy; override;
|
|
|
|
procedure CheckItemIAccessibilityHelperCount;
|
|
|
|
property ItemIAccessibilityHelperCount: Integer
|
|
read GetItemIAccessibilityHelperCount;
|
|
property ItemIAccessibilityHelpers[AIndex: Integer]: IdxNavBarAccessibilityHelper
|
|
read GetItemIAccessibilityHelper;
|
|
end;
|
|
|
|
TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper = class(TdxNavBarItemCollectionAccessibilityHelper)
|
|
private
|
|
FSignIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
function GetSignIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
function GetViewInfo: TdxNavBarOverflowPanelViewInfo;
|
|
protected
|
|
function GetChild(AIndex: Integer): TcxAccessibilityHelper; override;
|
|
function GetChildCount: Integer; override;
|
|
function GetParent: TcxAccessibilityHelper; override;
|
|
function GetState(
|
|
AChildID: TcxAccessibleSimpleChildElementID): Integer; override;
|
|
|
|
function GetActualItemCount: Integer; override;
|
|
function GetBounds: TRect; override;
|
|
function GetItemAccessibilityHelperClass: TdxNavBarItemCollectionItemAccessibilityHelperClass; override;
|
|
function GetSignAccessibilityHelperClass: TdxNavBarCustomAccessibilityHelperClass; virtual;
|
|
|
|
property ViewInfo: TdxNavBarOverflowPanelViewInfo read GetViewInfo;
|
|
public
|
|
destructor Destroy; override;
|
|
|
|
property SignIAccessibilityHelper: IdxNavBarAccessibilityHelper
|
|
read GetSignIAccessibilityHelper;
|
|
end;
|
|
|
|
TdxNavBarNavigationPaneOverflowPanelItemAccessibilityHelper = class(TdxNavBarItemCollectionItemAccessibilityHelper)
|
|
private
|
|
function GetGroup: TdxNavBarGroup;
|
|
function GetViewInfo: TdxNavBarNavigationPaneViewInfo;
|
|
protected
|
|
function GetParent: TcxAccessibilityHelper; override;
|
|
function GetState(
|
|
AChildID: TcxAccessibleSimpleChildElementID): Integer; override;
|
|
|
|
procedure Click(AKey: Word); override;
|
|
function GetBounds: TRect; override;
|
|
function IsClickKey(AKey: Word): Boolean; override;
|
|
function IsContainer: Boolean; override;
|
|
|
|
property Group: TdxNavBarGroup read GetGroup;
|
|
property ViewInfo: TdxNavBarNavigationPaneViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
TdxNavBarNavigationPaneOverflowPanelSignAccessibilityHelper = class(TdxNavBarCustomAccessibilityHelper)
|
|
private
|
|
function GetViewInfo: TdxNavBarNavigationPaneViewInfo;
|
|
protected
|
|
function GetParent: TcxAccessibilityHelper; override;
|
|
function GetState(
|
|
AChildID: TcxAccessibleSimpleChildElementID): Integer; override;
|
|
|
|
procedure Click(AKey: Word); override;
|
|
function GetBounds: TRect; override;
|
|
function IsClickKey(AKey: Word): Boolean; override;
|
|
function IsContainer: Boolean; override;
|
|
|
|
property ViewInfo: TdxNavBarNavigationPaneViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
{ TdxNavBarNavigationPaneActiveGroupCaptionPanelAccessibilityHelper }
|
|
|
|
TdxNavBarNavigationPaneActiveGroupCaptionPanelAccessibilityHelper = class(TdxNavBarCustomAccessibilityHelper)
|
|
private
|
|
function GetGroupViewInfo: TdxNavBarGroupViewInfo;
|
|
function GetNavBar: TdxCustomNavBar;
|
|
function GetNavBarViewInfo: TdxNavBarNavigationPaneViewInfo;
|
|
protected
|
|
function GetParent: TcxAccessibilityHelper; override;
|
|
function GetState(
|
|
AChildID: TcxAccessibleSimpleChildElementID): Integer; override;
|
|
|
|
function CanBeFocusedByDefault: Boolean; override;
|
|
function GetAssociatedObject: TdxNavBarCustomAccessibilityHelper; override;
|
|
function GetBounds: TRect; override;
|
|
function IsContainer: Boolean; override;
|
|
|
|
property NavBar: TdxCustomNavBar read GetNavBar;
|
|
property NavBarViewInfo: TdxNavBarNavigationPaneViewInfo read GetNavBarViewInfo;
|
|
property GroupViewInfo: TdxNavBarGroupViewInfo read GetGroupViewInfo;
|
|
end;
|
|
|
|
{ TdxNavBarNavigationPaneHeaderSignAccessibilityHelper }
|
|
|
|
TdxNavBarNavigationPaneHeaderSignAccessibilityHelper = class(TdxNavBarCustomAccessibilityHelper)
|
|
private
|
|
function GetViewInfo: TdxNavBarNavigationPaneViewInfo;
|
|
protected
|
|
function GetParent: TcxAccessibilityHelper; override;
|
|
function GetState(
|
|
AChildID: TcxAccessibleSimpleChildElementID): Integer; override;
|
|
|
|
procedure Click(AKey: Word); override;
|
|
function GetBounds: TRect; override;
|
|
function IsClickKey(AKey: Word): Boolean; override;
|
|
function IsContainer: Boolean; override;
|
|
|
|
property ViewInfo: TdxNavBarNavigationPaneViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
{ TdxNavBarItemPanelAccessibilityHelper }
|
|
|
|
TdxNavBarItemPanelAccessibilityHelper = class(TdxNavBarItemCollectionAccessibilityHelper)
|
|
private
|
|
FCollapseBarIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
function GetCollapseBarIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
function GetViewInfo: TdxNavBarItemPanelViewInfo;
|
|
protected
|
|
function GetChild(AIndex: Integer): TcxAccessibilityHelper; override;
|
|
function GetChildCount: Integer; override;
|
|
function GetParent: TcxAccessibilityHelper; override;
|
|
function GetState(
|
|
AChildID: TcxAccessibleSimpleChildElementID): Integer; override;
|
|
|
|
function GetActualItemCount: Integer; override;
|
|
function GetBounds: TRect; override;
|
|
function GetCollapseBarAccessibilityHelperClass: TdxNavBarCustomAccessibilityHelperClass; virtual;
|
|
function GetItemAccessibilityHelperClass: TdxNavBarItemCollectionItemAccessibilityHelperClass; override;
|
|
|
|
property ViewInfo: TdxNavBarItemPanelViewInfo read GetViewInfo;
|
|
public
|
|
destructor Destroy; override;
|
|
|
|
property CollapseBarIAccessibilityHelper: IdxNavBarAccessibilityHelper
|
|
read GetCollapseBarIAccessibilityHelper;
|
|
end;
|
|
|
|
{ TdxNavBarItemPanelCollapseBarAccessibilityHelper }
|
|
|
|
TdxNavBarItemPanelCollapseBarAccessibilityHelper = class(TdxNavBarCustomAccessibilityHelper)
|
|
private
|
|
function GetViewInfo: TdxNavBarItemPanelViewInfo;
|
|
protected
|
|
function GetParent: TcxAccessibilityHelper; override;
|
|
function GetState(
|
|
AChildID: TcxAccessibleSimpleChildElementID): Integer; override;
|
|
|
|
function CanBeFocusedByDefault: Boolean; override;
|
|
procedure Click(AKey: Word); override;
|
|
function GetBounds: TRect; override;
|
|
function IsClickKey(AKey: Word): Boolean; override;
|
|
function IsContainer: Boolean; override;
|
|
|
|
property ViewInfo: TdxNavBarItemPanelViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
{ TdxNavBarItemPanelItemAccessibilityHelper }
|
|
|
|
TdxNavBarItemPanelItemAccessibilityHelper = class(TdxNavBarItemCollectionItemAccessibilityHelper)
|
|
private
|
|
function GetViewInfo: TdxNavBarItemPanelViewInfo;
|
|
protected
|
|
function GetParent: TcxAccessibilityHelper; override;
|
|
function GetState(
|
|
AChildID: TcxAccessibleSimpleChildElementID): Integer; override;
|
|
|
|
function CanBeFocusedByDefault: Boolean; override;
|
|
procedure Click(AKey: Word); override;
|
|
function GetBounds: TRect; override;
|
|
function IsClickKey(AKey: Word): Boolean; override;
|
|
function IsContainer: Boolean; override;
|
|
|
|
property ViewInfo: TdxNavBarItemPanelViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
implementation
|
|
|
|
uses
|
|
{$IFDEF DELPHI6}
|
|
Types,
|
|
{$ENDIF}
|
|
SysUtils, CommCtrl, Math,
|
|
cxClasses, cxGeometry, cxLookAndFeels, dxOffice11,
|
|
dxNavBarConsts, dxNavBarGraphics, dxNavBarViewsFact, dxThemeManager, dxUxTheme,
|
|
dxNavBarAccessibility;
|
|
|
|
type
|
|
TdxCustomNavBarAccess = class(TdxCustomNavBar);
|
|
TdxNavBarControllerAccess = class(TdxNavBarController);
|
|
TdxNavBarItemAccess = class(TdxNavBarItem);
|
|
TdxNavBarPainterAccess = class(TdxNavBarPainter);
|
|
|
|
{ TdxNavBarOffice11LinkViewInfo }
|
|
|
|
function TdxNavBarOffice11LinkViewInfo.FontColor: TColor;
|
|
begin
|
|
Result := Font.Color;
|
|
if Result = clNone then Result := dxOffice11LinkFontColor;
|
|
end;
|
|
|
|
{ TdxNavBarOffice11GroupViewInfo }
|
|
|
|
function TdxNavBarOffice11GroupViewInfo.BorderColor: TColor;
|
|
begin
|
|
if IsDefaultCaptionColor then
|
|
Result := dxOffice11GroupBorderColor
|
|
else Result := inherited BorderColor;
|
|
end;
|
|
|
|
function TdxNavBarOffice11GroupViewInfo.BgAlphaBlend: Byte;
|
|
begin
|
|
if IsDefaultBgColor then
|
|
Result := 255
|
|
else Result := inherited BgAlphaBlend;
|
|
end;
|
|
|
|
function TdxNavBarOffice11GroupViewInfo.BgAlphaBlend2: Byte;
|
|
begin
|
|
if IsDefaultBgColor then
|
|
Result := 255
|
|
else Result := inherited BgAlphaBlend2;
|
|
end;
|
|
|
|
function TdxNavBarOffice11GroupViewInfo.BgBackColor: TColor;
|
|
begin
|
|
if IsDefaultBgColor then
|
|
Result := dxOffice11GroupBackgroundColor1
|
|
else Result := inherited BgBackColor;
|
|
end;
|
|
|
|
function TdxNavBarOffice11GroupViewInfo.BgBackColor2: TColor;
|
|
begin
|
|
if IsDefaultBgColor then
|
|
Result := dxOffice11GroupBackgroundColor2
|
|
else Result := inherited BgBackColor2;
|
|
end;
|
|
|
|
function TdxNavBarOffice11GroupViewInfo.BgGradientMode: TdxBarStyleGradientMode;
|
|
begin
|
|
if IsDefaultBgColor then
|
|
Result := gmVertical
|
|
else Result := inherited BgGradientMode;
|
|
end;
|
|
|
|
function TdxNavBarOffice11GroupViewInfo.CaptionAlphaBlend: Byte;
|
|
begin
|
|
if IsDefaultCaptionColor then
|
|
Result := 255
|
|
else Result := inherited CaptionAlphaBlend;
|
|
end;
|
|
|
|
function TdxNavBarOffice11GroupViewInfo.CaptionAlphaBlend2: Byte;
|
|
begin
|
|
if IsDefaultCaptionColor then
|
|
Result := 255
|
|
else Result := inherited CaptionAlphaBlend2;
|
|
end;
|
|
|
|
function TdxNavBarOffice11GroupViewInfo.CaptionBackColor: TColor;
|
|
begin
|
|
if IsDefaultCaptionColor then
|
|
Result := dxOffice11GroupCaptionColor1
|
|
else Result := inherited CaptionBackColor;
|
|
end;
|
|
|
|
function TdxNavBarOffice11GroupViewInfo.CaptionBackColor2: TColor;
|
|
begin
|
|
if IsDefaultCaptionColor then
|
|
Result := dxOffice11GroupCaptionColor2
|
|
else Result := inherited CaptionBackColor2;
|
|
end;
|
|
|
|
function TdxNavBarOffice11GroupViewInfo.CaptionGradientMode: TdxBarStyleGradientMode;
|
|
begin
|
|
if IsDefaultCaptionColor then
|
|
Result := gmHorizontal
|
|
else Result := inherited CaptionGradientMode;
|
|
end;
|
|
|
|
function TdxNavBarOffice11GroupViewInfo.CaptionFontColor: TColor;
|
|
begin
|
|
Result := CaptionFont.Color;
|
|
if Result = clNone then Result := dxOffice11GroupFontColor;
|
|
end;
|
|
|
|
function TdxNavBarOffice11GroupViewInfo.IsDefaultBgColor: Boolean;
|
|
begin
|
|
Result := (inherited BgBackColor = clNone) or (inherited BgBackColor2 = clNone);
|
|
end;
|
|
|
|
function TdxNavBarOffice11GroupViewInfo.IsDefaultCaptionColor: Boolean;
|
|
begin
|
|
Result := (inherited CaptionBackColor = clNone) or (inherited CaptionBackColor2 = clNone);
|
|
end;
|
|
|
|
{ TdxNavBarOffice11ViewInfo }
|
|
|
|
function TdxNavBarOffice11ViewInfo.BgAlphaBlend: Byte;
|
|
begin
|
|
if IsDefaultBgColor then
|
|
Result := 255
|
|
else Result := inherited BgAlphaBlend;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ViewInfo.BgAlphaBlend2: Byte;
|
|
begin
|
|
if IsDefaultBgColor then
|
|
Result := 255
|
|
else Result := inherited BgAlphaBlend2;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ViewInfo.BgBackColor: TColor;
|
|
begin
|
|
if IsDefaultBgColor then
|
|
Result := dxOffice11BackgroundColor1
|
|
else Result := inherited BgBackColor;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ViewInfo.BgBackColor2: TColor;
|
|
begin
|
|
if IsDefaultBgColor then
|
|
Result := dxOffice11BackgroundColor2
|
|
else Result := inherited BgBackColor2;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ViewInfo.BgGradientMode: TdxBarStyleGradientMode;
|
|
begin
|
|
if IsDefaultBgColor then
|
|
Result := gmVertical
|
|
else Result := inherited BgGradientMode;
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ViewInfo.AssignDefaultBackgroundStyle;
|
|
begin
|
|
NavBar.DefaultStyles.Background.ResetValues;
|
|
NavBar.DefaultStyles.Background.BackColor := clNone;
|
|
NavBar.DefaultStyles.Background.BackColor2 := clNone;
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ViewInfo.AssignDefaultGroupBackgroundStyle;
|
|
begin
|
|
NavBar.DefaultStyles.GroupBackground.ResetValues;
|
|
NavBar.DefaultStyles.GroupBackground.BackColor := clNone;
|
|
NavBar.DefaultStyles.GroupBackground.BackColor2 := clNone;
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ViewInfo.AssignDefaultGroupHeaderStyle;
|
|
begin
|
|
NavBar.DefaultStyles.GroupHeader.ResetValues;
|
|
NavBar.DefaultStyles.GroupHeader.BackColor := clNone;
|
|
NavBar.DefaultStyles.GroupHeader.BackColor2 := clNone;
|
|
NavBar.DefaultStyles.GroupHeader.Font.Color := clNone;
|
|
NavBar.DefaultStyles.GroupHeader.Font.Size := 10;
|
|
NavBar.DefaultStyles.GroupHeader.Font.Style := [fsBold];
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ViewInfo.AssignDefaultGroupHeaderActiveStyle;
|
|
begin
|
|
NavBar.DefaultStyles.GroupHeaderActive.Assign(NavBar.DefaultStyles.GroupHeader);
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ViewInfo.AssignDefaultItemStyle;
|
|
begin
|
|
NavBar.DefaultStyles.Item.ResetValues;
|
|
NavBar.DefaultStyles.Item.Font.Color := clNone;
|
|
NavBar.DefaultStyles.Item.HAlignment := haCenter;
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ViewInfo.CreateColors;
|
|
begin
|
|
dxNavBarGraphics.CreateOffice11Colors;
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ViewInfo.RefreshColors;
|
|
begin
|
|
dxNavBarGraphics.RefreshOffice11Colors;
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ViewInfo.ReleaseColors;
|
|
begin
|
|
dxNavBarGraphics.ReleaseOffice11Colors;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ViewInfo.GetGroupEdges: TPoint;
|
|
begin
|
|
Result := cxPoint(10, 4);
|
|
end;
|
|
|
|
function TdxNavBarOffice11ViewInfo.GetGroupSeparatorWidth: Integer;
|
|
begin
|
|
Result := 4;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ViewInfo.GetLinksImageEdges: TRect;
|
|
begin
|
|
Result := cxRect(4, 4, 4, 4);
|
|
end;
|
|
|
|
function TdxNavBarOffice11ViewInfo.IsDefaultBgColor: Boolean;
|
|
begin
|
|
Result := (inherited BgBackColor = clNone) or (inherited BgBackColor2 = clNone)
|
|
end;
|
|
|
|
{ TdxNavBarOffice11Painter }
|
|
|
|
class function TdxNavBarOffice11Painter.SignPainterClass: TdxNavBarCustomSignPainterClass;
|
|
begin
|
|
Result := TdxNavBarOffice11SignPainter;
|
|
end;
|
|
|
|
class function TdxNavBarOffice11Painter.GetViewInfoClass: TdxNavBarViewInfoClass;
|
|
begin
|
|
Result := TdxNavBarOffice11ViewInfo;
|
|
end;
|
|
|
|
class function TdxNavBarOffice11Painter.GetGroupViewInfoClass: TdxNavBarGroupViewInfoClass;
|
|
begin
|
|
Result := TdxNavBarOffice11GroupViewInfo;
|
|
end;
|
|
|
|
class function TdxNavBarOffice11Painter.GetLinkViewInfoClass: TdxNavBarLinkViewInfoClass;
|
|
begin
|
|
Result := TdxNavBarOffice11LinkViewInfo;
|
|
end;
|
|
|
|
class function TdxNavBarOffice11Painter.ButtonPainterClass: TdxNavBarCustomButtonPainterClass;
|
|
begin
|
|
Result := TdxNavBarAdvExplorerButtonPainter;
|
|
end;
|
|
|
|
{ TdxNavBarOffice11ExplorerBarGroupViewInfo }
|
|
|
|
function TdxNavBarOffice11ExplorerBarGroupViewInfo.CaptionBorderColor: TColor;
|
|
begin
|
|
Result := dxOffice11NavPaneBorder;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ExplorerBarGroupViewInfo.CaptionBackColor: TColor;
|
|
begin
|
|
if not IsDefaultCaptionColor then
|
|
Result := inherited CaptionBackColor
|
|
else
|
|
Result := dxOffice11NavPaneGroupCaptionColor1;
|
|
exit;
|
|
if sActive in State then
|
|
begin
|
|
if sHotTracked in State then
|
|
Result := dxOffice11NavPaneGroupCaptionPressedHotColor1
|
|
else
|
|
Result := dxOffice11NavPaneGroupCaptionPressedColor1;
|
|
end
|
|
else
|
|
if sHotTracked in State then
|
|
Result := dxOffice11NavPaneGroupCaptionHotColor1
|
|
else
|
|
Result := dxOffice11NavPaneGroupCaptionColor1;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ExplorerBarGroupViewInfo.CaptionBackColor2: TColor;
|
|
begin
|
|
if not IsDefaultCaptionColor then
|
|
Result := inherited CaptionBackColor2
|
|
else
|
|
Result := dxOffice11NavPaneGroupCaptionColor2;
|
|
Exit;
|
|
if sActive in State then
|
|
begin
|
|
if sHotTracked in State then
|
|
Result := dxOffice11NavPaneGroupCaptionPressedHotColor2
|
|
else
|
|
Result := dxOffice11NavPaneGroupCaptionPressedColor2;
|
|
end
|
|
else
|
|
if sHotTracked in State then
|
|
Result := dxOffice11NavPaneGroupCaptionHotColor2
|
|
else
|
|
Result := dxOffice11NavPaneGroupCaptionColor2;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ExplorerBarGroupViewInfo.CaptionAlphaBlend: Byte;
|
|
begin
|
|
if not IsDefaultCaptionColor then
|
|
Result := inherited CaptionAlphaBlend
|
|
else Result := 255;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ExplorerBarGroupViewInfo.CaptionAlphaBlend2: Byte;
|
|
begin
|
|
if not IsDefaultCaptionColor then
|
|
Result := inherited CaptionAlphaBlend2
|
|
else Result := 255;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ExplorerBarGroupViewInfo.CaptionGradientMode: TdxBarStyleGradientMode;
|
|
begin
|
|
if not IsDefaultCaptionColor then
|
|
Result := inherited CaptionGradientMode
|
|
else Result := gmVertical;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ExplorerBarGroupViewInfo.IsDefaultCaptionColor: Boolean;
|
|
begin
|
|
Result := (inherited CaptionBackColor = clNone) or (inherited CaptionBackColor2 = clNone);
|
|
end;
|
|
|
|
{ TdxNavBarOffice11ExplorerBarViewInfo }
|
|
|
|
procedure TdxNavBarOffice11ExplorerBarViewInfo.AssignDefaultBackgroundStyle;
|
|
begin
|
|
NavBar.DefaultStyles.Background.ResetValues;
|
|
NavBar.DefaultStyles.Background.BackColor := clWindow;
|
|
NavBar.DefaultStyles.Background.BackColor2 := clWindow;
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ExplorerBarViewInfo.AssignDefaultButtonStyle;
|
|
begin
|
|
NavBar.DefaultStyles.Button.ResetValues;
|
|
NavBar.DefaultStyles.Button.BackColor := clNone;
|
|
NavBar.DefaultStyles.Button.BackColor2 := clNone;
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ExplorerBarViewInfo.AssignDefaultGroupBackgroundStyle;
|
|
begin
|
|
NavBar.DefaultStyles.GroupBackground.ResetValues;
|
|
NavBar.DefaultStyles.GroupBackground.BackColor := clWindow;
|
|
NavBar.DefaultStyles.GroupBackground.BackColor2 := clWindow;
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ExplorerBarViewInfo.AssignDefaultGroupHeaderStyle;
|
|
begin
|
|
NavBar.DefaultStyles.GroupHeader.ResetValues;
|
|
NavBar.DefaultStyles.GroupHeader.BackColor := clNone;
|
|
NavBar.DefaultStyles.GroupHeader.BackColor2 := clNone;
|
|
NavBar.DefaultStyles.GroupHeader.Font.Style := [fsBold];
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ExplorerBarViewInfo.AssignDefaultItemStyle;
|
|
begin
|
|
NavBar.DefaultStyles.Item.ResetValues;
|
|
NavBar.DefaultStyles.Item.Font.Color := clWindowText;
|
|
NavBar.DefaultStyles.Item.HAlignment := haCenter;
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ExplorerBarViewInfo.AssignDefaultItemDisabledStyle;
|
|
begin
|
|
NavBar.DefaultStyles.ItemDisabled.Assign(NavBar.DefaultStyles.Item);
|
|
NavBar.DefaultStyles.ItemDisabled.Font.Color := clGrayText;
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ExplorerBarViewInfo.AssignDefaultNavigationPaneHeaderStyle;
|
|
begin
|
|
NavBar.DefaultStyles.NavigationPaneHeader.ResetValues;
|
|
NavBar.DefaultStyles.NavigationPaneHeader.BackColor := clNone;
|
|
NavBar.DefaultStyles.NavigationPaneHeader.BackColor2 := clNone;
|
|
NavBar.DefaultStyles.NavigationPaneHeader.Font.Color := clNone;
|
|
NavBar.DefaultStyles.NavigationPaneHeader.Font.Name := 'Arial';
|
|
NavBar.DefaultStyles.NavigationPaneHeader.Font.Size := 11;
|
|
NavBar.DefaultStyles.NavigationPaneHeader.Font.Style := [fsBold];
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ExplorerBarViewInfo.CreateColors;
|
|
begin
|
|
CreateOffice11NavPaneColors;
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ExplorerBarViewInfo.RefreshColors;
|
|
begin
|
|
RefreshOffice11NavPaneColors;
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ExplorerBarViewInfo.ReleaseColors;
|
|
begin
|
|
ReleaseOffice11NavPaneColors;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ExplorerBarViewInfo.CanSelectLinkByRect: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ExplorerBarViewInfo.GetGroupBorderOffsets: TRect;
|
|
begin
|
|
Result := cxNullRect;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ExplorerBarViewInfo.GetGroupCaptionHeightAddon: Integer;
|
|
begin
|
|
Result := 6;
|
|
end;
|
|
|
|
class function TdxNavBarOffice11ExplorerBarViewInfo.GetGroupCaptionImageIndent: Integer;
|
|
begin
|
|
Result := 2;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ExplorerBarViewInfo.GetGroupEdges: TPoint;
|
|
begin
|
|
Result := cxPoint(0, 0);
|
|
end;
|
|
|
|
function TdxNavBarOffice11ExplorerBarViewInfo.GetGroupSeparatorWidth: Integer;
|
|
begin
|
|
Result := 0;
|
|
end;
|
|
|
|
{ TdxNavBarOffice11ExplorerBarController }
|
|
|
|
procedure TdxNavBarOffice11ExplorerBarController.DoMouseDown(AButton: TMouseButton; AShift: TShiftState; const APoint: TPoint);
|
|
begin
|
|
if MouseOverSizeGrip then
|
|
TdxNavBarGroupControl(FNavBar.Parent).BeginResize(FNavBar, AButton, AShift, APoint)
|
|
else
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ExplorerBarController.DoMouseMove(AShift: TShiftState; const APoint: TPoint);
|
|
begin
|
|
MouseOverSizeGrip := (FNavBar.Parent is TdxNavBarGroupControl) and
|
|
TdxNavBarGroupControl(FNavBar.Parent).IsOnPopupControl and
|
|
not (FNavBar.IsPtBottomScrollButton(APoint) or FNavBar.IsPtTopScrollButton(APoint)) and
|
|
cxRectPtIn(TdxNavBarGroupControl(FNavBar.Parent).GetSizeGripRect(FNavBar), APoint);
|
|
if not MouseOverSizeGrip then
|
|
inherited;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ExplorerBarController.GetCursor: HIcon;
|
|
begin
|
|
if MouseOverSizeGrip then
|
|
Result := Screen.Cursors[crSizeWE]
|
|
else
|
|
Result := inherited GetCursor;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ExplorerBarController.GetMouseOverSizeGrip: Boolean;
|
|
begin
|
|
Result := ecsOverSizeGrip in FInternalState;
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ExplorerBarController.SetMouseOverSizeGrip(AValue: Boolean);
|
|
begin
|
|
if MouseOverSizeGrip <> AValue then
|
|
if AValue then
|
|
Include(FInternalState, ecsOverSizeGrip)
|
|
else
|
|
Exclude(FInternalState, ecsOverSizeGrip);
|
|
end;
|
|
|
|
{ TdxNavBarOffice11ExplorerBarPainter }
|
|
|
|
procedure TdxNavBarOffice11ExplorerBarPainter.DrawNavBarControl;
|
|
begin
|
|
inherited;
|
|
if (NavBar.Parent is TdxNavBarGroupControl) and
|
|
TdxNavBarGroupControl(NavBar.Parent).IsOnPopupControl then
|
|
TdxNavBarGroupControl(NavBar.Parent).DrawSizeGrip(Canvas, TdxNavBarGroupControl(NavBar.Parent).GetSizeGripRect(NavBar));
|
|
end;
|
|
|
|
procedure TdxNavBarOffice11ExplorerBarPainter.DrawGroupControlSplitter(AGroupViewInfo: TdxNavBarExplorerBarGroupViewInfo);
|
|
var
|
|
APoint: TPoint;
|
|
begin
|
|
with AGroupViewInfo do
|
|
ButtonPainterClass.DrawButton(Canvas, SplitterRect, CaptionImage,
|
|
CaptionBackColor, CaptionBackColor2, CaptionAlphaBlend, CaptionAlphaBlend2,
|
|
CaptionGradientMode, CaptionBorderColor, State);
|
|
if dxOffice11NavPaneSplitterBitmap <> nil then
|
|
begin
|
|
APoint := cxRectCenter(AGroupViewInfo.SplitterRect, dxOffice11NavPaneSplitterBitmap.Width, dxOffice11NavPaneSplitterBitmap.Height).TopLeft;
|
|
if APoint.X > AGroupViewInfo.SplitterRect.Left then
|
|
Canvas.Draw(APoint.X, APoint.Y, dxOffice11NavPaneSplitterBitmap);
|
|
end;
|
|
end;
|
|
|
|
class function TdxNavBarOffice11ExplorerBarPainter.GetViewInfoClass: TdxNavBarViewInfoClass;
|
|
begin
|
|
Result := TdxNavBarOffice11ExplorerBarViewInfo;
|
|
end;
|
|
|
|
class function TdxNavBarOffice11ExplorerBarPainter.GetGroupViewInfoClass: TdxNavBarGroupViewInfoClass;
|
|
begin
|
|
Result := TdxNavBarOffice11ExplorerBarGroupViewInfo;
|
|
end;
|
|
|
|
function TdxNavBarOffice11ExplorerBarPainter.GetControllerClass: TdxNavBarControllerClass;
|
|
begin
|
|
Result := TdxNavBarOffice11ExplorerBarController;
|
|
end;
|
|
|
|
class function TdxNavBarOffice11ExplorerBarPainter.SignPainterClass: TdxNavBarCustomSignPainterClass;
|
|
begin
|
|
Result := TdxNavBarOffice11ExplorerBarSignPainter;
|
|
end;
|
|
|
|
{ TdxNavBarOffice11ExplorerBarSignPainter }
|
|
|
|
class procedure TdxNavBarOffice11ExplorerBarSignPainter.DrawSignSelection(ACanvas: TCanvas; ARect: TRect; AForeColor,
|
|
ABackColor1, ABackColor2: TColor; AState: TdxNavBarObjectStates);
|
|
begin
|
|
end;
|
|
|
|
{ TdxNavBarNavigationPane }
|
|
|
|
function TdxNavBarNavigationPaneGroupViewInfo.CaptionBorderColor: TColor;
|
|
begin
|
|
Result := dxOffice11NavPaneBorder;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneGroupViewInfo.CaptionBackColor: TColor;
|
|
begin
|
|
if not IsDefaultCaptionColor then
|
|
Result := inherited CaptionBackColor
|
|
else
|
|
if sActive in State then
|
|
begin
|
|
if sHotTracked in State then
|
|
Result := dxOffice11NavPaneGroupCaptionPressedHotColor1
|
|
else
|
|
Result := dxOffice11NavPaneGroupCaptionPressedColor1;
|
|
end
|
|
else
|
|
if sHotTracked in State then
|
|
Result := dxOffice11NavPaneGroupCaptionHotColor1
|
|
else
|
|
Result := dxOffice11NavPaneGroupCaptionColor1;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneGroupViewInfo.CaptionBackColor2: TColor;
|
|
begin
|
|
if not IsDefaultCaptionColor then
|
|
Result := inherited CaptionBackColor2
|
|
else
|
|
if sActive in State then
|
|
begin
|
|
if sHotTracked in State then
|
|
Result := dxOffice11NavPaneGroupCaptionPressedHotColor2
|
|
else
|
|
Result := dxOffice11NavPaneGroupCaptionPressedColor2;
|
|
end
|
|
else
|
|
if sHotTracked in State then
|
|
Result := dxOffice11NavPaneGroupCaptionHotColor2
|
|
else
|
|
Result := dxOffice11NavPaneGroupCaptionColor2;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneGroupViewInfo.CaptionAlphaBlend: Byte;
|
|
begin
|
|
if not IsDefaultCaptionColor then
|
|
Result := inherited CaptionAlphaBlend
|
|
else Result := 255;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneGroupViewInfo.CaptionAlphaBlend2: Byte;
|
|
begin
|
|
if not IsDefaultCaptionColor then
|
|
Result := inherited CaptionAlphaBlend2
|
|
else Result := 255;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneGroupViewInfo.CaptionGradientMode: TdxBarStyleGradientMode;
|
|
begin
|
|
if not IsDefaultCaptionColor then
|
|
Result := inherited CaptionGradientMode
|
|
else Result := gmVertical;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneGroupViewInfo.IsDefaultCaptionColor: Boolean;
|
|
begin
|
|
Result := (inherited CaptionBackColor = clNone) or (inherited CaptionBackColor2 = clNone);
|
|
end;
|
|
|
|
{ TdxNavBarNavigationPaneCustomViewInfo }
|
|
|
|
constructor TdxNavBarNavigationPaneCustomViewInfo.Create(AViewInfo: TdxNavBarViewInfo);
|
|
begin
|
|
inherited Create;
|
|
FViewInfo := AViewInfo;
|
|
FPainter := FViewInfo.Painter;
|
|
FNavBar := FViewInfo.NavBar;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneCustomViewInfo.GetViewInfo: TdxNavBarNavigationPaneViewInfo;
|
|
begin
|
|
Result := TdxNavBarNavigationPaneViewInfo(FViewInfo);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneCustomViewInfo.GetPainter: TdxNavBarNavigationPanePainter;
|
|
begin
|
|
Result := TdxNavBarNavigationPanePainter(inherited Painter);
|
|
end;
|
|
|
|
{ TdxNavBarOverflowPanelViewInfo }
|
|
|
|
constructor TdxNavBarOverflowPanelViewInfo.Create(AViewInfo: TdxNavBarViewInfo);
|
|
begin
|
|
inherited;
|
|
FItems := TObjectList.Create;
|
|
end;
|
|
|
|
destructor TdxNavBarOverflowPanelViewInfo.Destroy;
|
|
begin
|
|
ClearItems;
|
|
FreeAndNil(FItems);
|
|
NavBarAccessibleObjectOwnerObjectDestroyed(FIAccessibilityHelper);
|
|
inherited;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetAccessibilityHelperClass: TdxNavBarCustomAccessibilityHelperClass;
|
|
begin
|
|
Result := TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper;
|
|
end;
|
|
|
|
procedure TdxNavBarOverflowPanelViewInfo.CalculateBounds(X, Y: Integer);
|
|
|
|
procedure CalculateItemRects(const AItemsRect: TRect);
|
|
var
|
|
I, AStartPos, ASelectionWidth: Integer;
|
|
APlaceCount: Integer;
|
|
ASelectionRect, AItemRect: TRect;
|
|
begin
|
|
ASelectionWidth := GetItemSelectionWidth;
|
|
APlaceCount := cxRectWidth(AItemsRect) div ASelectionWidth;
|
|
FVisibleItemCount := Min(APlaceCount, ItemCount);
|
|
|
|
AStartPos := AItemsRect.Right - FVisibleItemCount * ASelectionWidth;
|
|
|
|
ASelectionRect := cxRect(0, 0, ASelectionWidth, cxRectHeight(AItemsRect));
|
|
OffsetRect(ASelectionRect, AStartPos, AItemsRect.Top);
|
|
|
|
AItemRect := cxRect(0, 0, ASelectionWidth, GetImageHeight);
|
|
OffsetRect(AItemRect, AStartPos, AItemsRect.Top +
|
|
(cxRectHeight(AItemsRect) - GetImageHeight) div 2);
|
|
InflateRect(AItemRect, -GetImageWidthAddon, 0);
|
|
|
|
for I := 0 to FVisibleItemCount - 1 do
|
|
begin
|
|
Items[I].SelectionRect := ASelectionRect;
|
|
OffsetRect(Items[I].SelectionRect, ASelectionWidth * I, 0);
|
|
Items[I].Rect := AItemRect;
|
|
OffsetRect(Items[I].Rect, ASelectionWidth * I, 0);
|
|
end;
|
|
end;
|
|
|
|
var
|
|
AClientRect, AItemsRect: TRect;
|
|
begin
|
|
if not IsVisible then
|
|
Exit;
|
|
|
|
FRect := Bounds(X, Y, ViewInfo.ClientWidth - 2*X, GetHeight);
|
|
|
|
AClientRect := cxRectContent(FRect, GetClientOffset);
|
|
FSignRect := AClientRect;
|
|
FSignRect.Left := FSignRect.Right - GetSignWidth;
|
|
|
|
if ViewInfo.Painter.Controller.Collapsed then
|
|
AItemsRect := cxNullRect
|
|
else
|
|
begin
|
|
AItemsRect := AClientRect;
|
|
AItemsRect.Right := FSignRect.Left - GetSeparator;
|
|
end;
|
|
CalculateItemRects(AItemsRect);
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.IsVisible: Boolean;
|
|
begin
|
|
Result := NavBar.OptionsView.NavigationPane.ShowOverflowPanel;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetHeight: Integer;
|
|
|
|
function GetHeight: Integer;
|
|
begin
|
|
Result := GetImageHeight;
|
|
if ViewInfo.FImageHeightPeer then
|
|
Result := Max(ViewInfo.FMaxImageSize.cy, Result)
|
|
end;
|
|
|
|
begin
|
|
if not IsVisible then
|
|
Result := 0
|
|
else
|
|
Result := GetHeight + GetHeightAddon;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetImageHeight: Integer;
|
|
begin
|
|
if NavBar.NavigationPaneOverflowPanelUseSmallImages then
|
|
Result := ViewInfo.GetSmallImageHeight
|
|
else
|
|
Result := ViewInfo.GetLargeImageHeight;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetImageWidth: Integer;
|
|
begin
|
|
if NavBar.NavigationPaneOverflowPanelUseSmallImages then
|
|
Result := ViewInfo.GetSmallImageWidth
|
|
else
|
|
Result := ViewInfo.GetLargeImageWidth;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetImageList: TCustomImageList;
|
|
begin
|
|
if NavBar.NavigationPaneOverflowPanelUseSmallImages then
|
|
Result := NavBar.SmallImages
|
|
else
|
|
Result := NavBar.LargeImages;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetImageIndex(AGroup: TdxNavBarGroup): Integer;
|
|
begin
|
|
if NavBar.NavigationPaneOverflowPanelUseSmallImages then
|
|
Result := AGroup.SmallImageIndex
|
|
else
|
|
Result := AGroup.LargeImageIndex;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetItemIndexAtPos(const pt: TPoint): Integer;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := -1;
|
|
for I := 0 to FVisibleItemCount - 1 do
|
|
if PtInRect(Items[I].SelectionRect, pt) then
|
|
begin
|
|
Result := I;
|
|
Break;
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetItemSelectionWidth: Integer;
|
|
begin
|
|
Result := GetImageWidth + 2 * GetImageWidthAddon;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetGroupAtPos(const pt: TPoint): TdxNavBarGroup;
|
|
var
|
|
AIndex: Integer;
|
|
begin
|
|
AIndex := GetItemIndexAtPos(pt);
|
|
if AIndex >= 0 then
|
|
begin
|
|
Result := Items[AIndex].Group;
|
|
if (Result <> nil) and (csDestroying in Result.ComponentState) then
|
|
Result := nil;
|
|
end
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetHeightAddon: Integer;
|
|
begin
|
|
Result := 8;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetImageWidthAddon: Integer;
|
|
begin
|
|
Result := 3;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetPopupMenuImageIndent: Integer;
|
|
begin
|
|
Result := 3;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetPopupMenuTextIndent: Integer;
|
|
begin
|
|
Result := 4;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetSignWidth: Integer;
|
|
begin
|
|
Result := 18;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetSeparator: Integer;
|
|
begin
|
|
Result := 0;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetClientOffset: TRect;
|
|
begin
|
|
Result := cxNullRect;
|
|
Result := cxRectOffset(Result, 0, ViewInfo.BorderWidth);
|
|
end;
|
|
|
|
procedure TdxNavBarOverflowPanelViewInfo.ClearRects;
|
|
begin
|
|
SetRectEmpty(FRect);
|
|
SetRectEmpty(FSignRect);
|
|
end;
|
|
|
|
procedure TdxNavBarOverflowPanelViewInfo.ClearItems;
|
|
begin
|
|
FVisibleItemCount := 0;
|
|
FItems.Clear;
|
|
end;
|
|
|
|
procedure TdxNavBarOverflowPanelViewInfo.OffsetElements(AHeightDifference: Integer);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
if not IsVisible then
|
|
Exit;
|
|
OffsetRect(FRect, 0, AHeightDifference);
|
|
OffsetRect(FSignRect, 0, AHeightDifference);
|
|
for I := 0 to FVisibleItemCount - 1 do
|
|
begin
|
|
OffsetRect(Items[I].Rect, 0, AHeightDifference);
|
|
OffsetRect(Items[I].SelectionRect, 0, AHeightDifference);
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
begin
|
|
if FIAccessibilityHelper = nil then
|
|
FIAccessibilityHelper := NavBarGetAccessibilityHelper(
|
|
GetAccessibilityHelperClass.Create(Self, NavBar));
|
|
Result := FIAccessibilityHelper;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.AddItem: TdxNavBarOverflowPanelViewInfoItem;
|
|
begin
|
|
Result := TdxNavBarOverflowPanelViewInfoItem.Create;
|
|
FItems.Insert(0, Result);
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetItemCount: Integer;
|
|
begin
|
|
Result := FItems.Count;
|
|
end;
|
|
|
|
function TdxNavBarOverflowPanelViewInfo.GetItems(AIndex: Integer): TdxNavBarOverflowPanelViewInfoItem;
|
|
begin
|
|
Result := TdxNavBarOverflowPanelViewInfoItem(FItems[AIndex]);
|
|
end;
|
|
|
|
{ TdxNavBarItemPanelViewInfoItem }
|
|
|
|
procedure TdxNavBarItemPanelViewInfoItem.OffsetRects(dX, dY: Integer);
|
|
begin
|
|
Rect := cxRectOffset(Rect, dX, dY);
|
|
TextRect := cxRectOffset(TextRect, dX, dY);
|
|
ImageRect := cxRectOffset(ImageRect, dX, dY);
|
|
end;
|
|
|
|
function TdxNavBarItemPanelViewInfoItem.GetCaption: string;
|
|
begin
|
|
Result := ItemLink.Item.Caption;
|
|
end;
|
|
|
|
{ TdxNavBarItemPanelViewInfo }
|
|
|
|
constructor TdxNavBarItemPanelViewInfo.Create(AViewInfo: TdxNavBarViewInfo);
|
|
begin
|
|
inherited;
|
|
FItems := TObjectList.Create;
|
|
NavBar.IAccessibilityHelper.AttachChild(IAccessibilityHelper);
|
|
end;
|
|
|
|
destructor TdxNavBarItemPanelViewInfo.Destroy;
|
|
begin
|
|
if not (csDestroying in NavBar.ComponentState) then
|
|
NavBar.IAccessibilityHelper.DetachChild(IAccessibilityHelper);
|
|
NavBarAccessibleObjectOwnerObjectDestroyed(FIAccessibilityHelper);
|
|
FreeAndNil(FItems);
|
|
inherited;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelViewInfo.GetMinHeight: Integer;
|
|
begin
|
|
if FIsCollapseMode then
|
|
Result := cxTextWidth(CollapseBarFont, CollapseBarText) + GetCollapseBarCaptionIndent * 2
|
|
else
|
|
Result := ViewInfo.GetActiveGroupMinHeight;
|
|
end;
|
|
|
|
procedure TdxNavBarItemPanelViewInfo.CalculateBounds(var X, Y: Integer);
|
|
|
|
procedure CalculateItemRects(ARect: TRect);
|
|
var
|
|
I: Integer;
|
|
AItem: TdxNavBarItemPanelViewInfoItem;
|
|
ATextWidth, AIndent: Integer;
|
|
AImageSize: TSize;
|
|
begin
|
|
for I := 0 to ItemCount - 1 do
|
|
begin
|
|
AItem := Items[I];
|
|
AIndent := ViewInfo.GetGroupCaptionImageIndent;
|
|
ATextWidth := cxTextWidth(AItem.Font, AItem.Caption);
|
|
AItem.TextRect := cxRect(ARect.Left, ARect.Bottom, ARect.Right, ARect.Bottom + ATextWidth + AIndent * 2);
|
|
|
|
if IsImageAssigned(AItem.ImageList, AItem.ImageIndex) then
|
|
AImageSize := Size(ViewInfo.GetSmallImageWidth, ViewInfo.GetSmallImageHeight)
|
|
else
|
|
AImageSize := cxNullSize;
|
|
AItem.ImageRect := cxRectCenter(cxRect(ARect.Left, AItem.TextRect.Bottom, ARect.Right, AItem.TextRect.Bottom + AImageSize.cy), AImageSize);
|
|
|
|
AItem.Rect := cxRect(ARect.Left, AItem.TextRect.Top, ARect.Right, AItem.ImageRect.Bottom);
|
|
if IsImageAssigned(AItem.ImageList, AItem.ImageIndex) then
|
|
AItem.Rect.Bottom := AItem.Rect.Bottom + AIndent;
|
|
|
|
ARect.Bottom := AItem.Rect.Bottom;
|
|
end;
|
|
end;
|
|
|
|
begin
|
|
if (FActiveGroupViewInfo <> nil) and not FIsCollapseMode then
|
|
begin
|
|
FActiveGroupViewInfo.CalculateBounds(X, Y);
|
|
FRect := FActiveGroupViewInfo.Rect;
|
|
end
|
|
else
|
|
begin
|
|
FRect := Bounds(X, Y, ViewInfo.ClientWidth - 2*X, GetMinHeight);
|
|
Y := FRect.Bottom;
|
|
end;
|
|
if FIsCollapseMode then
|
|
begin
|
|
FCollapseBarRect := FRect;
|
|
CalculateItemRects(FCollapseBarRect);
|
|
end
|
|
else
|
|
FCollapseBarRect := cxNullRect;
|
|
end;
|
|
|
|
procedure TdxNavBarItemPanelViewInfo.CorrectBounds(AHeightDifference: Integer);
|
|
var
|
|
I, ALastVisibleIndex: Integer;
|
|
begin
|
|
FRect.Bottom := FRect.Bottom + AHeightDifference;
|
|
if (FActiveGroupViewInfo <> nil) and not FIsCollapseMode then
|
|
FActiveGroupViewInfo.CorrectActiveGroupBounds(0, AHeightDifference);
|
|
if FIsCollapseMode then
|
|
begin
|
|
ALastVisibleIndex := -1;
|
|
for I := 0 to ItemCount - 1 do
|
|
begin
|
|
if cxRectHeight(Items[I].Rect) <= AHeightDifference then
|
|
begin
|
|
AHeightDifference := AHeightDifference - cxRectHeight(Items[I].Rect);
|
|
ALastVisibleIndex := I;
|
|
end
|
|
else
|
|
Break;
|
|
end;
|
|
for I := ItemCount - 1 downto ALastVisibleIndex + 1 do
|
|
FItems.Delete(I);
|
|
FCollapseBarRect.Bottom := FCollapseBarRect.Bottom + AHeightDifference;
|
|
for I := 0 to ItemCount - 1 do
|
|
Items[I].OffsetRects(0, AHeightDifference);
|
|
(IAccessibilityHelper.GetHelper as TdxNavBarItemPanelAccessibilityHelper).CheckItemIAccessibilityHelperCount;
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelViewInfo.GetCollapseBarFont: TFont;
|
|
begin
|
|
Result := ViewInfo.HeaderFont;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelViewInfo.GetCollapseBarText: string;
|
|
begin
|
|
Result := cxGetResourceString(@sdxNavigationPaneCollapseBar);
|
|
end;
|
|
|
|
function TdxNavBarItemPanelViewInfo.GetItemFont(AIndex: Integer): TFont;
|
|
begin
|
|
Result := NavBar.DefaultStyles.Item.Font;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelViewInfo.GetItemIndexAtPos(const pt: TPoint): Integer;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := -1;
|
|
for I := 0 to ItemCount - 1 do
|
|
if PtInRect(Items[I].Rect, pt) then
|
|
begin
|
|
Result := I;
|
|
Break;
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelViewInfo.GetCollapseBarCaptionIndent: Integer;
|
|
begin
|
|
Result := GetRevisedValue(4);
|
|
end;
|
|
|
|
function TdxNavBarItemPanelViewInfo.GetAccessibilityHelperClass: TdxNavBarCustomAccessibilityHelperClass;
|
|
begin
|
|
Result := TdxNavBarItemPanelAccessibilityHelper;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelViewInfo.GetCollapseBarIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
begin
|
|
Result := (IAccessibilityHelper.GetHelper as TdxNavBarItemPanelAccessibilityHelper).CollapseBarIAccessibilityHelper;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelViewInfo.GetIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
begin
|
|
if FIAccessibilityHelper = nil then
|
|
FIAccessibilityHelper := NavBarGetAccessibilityHelper(
|
|
GetAccessibilityHelperClass.Create(Self, NavBar));
|
|
Result := FIAccessibilityHelper;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelViewInfo.GetItemCount: Integer;
|
|
begin
|
|
Result := FItems.Count;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelViewInfo.GetItemIAccessibilityHelper(
|
|
AIndex: Integer): IdxNavBarAccessibilityHelper;
|
|
begin
|
|
Result := (IAccessibilityHelper.GetHelper as TdxNavBarItemPanelAccessibilityHelper).ItemIAccessibilityHelpers[AIndex];
|
|
end;
|
|
|
|
function TdxNavBarItemPanelViewInfo.GetItems(AIndex: Integer): TdxNavBarItemPanelViewInfoItem;
|
|
begin
|
|
Result := TdxNavBarItemPanelViewInfoItem(FItems[AIndex]);
|
|
end;
|
|
|
|
procedure TdxNavBarItemPanelViewInfo.SetActiveGroupViewInfo(AValue: TdxNavBarGroupViewInfo);
|
|
begin
|
|
FActiveGroupViewInfo := AValue;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelViewInfo.AddItem: TdxNavBarItemPanelViewInfoItem;
|
|
begin
|
|
Result := TdxNavBarItemPanelViewInfoItem.Create;
|
|
Result.Index := FItems.Add(Result);
|
|
end;
|
|
|
|
procedure TdxNavBarItemPanelViewInfo.ClearItems;
|
|
begin
|
|
FItems.Clear;
|
|
end;
|
|
|
|
procedure TdxNavBarItemPanelViewInfo.CreateItems;
|
|
var
|
|
I: Integer;
|
|
APanelItem: TdxNavBarItemPanelViewInfoItem;
|
|
ALink: TdxNavBarItemLink;
|
|
begin
|
|
ClearItems;
|
|
if FIsCollapseMode and (FCollapseBarGroup <> nil) then
|
|
begin
|
|
for I := 0 to FCollapseBarGroup.LinkCount - 1 do
|
|
begin
|
|
ALink := FCollapseBarGroup.Links[I];
|
|
if ALink.CanSelect and ALink.Item.Visible then
|
|
begin
|
|
APanelItem := AddItem;
|
|
APanelItem.ItemLink := ALink;
|
|
APanelItem.Font := GetItemFont(I);
|
|
APanelItem.ImageList := NavBar.SmallImages;
|
|
APanelItem.ImageIndex := APanelItem.ItemLink.Item.SmallImageIndex;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TdxNavBarOffice11NavPanelViewInfo }
|
|
|
|
constructor TdxNavBarNavigationPaneViewInfo.Create(APainter: TdxNavBarPainter);
|
|
begin
|
|
inherited;
|
|
FOverflowPanelViewInfo := GetOverflowPanelViewInfoClass.Create(Self);
|
|
FItemPanelViewInfo := TdxNavBarItemPanelViewInfo.Create(Self);
|
|
FImageList := TImageList.Create(NavBar);
|
|
FPopupMenu := TPopupMenu.Create(NavBar);
|
|
APainter.NavBar.IAccessibilityHelper.AttachChild(
|
|
ActiveGroupCaptionPanelIAccessibilityHelper);
|
|
APainter.NavBar.IAccessibilityHelper.AttachChild(
|
|
HeaderSignIAccessibilityHelper);
|
|
APainter.NavBar.IAccessibilityHelper.AttachChild(
|
|
OverflowPanelIAccessibilityHelper);
|
|
end;
|
|
|
|
destructor TdxNavBarNavigationPaneViewInfo.Destroy;
|
|
begin
|
|
if not (csDestroying in NavBar.ComponentState) then
|
|
begin
|
|
NavBar.IAccessibilityHelper.DetachChild(ActiveGroupCaptionPanelIAccessibilityHelper);
|
|
NavBar.IAccessibilityHelper.DetachChild(HeaderSignIAccessibilityHelper);
|
|
NavBar.IAccessibilityHelper.DetachChild(OverflowPanelIAccessibilityHelper);
|
|
end;
|
|
NavBarAccessibleObjectOwnerObjectDestroyed(FActiveGroupCaptionPanelIAccessibilityHelper);
|
|
NavBarAccessibleObjectOwnerObjectDestroyed(FHeaderSignIAccessibilityHelper);
|
|
FPopupMenu.Free;
|
|
FImageList.Free;
|
|
FreeAndnil(FItemPanelViewInfo);
|
|
FreeAndnil(FOverflowPanelViewInfo);
|
|
inherited;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.FindGroupWithAccel(AKey: Word): TdxNavBarGroup;
|
|
var
|
|
AIndex: Integer;
|
|
AGroup: TdxNavBarGroup;
|
|
begin
|
|
Result := inherited FindGroupWithAccel(AKey);
|
|
if (Result = nil) and (FOverflowPanelViewInfo.IsVisible) and not Painter.Controller.Collapsed then
|
|
for AIndex := 0 to FOverflowPanelViewInfo.ItemCount - 1 do
|
|
begin
|
|
AGroup := FOverflowPanelViewInfo.Items[AIndex].Group;
|
|
if IsAccel(AKey, AGroup.Caption) then
|
|
begin
|
|
Result := AGroup;
|
|
Break;
|
|
end
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.FindLinkWithAccel(AKey: Word): TdxNavBarItemLink;
|
|
var
|
|
AIndex: Integer;
|
|
AItemPanelViewInfoItem: TdxNavBarItemPanelViewInfoItem;
|
|
begin
|
|
Result := inherited FindLinkWithAccel(AKey);
|
|
if Result = nil then
|
|
for AIndex := 0 to FItemPanelViewInfo.ItemCount - 1 do
|
|
begin
|
|
AItemPanelViewInfoItem := FItemPanelViewInfo.Items[AIndex];
|
|
if IsAccel(AKey, AItemPanelViewInfoItem.Caption) then
|
|
begin
|
|
Result := AItemPanelViewInfoItem.ItemLink;
|
|
Break;
|
|
end
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.BorderWidth: Integer;
|
|
begin
|
|
Result := 1;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.BorderColor: TColor;
|
|
begin
|
|
Result := dxOffice11NavPaneBorder;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.CollapseBarFontColor: TColor;
|
|
begin
|
|
Result := BorderColor;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.BottomScrollButtonBackColor: TColor;
|
|
begin
|
|
if not IsDefaultBottomScrollButtonColor then
|
|
Result := inherited BottomScrollButtonBackColor
|
|
else if sPressed in BottomScrollButtonState then
|
|
Result := dxOffice11NavPaneGroupCaptionPressedColor1
|
|
else if sActive in BottomScrollButtonState then
|
|
Result := dxOffice11NavPaneGroupCaptionPressedColor2
|
|
else if sHotTracked in BottomScrollButtonState then
|
|
Result := dxOffice11NavPaneGroupCaptionHotColor1
|
|
else Result := dxOffice11NavPaneGroupCaptionColor1;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.BottomScrollButtonBackColor2: TColor;
|
|
begin
|
|
if not IsDefaultBottomScrollButtonColor then
|
|
Result := inherited BottomScrollButtonBackColor2
|
|
else if sPressed in BottomScrollButtonState then
|
|
Result := dxOffice11NavPaneGroupCaptionPressedColor2
|
|
else if sActive in BottomScrollButtonState then
|
|
Result := dxOffice11NavPaneGroupCaptionPressedColor1
|
|
else if sHotTracked in BottomScrollButtonState then
|
|
Result := dxOffice11NavPaneGroupCaptionHotColor2
|
|
else Result := dxOffice11NavPaneGroupCaptionColor2;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.BottomScrollButtonAlphaBlend: Byte;
|
|
begin
|
|
if not IsDefaultBottomScrollButtonColor then
|
|
Result := inherited BottomScrollButtonAlphaBlend
|
|
else Result := 255;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.BottomScrollButtonAlphaBlend2: Byte;
|
|
begin
|
|
if not IsDefaultBottomScrollButtonColor then
|
|
Result := inherited BottomScrollButtonAlphaBlend2
|
|
else Result := 255;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.BottomScrollButtonGradientMode: TdxBarStyleGradientMode;
|
|
begin
|
|
if not IsDefaultBottomScrollButtonColor then
|
|
Result := inherited BottomScrollButtonGradientMode
|
|
else Result := gmVertical;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.TopScrollButtonBackColor: TColor;
|
|
begin
|
|
if not IsDefaultTopScrollButtonColor then
|
|
Result := inherited TopScrollButtonBackColor
|
|
else if sPressed in TopScrollButtonState then
|
|
Result := dxOffice11NavPaneGroupCaptionPressedColor1
|
|
else if sActive in TopScrollButtonState then
|
|
Result := dxOffice11NavPaneGroupCaptionPressedColor2
|
|
else if sHotTracked in TopScrollButtonState then
|
|
Result := dxOffice11NavPaneGroupCaptionHotColor1
|
|
else Result := dxOffice11NavPaneGroupCaptionColor1;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.TopScrollButtonBackColor2: TColor;
|
|
begin
|
|
if not IsDefaultTopScrollButtonColor then
|
|
Result := inherited TopScrollButtonBackColor2
|
|
else if sPressed in TopScrollButtonState then
|
|
Result := dxOffice11NavPaneGroupCaptionPressedColor2
|
|
else if sActive in TopScrollButtonState then
|
|
Result := dxOffice11NavPaneGroupCaptionPressedColor1
|
|
else if sHotTracked in TopScrollButtonState then
|
|
Result := dxOffice11NavPaneGroupCaptionHotColor2
|
|
else Result := dxOffice11NavPaneGroupCaptionColor2;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.TopScrollButtonAlphaBlend: Byte;
|
|
begin
|
|
if not IsDefaultTopScrollButtonColor then
|
|
Result := inherited TopScrollButtonAlphaBlend
|
|
else Result := 255;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.TopScrollButtonAlphaBlend2: Byte;
|
|
begin
|
|
if not IsDefaultTopScrollButtonColor then
|
|
Result := inherited TopScrollButtonAlphaBlend2
|
|
else Result := 255;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.TopScrollButtonGradientMode: TdxBarStyleGradientMode;
|
|
begin
|
|
if not IsDefaultTopScrollButtonColor then
|
|
Result := inherited TopScrollButtonGradientMode
|
|
else Result := gmVertical;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.HeaderBackColor: TColor;
|
|
begin
|
|
if not IsDefaultHeaderColor then
|
|
Result := inherited HeaderBackColor
|
|
else Result := dxOffice11NavPaneHeaderColor1;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.HeaderBackColor2: TColor;
|
|
begin
|
|
if not IsDefaultHeaderColor then
|
|
Result := inherited HeaderBackColor2
|
|
else Result := dxOffice11NavPaneHeaderColor2;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.HeaderAlphaBlend: Byte;
|
|
begin
|
|
if not IsDefaultHeaderColor then
|
|
Result := inherited HeaderAlphaBlend
|
|
else Result := 255;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.HeaderAlphaBlend2: Byte;
|
|
begin
|
|
if not IsDefaultHeaderColor then
|
|
Result := inherited HeaderAlphaBlend2
|
|
else Result := 255;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.HeaderGradientMode: TdxBarStyleGradientMode;
|
|
begin
|
|
if not IsDefaultHeaderColor then
|
|
Result := inherited HeaderGradientMode
|
|
else Result := gmVertical;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.HeaderFontColor: TColor;
|
|
begin
|
|
Result := inherited HeaderFontColor;
|
|
if Result = clNone then
|
|
Result := dxOffice11NavPaneHeaderFontColor;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.OverflowPanelBackColor: TColor;
|
|
begin
|
|
if not IsDefaultOverflowPanelColor then
|
|
Result := inherited OverflowPanelBackColor
|
|
else Result := dxOffice11NavPaneGroupCaptionColor1;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.OverflowPanelBackColor2: TColor;
|
|
begin
|
|
if not IsDefaultOverflowPanelColor then
|
|
Result := inherited OverflowPanelBackColor2
|
|
else Result := dxOffice11NavPaneGroupCaptionColor2;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.OverflowPanelAlphaBlend: Byte;
|
|
begin
|
|
if not IsDefaultOverflowPanelColor then
|
|
Result := inherited OverflowPanelAlphaBlend
|
|
else Result := 255;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.OverflowPanelAlphaBlend2: Byte;
|
|
begin
|
|
if not IsDefaultOverflowPanelColor then
|
|
Result := inherited OverflowPanelAlphaBlend2
|
|
else Result := 255;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.OverflowPanelGradientMode: TdxBarStyleGradientMode;
|
|
begin
|
|
if not IsDefaultOverflowPanelColor then
|
|
Result := inherited OverflowPanelGradientMode
|
|
else Result := gmVertical;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.SplitterBackColor: TColor;
|
|
begin
|
|
if XPScheme = schUnknown then
|
|
Result := dxOffice11NavPaneSplitterColor1
|
|
else
|
|
Result := inherited SplitterBackColor;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.SplitterBackColor2: TColor;
|
|
begin
|
|
if XPScheme = schUnknown then
|
|
Result := dxOffice11NavPaneSplitterColor2
|
|
else
|
|
Result := inherited SplitterBackColor2;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.SplitterGradientMode: TdxBarStyleGradientMode;
|
|
begin
|
|
if XPScheme = schUnknown then
|
|
Result := gmVertical
|
|
else
|
|
Result := inherited SplitterGradientMode;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.AssignDefaultBackgroundStyle;
|
|
begin
|
|
NavBar.DefaultStyles.Background.ResetValues;
|
|
NavBar.DefaultStyles.Background.BackColor := clWindow;
|
|
NavBar.DefaultStyles.Background.BackColor2 := clWindow;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.AssignDefaultButtonStyle;
|
|
begin
|
|
NavBar.DefaultStyles.Button.ResetValues;
|
|
NavBar.DefaultStyles.Button.BackColor := clNone;
|
|
NavBar.DefaultStyles.Button.BackColor2 := clNone;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.AssignDefaultGroupBackgroundStyle;
|
|
begin
|
|
NavBar.DefaultStyles.GroupBackground.ResetValues;
|
|
NavBar.DefaultStyles.GroupBackground.BackColor := clWindow;
|
|
NavBar.DefaultStyles.GroupBackground.BackColor2 := clWindow;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.AssignDefaultGroupHeaderStyle;
|
|
begin
|
|
NavBar.DefaultStyles.GroupHeader.ResetValues;
|
|
NavBar.DefaultStyles.GroupHeader.BackColor := clNone;
|
|
NavBar.DefaultStyles.GroupHeader.BackColor2 := clNone;
|
|
NavBar.DefaultStyles.GroupHeader.Font.Style := [fsBold];
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.AssignDefaultItemStyle;
|
|
begin
|
|
NavBar.DefaultStyles.Item.ResetValues;
|
|
NavBar.DefaultStyles.Item.Font.Color := clWindowText;
|
|
NavBar.DefaultStyles.Item.HAlignment := haCenter;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.AssignDefaultItemDisabledStyle;
|
|
begin
|
|
NavBar.DefaultStyles.ItemDisabled.Assign(NavBar.DefaultStyles.Item);
|
|
NavBar.DefaultStyles.ItemDisabled.Font.Color := clGrayText;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.AssignDefaultNavigationPaneHeaderStyle;
|
|
begin
|
|
NavBar.DefaultStyles.NavigationPaneHeader.ResetValues;
|
|
NavBar.DefaultStyles.NavigationPaneHeader.BackColor := clNone;
|
|
NavBar.DefaultStyles.NavigationPaneHeader.BackColor2 := clNone;
|
|
NavBar.DefaultStyles.NavigationPaneHeader.Font.Color := clNone;
|
|
NavBar.DefaultStyles.NavigationPaneHeader.Font.Name := 'Arial';
|
|
NavBar.DefaultStyles.NavigationPaneHeader.Font.Size := 11;
|
|
NavBar.DefaultStyles.NavigationPaneHeader.Font.Style := [fsBold];
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.CreateColors;
|
|
begin
|
|
CreateOffice11NavPaneColors;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.RefreshColors;
|
|
begin
|
|
RefreshOffice11NavPaneColors;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.ReleaseColors;
|
|
begin
|
|
ReleaseOffice11NavPaneColors;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetGroupEdges: TPoint;
|
|
begin
|
|
Result := cxPoint(1, 0);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetGroupSeparatorWidth: Integer;
|
|
begin
|
|
Result := 0;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetGroupBorderOffsets: TRect;
|
|
begin
|
|
Result := inherited GetGroupBorderOffsets;
|
|
if IsTopBorderNeeded then
|
|
Result.Top := Result.Top + BorderWidth;
|
|
if IsBottomBorderNeeded then
|
|
Result.Bottom := Result.Bottom + BorderWidth;
|
|
end;
|
|
|
|
class function TdxNavBarNavigationPaneViewInfo.GetGroupCaptionImageIndent: Integer;
|
|
begin
|
|
Result := 4;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetGroupCaptionHeightAddon: Integer;
|
|
begin
|
|
Result := 4;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetGroupHeaderTextIndent: Integer;
|
|
begin
|
|
Result := GetGroupCaptionTextIndent;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetHeaderClientOffset: TRect;
|
|
begin
|
|
Result := cxNullRect;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetHeaderSignIndents: TRect;
|
|
begin
|
|
Result := Rect(GetGroupCaptionImageIndent, 0, GetGroupCaptionImageIndent, 0);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetNavBarCollapsedWidth: Integer;
|
|
var
|
|
AMaxElementSize: Integer;
|
|
begin
|
|
with FOverflowPanelViewInfo do
|
|
AMaxElementSize := Max((GetGroupCaptionImageIndent) * 2 + FMaxImageSize.cx,
|
|
GetSignWidth + GetClientOffset.Left + GetClientOffset.Right);
|
|
AMaxElementSize := Max(AMaxElementSize,
|
|
cxRectWidth(HeaderSignRect) + GetHeaderClientOffset.Left + GetHeaderClientOffset.Right);
|
|
Result := AMaxElementSize + GetGroupEdges.X * 2;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetNavBarMinExpandedWidth: Integer;
|
|
begin
|
|
Result := GetNavBarCollapsedWidth * 2;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetHeaderHeight: Integer;
|
|
begin
|
|
if not IsHeaderVisible then
|
|
Result := 0
|
|
else
|
|
begin
|
|
Result := GetHeaderHeightAddon;
|
|
Inc(Result, Max(cxScreenCanvas.FontHeight(HeaderFont), GetGroupCaptionSignSize.cy));
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetGripSize: Integer;
|
|
begin
|
|
if TdxCustomNavBarAccess(NavBar).IsInternal then
|
|
Result := 15
|
|
else
|
|
Result := 0;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetSplitterHeight: Integer;
|
|
begin
|
|
if not IsSplitterVisible then
|
|
Result := 0
|
|
else
|
|
Result := 7;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.CanCollapse: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.CanHasGroupViewAsIconView: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.CanHasImageInGroupCaption: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.CanGroupCaptionBoundsByImage: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsBottomBorderNeeded: Boolean;
|
|
begin
|
|
Result := not IsGroupReflectionNeeded;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsHeaderVisible: Boolean;
|
|
begin
|
|
Result := NavBar.OptionsView.NavigationPane.ShowHeader;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsSplitterVisible: Boolean;
|
|
begin
|
|
Result := FOverflowPanelViewInfo.IsVisible;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsTopBorderNeeded: Boolean;
|
|
begin
|
|
Result := not IsHeaderVisible;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.DoCreateGroupsInfo;
|
|
|
|
procedure CheckFocusedAccessibleObject;
|
|
var
|
|
AFocusedAccessibleObject: IdxNavBarAccessibilityHelper;
|
|
begin
|
|
AFocusedAccessibleObject := TdxCustomNavBarAccess(NavBar).FocusedAccessibleObject;
|
|
if (AFocusedAccessibleObject <> nil) and (NavBar.ActiveGroup <> nil) and
|
|
(AFocusedAccessibleObject.GetHelper = NavBar.ActiveGroup.CaptionPanelIAccessibilityHelper.GetHelper) then
|
|
TdxCustomNavBarAccess(NavBar).FocusedAccessibleObject := ActiveGroupCaptionPanelIAccessibilityHelper;
|
|
end;
|
|
|
|
var
|
|
I: Integer;
|
|
begin
|
|
if IsActiveGroupVisible then
|
|
AddGroup(Self, NavBar.ActiveGroup, False, True);
|
|
|
|
if IsGroupReflectionNeeded then
|
|
for I := 0 to NavBar.Groups.Count - 1 do
|
|
if NavBar.Groups[I].Visible then
|
|
AddGroup(Self, NavBar.Groups[I], True, False);
|
|
CheckFocusedAccessibleObject;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.DoCalculateBounds(X, Y: Integer);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
CalculateMaxImageSize;
|
|
CalculateHeaderBounds(X, Y);
|
|
FItemPanelViewInfo.CalculateBounds(X, Y);
|
|
CalculateSplitterBounds(X, Y);
|
|
for I := GetRealGroupStartIndex to GroupCount - 1 do
|
|
Groups[I].CalculateBounds(X, Y);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetItemPanelRect: TRect;
|
|
begin
|
|
Result := FItemPanelViewInfo.FRect;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetBoundsUpdateType: TdxNavBarChangeType;
|
|
begin
|
|
Result := doRecreate;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetActiveGroupCaptionPanelAccessibilityHelperClass: TdxNavBarCustomAccessibilityHelperClass;
|
|
begin
|
|
Result := TdxNavBarNavigationPaneActiveGroupCaptionPanelAccessibilityHelper;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetHeaderSignAccessibilityHelperClass: TdxNavBarCustomAccessibilityHelperClass;
|
|
begin
|
|
Result := TdxNavBarNavigationPaneHeaderSignAccessibilityHelper;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetOverflowPanelViewInfoClass: TdxNavBarOverflowPanelViewInfoClass;
|
|
begin
|
|
Result := TdxNavBarOverflowPanelViewInfo;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.CreateInfo;
|
|
var
|
|
AOverflowPanelItemCount: Integer;
|
|
begin
|
|
inherited;
|
|
if NavBar.ShowGroupCaptions then
|
|
AOverflowPanelItemCount := NavBar.NavigationPaneOverflowPanelItemCount
|
|
else AOverflowPanelItemCount := 0;
|
|
CreateOverflowPanelInfo(AOverflowPanelItemCount, True);
|
|
CreateItemPanelViewInfo;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.CreateItemPanelViewInfo;
|
|
begin
|
|
FItemPanelViewInfo.ActiveGroupViewInfo := ActiveGroupViewInfo;
|
|
FItemPanelViewInfo.FIsCollapseMode := Painter.Controller.Collapsed;
|
|
FItemPanelViewInfo.FCollapseBarGroup := NavBar.ActiveGroup;
|
|
FItemPanelViewInfo.CreateItems;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.CreateOverflowPanelInfo(AItemCount: Integer; AClearOld: Boolean);
|
|
var
|
|
I: Integer;
|
|
AItem: TdxNavBarOverflowPanelViewInfoItem;
|
|
begin
|
|
if AClearOld then
|
|
FOverflowPanelViewInfo.ClearItems;
|
|
if not FOverflowPanelViewInfo.IsVisible then Exit;
|
|
for I := GroupCount - 1 downto GetRealGroupStartIndex do
|
|
begin
|
|
if OverflowPanelItemCount >= AItemCount then
|
|
Break;
|
|
AItem := FOverflowPanelViewInfo.AddItem;
|
|
AItem.Group := Groups[I].Group;
|
|
RemoveGroup(Groups[I]);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.CalculateSizeGripBounds;
|
|
begin
|
|
FSizeGripRect.Right := ClientWidth;
|
|
FSizeGripRect.Left := FSizeGripRect.Right - GetGripSize;
|
|
FSizeGripRect.Bottom := ClientHeight;
|
|
FSizeGripRect.Top := FSizeGripRect.Bottom - GetGripSize;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.CalculateHeaderBounds(var X, Y: Integer);
|
|
begin
|
|
if IsHeaderVisible then
|
|
begin
|
|
FHeaderRect := Bounds(X, Y, ClientWidth - 2*X , GetHeaderHeight);
|
|
FHeaderTextRect := cxRectContent(FHeaderRect, GetHeaderClientOffset);
|
|
|
|
if Painter.Controller.Collapsible then
|
|
begin
|
|
FHeaderSignRect := FHeaderTextRect;
|
|
Dec(FHeaderSignRect.Right, GetHeaderSignIndents.Right);
|
|
FHeaderSignRect.Left := FHeaderSignRect.Right - GetGroupCaptionSignSize.cx;
|
|
FHeaderTextRect.Right := FHeaderSignRect.Left - GetHeaderSignIndents.Left;
|
|
FHeaderSignRect := cxRectCenter(FHeaderSignRect, GetGroupCaptionSignSize);
|
|
end
|
|
else
|
|
FHeaderSignRect := cxNullRect;
|
|
Y := FHeaderRect.Bottom + GetSpaceBetweenGroups;
|
|
end
|
|
else
|
|
begin
|
|
SetRectEmpty(FHeaderTextRect);
|
|
SetRectEmpty(FHeaderSignRect);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.CalculateMaxImageSize;
|
|
|
|
function GetGroupViewInfo(AList: TList; AIndex: Integer): TdxNavBarGroupViewInfo;
|
|
begin
|
|
Result := TdxNavBarGroupViewInfo(AList[AIndex]);
|
|
end;
|
|
|
|
var
|
|
I: Integer;
|
|
AList: TObjectList;
|
|
begin
|
|
AList := TObjectList.Create;
|
|
try
|
|
FMaxImageSize := Size(FOverflowPanelViewInfo.GetImageWidth, FOverflowPanelViewInfo.GetImageHeight);
|
|
|
|
for I := 0 to NavBar.Groups.Count - 1 do
|
|
AList.Add(Painter.CreateGroupViewInfo(Self, NavBar.Groups[I], True, False));
|
|
|
|
FImageHeightPeer := AList.Count > 0;
|
|
for I := 0 to AList.Count - 1 do
|
|
begin
|
|
FImageHeightPeer := FImageHeightPeer and (GetGroupViewInfo(AList, 0).GetImageHeight = GetGroupViewInfo(AList, I).GetImageHeight);
|
|
FMaxImageSize.cx := Max(FMaxImageSize.cx, GetGroupViewInfo(AList, I).GetImageWidth);
|
|
FMaxImageSize.cy := Max(FMaxImageSize.cy, GetGroupViewInfo(AList, I).GetImageHeight);
|
|
end;
|
|
finally
|
|
AList.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.CalculateSplitterBounds(var X, Y: Integer);
|
|
begin
|
|
if not IsSplitterVisible then
|
|
Exit;
|
|
|
|
FSplitterRect := Bounds(X, Y, ClientWidth - 2*X, GetSplitterHeight);
|
|
Y := FSplitterRect.Bottom + GetSpaceBetweenGroups;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.ClearRects;
|
|
begin
|
|
inherited;
|
|
FOverflowPanelViewInfo.ClearRects;
|
|
SetRectEmpty(FHeaderRect);
|
|
SetRectEmpty(FSizeGripRect);
|
|
SetRectEmpty(FSplitterRect);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.CorrectBounds;
|
|
|
|
procedure CalcHeightDifference(out AShortage, AHeightDifference: Integer);
|
|
var
|
|
AAvailableHeight, ARequiredHeight, AMinHeight: Integer;
|
|
begin
|
|
AAvailableHeight := ClientHeight - FOverflowPanelViewInfo.GetHeight;
|
|
if GetRealGroupCount = 0 then
|
|
Dec(AAvailableHeight, GetSplitterHeight);
|
|
AMinHeight := FItemPanelViewInfo.GetMinHeight;
|
|
if GroupCount > 0 then
|
|
ARequiredHeight := Groups[GroupCount - 1].Rect.Bottom
|
|
else
|
|
ARequiredHeight := HeaderRect.Bottom + AMinHeight;
|
|
AHeightDifference := AAvailableHeight - ARequiredHeight;
|
|
if AHeightDifference < AMinHeight - cxRectHeight(FItemPanelViewInfo.FRect) then // if AHeightDifference < 0
|
|
begin
|
|
AShortage := AMinHeight - cxRectHeight(FItemPanelViewInfo.FRect) - AHeightDifference;
|
|
AHeightDifference := AMinHeight - cxRectHeight(FItemPanelViewInfo.FRect);
|
|
end
|
|
else
|
|
AShortage := 0;
|
|
end;
|
|
|
|
procedure CorrectOverflowPanel(AShortage: Integer; var AHeightDifference: Integer);
|
|
|
|
procedure CorrectOverflowPanelBounds;
|
|
var
|
|
X, Y: Integer;
|
|
begin
|
|
X := SplitterRect.Left;
|
|
if (GetRealGroupCount = 0) or not NavBar.ShowGroupCaptions then
|
|
Y := SplitterRect.Bottom
|
|
else
|
|
Y := Groups[GroupCount - 1].Rect.Bottom;
|
|
FOverflowPanelViewInfo.CalculateBounds(X, Y);
|
|
end;
|
|
|
|
procedure RemoveExcessGroups(var AOverflowPanelGroupCount: Integer);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := GroupCount - 1 downto GetRealGroupStartIndex do
|
|
begin
|
|
if AShortage <= 0 then
|
|
Break;
|
|
Dec(AShortage, cxRectHeight(Groups[I].Rect));
|
|
Inc(AOverflowPanelGroupCount);
|
|
end;
|
|
Inc(AHeightDifference, -AShortage);
|
|
end;
|
|
|
|
var
|
|
AGroupCount: Integer;
|
|
begin
|
|
if not FOverflowPanelViewInfo.IsVisible then
|
|
Exit;
|
|
AGroupCount := NavBar.NavigationPaneOverflowPanelItemCount;
|
|
if not NavBar.ShowGroupCaptions then
|
|
AGroupCount := GroupCount - 1
|
|
else
|
|
if AShortage > 0 then
|
|
RemoveExcessGroups(AGroupCount);
|
|
|
|
CreateOverflowPanelInfo(AGroupCount, False);
|
|
CorrectOverflowPanelBounds;
|
|
end;
|
|
|
|
procedure OffsetElements(AHeightDifference: Integer);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
|
|
for I := GetRealGroupStartIndex to GroupCount - 1 do
|
|
Groups[I].CorrectBounds(0, AHeightDifference);
|
|
|
|
OffsetRect(FSplitterRect, 0, AHeightDifference);
|
|
FOverflowPanelViewInfo.OffsetElements(AHeightDifference);
|
|
end;
|
|
|
|
procedure CorrectBoundsWithActiveGroup;
|
|
var
|
|
AHeightDifference, AShortage: Integer;
|
|
begin
|
|
CalcHeightDifference(AShortage, AHeightDifference);
|
|
CorrectOverflowPanel(AShortage, AHeightDifference);
|
|
FItemPanelViewInfo.CorrectBounds(AHeightDifference);
|
|
OffsetElements(AHeightDifference);
|
|
end;
|
|
|
|
begin
|
|
CorrectBoundsWithActiveGroup;
|
|
CalculateScrollButtonsBounds;
|
|
CalculateSizeGripBounds;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetGroupViewInfoAtItemsPos(const pt: TPoint): TdxNavBarGroupViewInfo;
|
|
begin
|
|
Result := inherited GetGroupViewInfoAtItemsPos(pt);
|
|
if (Result = ActiveGroupViewInfo) and (NavBar.SourceGroup <> nil) then
|
|
Result := nil;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetViewInfoAtDragPosition(const pt: TPoint;
|
|
var ItemGroup: TdxNavBarGroupViewInfo; var Item1, Item2: TdxNavBarLinkViewInfo): Integer;
|
|
begin
|
|
Result := inherited GetViewInfoAtDragPosition(pt, ItemGroup, Item1, Item2);
|
|
if (ItemGroup <> nil) and (GroupCount > 0) and (ItemGroup <> Groups[0]) and
|
|
(NavBar.ActiveGroup = ItemGroup.Group) then
|
|
begin
|
|
ItemGroup := Groups[0];
|
|
Item1 := nil;
|
|
if ItemGroup.ItemCount > 0 then
|
|
Item2 := ItemGroup.Items[0]
|
|
else Item2 := nil;
|
|
Result := 0;
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsPtIncNavigationPaneOverflowPanelItemCount(const pt: TPoint): Boolean;
|
|
begin
|
|
if GetRealGroupCount > 0 then
|
|
Result := pt.Y > SplitterRect.Top + cxRectHeight(SplitterRect) div 2 + cxRectHeight(Groups[GetRealGroupStartIndex].Rect)
|
|
else
|
|
Result := pt.Y > SplitterRect.Top + cxRectHeight(SplitterRect) div 2 + 20;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsPtDecNavigationPaneOverflowPanelItemCount(const pt: TPoint): Boolean;
|
|
begin
|
|
if GetRealGroupCount > 0 then
|
|
Result := pt.Y < SplitterRect.Top + cxRectHeight(SplitterRect) div 2 - cxRectHeight(Groups[GetRealGroupStartIndex].Rect)
|
|
else
|
|
Result := pt.Y < SplitterRect.Top + cxRectHeight(SplitterRect) div 2 - 20;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsPtNavigationPaneHeader(const pt: TPoint): Boolean;
|
|
begin
|
|
Result := PtInRect(FHeaderRect, pt);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsPtNavigationPaneHeaderSign(const pt: TPoint): Boolean;
|
|
begin
|
|
Result := PtInRect(FHeaderSignRect, pt);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsPtNavigationPaneOverflowPanel(const pt: TPoint): Boolean;
|
|
begin
|
|
Result := PtInRect(OverflowPanelRect, pt);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsPtNavigationPaneOverflowPanelSign(const pt: TPoint): Boolean;
|
|
begin
|
|
Result := PtInRect(OverflowPanelSignRect, pt);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsPtNavigationPaneSplitter(const pt: TPoint): Boolean;
|
|
begin
|
|
Result := PtInRect(FSplitterRect, pt);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsPtNavigationPaneItemPanel(const pt: TPoint): Boolean;
|
|
begin
|
|
Result := PtInRect(FItemPanelViewInfo.FRect, pt);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.DoShowPopupMenu(const APoint: TPoint);
|
|
begin
|
|
DoUpdatePopupMenu;
|
|
PopupMenu.Popup(APoint.X, APoint.Y);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.DoUpdatePopupMenu;
|
|
|
|
function AddItem(AParentItem: TMenuItem; ACaption: string;
|
|
AEnabled: Boolean = True; AOnClick: TNotifyEvent = nil;
|
|
AImageIndex: Integer = -1; AChecked: Boolean = False): TMenuItem;
|
|
begin
|
|
Result := TMenuItem.Create(PopupMenu);
|
|
Result.Caption := ACaption;
|
|
Result.OnDrawItem := DoDrawItem;
|
|
if ACaption <> '-' then
|
|
begin
|
|
Result.OnMeasureItem := DoMeasureItem;
|
|
Result.OnClick := AOnClick;
|
|
Result.Checked := AChecked;
|
|
Result.Enabled := AEnabled;
|
|
Result.ImageIndex := AImageIndex;
|
|
end;
|
|
AParentItem.Add(Result);
|
|
end;
|
|
|
|
procedure AssignImage(AImageList: TImageList; ASourceBitmap: TBitmap);
|
|
var
|
|
ABitmap: TBitmap;
|
|
ASideSize: Integer;
|
|
AStretchRect: TRect;
|
|
AMaskColor: TColor;
|
|
begin
|
|
if AImageList.BkColor = clNone then
|
|
AMaskColor := clFuchsia
|
|
else
|
|
AMaskColor := AImageList.BkColor;
|
|
ABitmap := cxCreateBitmap(AImageList.Width, AImageList.Height);
|
|
try
|
|
ASideSize := Min(ABitmap.Width, ABitmap.Height);
|
|
AStretchRect.Left := (ABitmap.Width - ASideSize) div 2;
|
|
AStretchRect.Right := AStretchRect.Left + ASideSize;
|
|
AStretchRect.Top := (ABitmap.Height - ASideSize) div 2;
|
|
AStretchRect.Bottom := AStretchRect.Top + ASideSize;
|
|
ABitmap.Canvas.Brush.Color := AMaskColor;
|
|
ABitmap.Canvas.FillRect(Rect(0, 0, ABitmap.Width, ABitmap.Height));
|
|
ABitmap.Canvas.StretchDraw(AStretchRect, ASourceBitmap);
|
|
AImageList.AddMasked(ABitmap, AMaskColor);
|
|
finally
|
|
ABitmap.Free;
|
|
end;
|
|
end;
|
|
|
|
function GetImageIndex(AGroup: TdxNavBarGroup; ADefaultImageIndex: Integer): Integer;
|
|
begin
|
|
if IsImageAssigned(NavBar.SmallImages, AGroup.SmallImageIndex) then
|
|
Result := AGroup.SmallImageIndex
|
|
else
|
|
Result := ADefaultImageIndex;
|
|
end;
|
|
|
|
procedure CreateGroupList(AParentMenuItem: TMenuItem; ADefaultImageIndex: Integer);
|
|
var
|
|
I: Integer;
|
|
AItem: TMenuItem;
|
|
begin
|
|
for I := 0 to NavBar.Groups.Count - 1 do
|
|
begin
|
|
if NavBar.Groups[I].VisibleForCustomization then
|
|
begin
|
|
AItem := AddItem(AParentMenuItem, NavBar.Groups[I].Caption, True, DoAddRemoveButtonsClick,
|
|
GetImageIndex(NavBar.Groups[I], ADefaultImageIndex), NavBar.Groups[I].Visible);
|
|
{$IFDEF DELPHI6}
|
|
AItem.AutoCheck := True;
|
|
{$ENDIF};
|
|
AItem.Tag := I;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure CreateHiddenGroupList(AParentMenuItem: TMenuItem; ADefaultImageIndex: Integer);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
AddItem(AParentMenuItem, '-');
|
|
for I := OverflowPanelVisibleItemCount to OverflowPanelItemCount - 1 do
|
|
AddItem(AParentMenuItem, OverflowPanelItems[I].Group.Caption, True, DoHiddenGroupClick,
|
|
GetImageIndex(OverflowPanelItems[I].Group, ADefaultImageIndex),
|
|
NavBar.ActiveGroup = OverflowPanelItems[I].Group).Tag := Integer(OverflowPanelItems[I].Group);
|
|
end;
|
|
|
|
var
|
|
AImageCount: Integer;
|
|
AParentMenuItem: TMenuItem;
|
|
begin
|
|
RecreateImageList;
|
|
|
|
if NavBar.SmallImages <> nil then
|
|
begin
|
|
ImageList.Width := NavBar.SmallImages.Width;
|
|
ImageList.Height := NavBar.SmallImages.Height;
|
|
end;
|
|
|
|
AImageCount := GetSmallImagesCount;
|
|
AssignImage(ImageList, dxOffice11NavPaneArrowUpBitmap);
|
|
AssignImage(ImageList, dxOffice11NavPaneArrowDownBitmap);
|
|
AssignImage(ImageList, dxOffice11NavPaneDefaultSmallBitmap);
|
|
|
|
PopupMenu.Items.Clear;
|
|
PopupMenu.Images := ImageList;
|
|
|
|
AddItem(PopupMenu.Items, cxGetResourceString(@sdxNavBarOffice11ShowMoreButtons),
|
|
NavBar.CanDecNavigationPaneOverflowPanelItemCount, DoMoreButtonsClick, AImageCount);
|
|
AddItem(PopupMenu.Items, cxGetResourceString(@sdxNavBarOffice11ShowFewerButtons),
|
|
NavBar.CanIncNavigationPaneOverflowPanelItemCount, DoFewerButtonsClick, AImageCount + 1);
|
|
if NavBar.OptionsBehavior.NavigationPane.AllowCustomizing then
|
|
begin
|
|
AParentMenuItem := AddItem(PopupMenu.Items,
|
|
cxGetResourceString(@sdxNavBarOffice11AddRemoveButtons), NavBar.Groups.Count > 0);
|
|
CreateGroupList(AParentMenuItem, AImageCount + 2);
|
|
end;
|
|
CreateHiddenGroupList(PopupMenu.Items, AImageCount + 2);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsDefaultHeaderColor: Boolean;
|
|
begin
|
|
Result := (inherited HeaderBackColor = clNone) or (inherited HeaderBackColor2 = clNone);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsDefaultOverflowPanelColor: Boolean;
|
|
begin
|
|
Result := (inherited OverflowPanelBackColor = clNone) or (inherited OverflowPanelBackColor2 = clNone);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsDefaultBottomScrollButtonColor: Boolean;
|
|
begin
|
|
Result := (inherited BottomScrollButtonBackColor = clNone) or (inherited BottomScrollButtonBackColor2 = clNone);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsDefaultTopScrollButtonColor: Boolean;
|
|
begin
|
|
Result := (inherited TopScrollButtonBackColor = clNone) or (inherited TopScrollButtonBackColor2 = clNone);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.RecreateImageList;
|
|
begin
|
|
FImageList.Free;
|
|
FImageList := TImageList.Create(NavBar);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetPainter: TdxNavBarNavigationPanePainter;
|
|
begin
|
|
Result := TdxNavBarNavigationPanePainter(inherited Painter);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetActiveGroupCaptionPanelIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
begin
|
|
if FActiveGroupCaptionPanelIAccessibilityHelper = nil then
|
|
FActiveGroupCaptionPanelIAccessibilityHelper := NavBarGetAccessibilityHelper(
|
|
GetActiveGroupCaptionPanelAccessibilityHelperClass.Create(Self, NavBar));
|
|
Result := FActiveGroupCaptionPanelIAccessibilityHelper;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetHeaderSignIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
begin
|
|
if FHeaderSignIAccessibilityHelper = nil then
|
|
FHeaderSignIAccessibilityHelper := NavBarGetAccessibilityHelper(
|
|
GetHeaderSignAccessibilityHelperClass.Create(Self, NavBar));
|
|
Result := FHeaderSignIAccessibilityHelper;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetNavPanePartIAccessibilityHelper(
|
|
const APart: TdxNavBarPart): IdxNavBarAccessibilityHelper;
|
|
begin
|
|
case APart.MajorPartIndex of
|
|
nbOverflowPanelItem: Result := GetOverflowPanelItemIAccessibilityHelper(APart.MinorPartIndex);
|
|
nbOverflowPanelSign: Result := OverflowPanelSignIAccessibilityHelper;
|
|
nbHeaderSign: Result := HeaderSignIAccessibilityHelper;
|
|
|
|
nbItemPanelCollapseItem: Result := FItemPanelViewInfo.ItemIAccessibilityHelpers[APart.MinorPartIndex];
|
|
nbItemPanelCollapseBar: Result := FItemPanelViewInfo.CollapseBarIAccessibilityHelper;
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetOverflowPanelIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
begin
|
|
Result := FOverflowPanelViewInfo.GetIAccessibilityHelper;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.DoMoreButtonsClick(Sender: TObject);
|
|
begin
|
|
NavBar.DoDecNavigationPaneOverflowPanelItemCount;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.DoFewerButtonsClick(Sender: TObject);
|
|
begin
|
|
NavBar.DoIncNavigationPaneOverflowPanelItemCount;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.DoAddRemoveButtonsClick(Sender: TObject);
|
|
var
|
|
AMenuItem: TMenuItem;
|
|
AGroup: TdxNavBarGroup;
|
|
begin
|
|
AMenuItem := Sender as TMenuItem;
|
|
{$IFNDEF DELPHI6}
|
|
AMenuItem.Checked := not AMenuItem.Checked;
|
|
{$ENDIF}
|
|
AGroup := NavBar.Groups[AMenuItem.Tag];
|
|
AGroup.Visible := AMenuItem.Checked;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.DoHiddenGroupClick(Sender: TObject);
|
|
begin
|
|
NavBar.ActiveGroup := TdxNavBarGroup(TMenuItem(Sender).Tag);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.DoDrawItem(Sender: TObject;
|
|
ACanvas: TCanvas; ARect: TRect; Selected: Boolean);
|
|
var
|
|
AMenuItem: TMenuItem;
|
|
AState: TdxNavBarObjectStates;
|
|
AImageList: TCustomImageList;
|
|
AImageIndex: Integer;
|
|
begin
|
|
AMenuItem := Sender as TMenuItem;
|
|
AState := [];
|
|
if Selected then
|
|
Include(AState, sSelected);
|
|
if AMenuItem.Checked then
|
|
Include(AState, sActive);
|
|
if not AMenuItem.Enabled then
|
|
Include(AState, sDisabled);
|
|
|
|
AImageIndex := AMenuItem.ImageIndex;
|
|
if IsImageAssigned(NavBar.SmallImages, AImageIndex) then
|
|
AImageList := NavBar.SmallImages
|
|
else
|
|
begin
|
|
AImageList := ImageList;
|
|
Dec(AImageIndex, GetSmallImagesCount);
|
|
end;
|
|
(Painter as TdxNavBarNavigationPanePainter).DrawPopupMenuItem(ACanvas, ARect,
|
|
AImageList, AImageIndex, AMenuItem.Caption, AState);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneViewInfo.DoMeasureItem(Sender: TObject; ACanvas: TCanvas; var Width, Height: Integer);
|
|
begin
|
|
Height := 2 * FOverflowPanelViewInfo.GetPopupMenuImageIndent + GetSmallImageHeight;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetOverflowPanelItemCount: Integer;
|
|
begin
|
|
Result := FOverflowPanelViewInfo.ItemCount;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetOverflowPanelItems(AIndex: Integer): TdxNavBarOverflowPanelViewInfoItem;
|
|
begin
|
|
Result := FOverflowPanelViewInfo.Items[AIndex];
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetOverflowPanelVisibleItemCount: Integer;
|
|
begin
|
|
Result := FOverflowPanelViewInfo.FVisibleItemCount;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetOverflowPanelRect: TRect;
|
|
begin
|
|
Result := FOverflowPanelViewInfo.FRect;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetOverflowPanelSignRect: TRect;
|
|
begin
|
|
Result := FOverflowPanelViewInfo.FSignRect;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetOverflowPanelSignIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
begin
|
|
Result := (OverflowPanelIAccessibilityHelper.GetHelper as TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper).SignIAccessibilityHelper;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetOverflowPanelItemIAccessibilityHelper(AIndex: Integer): IdxNavBarAccessibilityHelper;
|
|
begin
|
|
Result := (OverflowPanelIAccessibilityHelper.GetHelper as TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper).ItemIAccessibilityHelpers[AIndex]
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsActiveGroupVisible: Boolean;
|
|
begin
|
|
Result := not Painter.Controller.Collapsed and (NavBar.ActiveGroup <> nil) and NavBar.ActiveGroup.Visible;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.IsGroupReflectionNeeded: Boolean;
|
|
begin
|
|
Result := FOverflowPanelViewInfo.IsVisible or
|
|
NavBar.OptionsView.Common.ShowGroupCaptions;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetRealGroupStartIndex: Integer;
|
|
begin
|
|
if IsActiveGroupVisible then
|
|
Result := 1
|
|
else
|
|
Result := 0;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetRealGroupCount: Integer;
|
|
begin
|
|
Result := GroupCount - GetRealGroupStartIndex;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneViewInfo.GetSmallImagesCount: Integer;
|
|
begin
|
|
if NavBar.SmallImages <> nil then
|
|
Result := NavBar.SmallImages.Count
|
|
else
|
|
Result := 0;
|
|
end;
|
|
|
|
{ TdxNavBarPopupControlViewInfo }
|
|
|
|
procedure TdxNavBarPopupControlViewInfo.CalculateBounds(AClientWidth: Integer);
|
|
var
|
|
X, Y: Integer;
|
|
AActiveGroupViewInfo: TdxNavBarGroupViewInfo;
|
|
begin
|
|
AActiveGroupViewInfo := TdxNavBarGroupViewInfo.Create(ViewInfo, NavBar.ActiveGroup, False, True);
|
|
try
|
|
X := 0;
|
|
Y := 0;
|
|
AActiveGroupViewInfo.CalculateBounds(X, Y);
|
|
FRect := cxRectSetHeight(AActiveGroupViewInfo.Rect,
|
|
cxRectHeight(AActiveGroupViewInfo.Rect) + GetBorderOffsets.Top + GetBorderOffsets.Bottom);
|
|
FRect := cxRectSetWidth(FRect,
|
|
AClientWidth + GetBorderOffsets.Left + GetBorderOffsets.Right);
|
|
if (AActiveGroupViewInfo.Control <> nil) or (cxRectHeight(FRect) > GetMaxHeight) then
|
|
FRect := cxRectSetHeight(FRect, GetMaxHeight);
|
|
finally
|
|
FreeAndNil(AActiveGroupViewInfo);
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarPopupControlViewInfo.CalculatePosition: TPoint;
|
|
begin
|
|
Result := NavBar.ClientToScreen(cxPoint(NavBar.Width - ViewInfo.BorderWidth,
|
|
cxRectHeight(ViewInfo.HeaderRect) - 1));
|
|
end;
|
|
|
|
function TdxNavBarPopupControlViewInfo.GetBorderOffsets: TRect;
|
|
begin
|
|
Result := cxRect(2, 2, 2, 2);
|
|
end;
|
|
|
|
function TdxNavBarPopupControlViewInfo.GetMaxHeight: Integer;
|
|
begin
|
|
Result := NavBar.ClientHeight - ViewInfo.GetHeaderHeight * 2;
|
|
end;
|
|
|
|
function TdxNavBarPopupControlViewInfo.GetMinWidth: Integer;
|
|
begin
|
|
Result := ViewInfo.GetNavBarMinExpandedWidth + GetBorderOffsets.Left + GetBorderOffsets.Right;
|
|
end;
|
|
|
|
function TdxNavBarPopupControlViewInfo.IsPtSizeGrip(const pt: TPoint): Boolean;
|
|
begin
|
|
Result := (pt.X >= cxRectWidth(FRect) - GetBorderOffsets.Right);
|
|
end;
|
|
|
|
function TdxNavBarPopupControlViewInfo.GetClientRect: TRect;
|
|
begin
|
|
Result := cxRectContent(FRect, GetBorderOffsets);
|
|
end;
|
|
|
|
type
|
|
TdxNavBarPopupInnerControl = class(TdxCustomNavBar)
|
|
private
|
|
FNavBar: TdxCustomNavBar;
|
|
procedure AcceptActiveGroupControl(ASource, ADestination: TdxCustomNavBar);
|
|
procedure AssignGroupProperties(ASource, ADestination: TdxCustomNavBar);
|
|
procedure CloneActiveGroupLinks(ASource, ADestination: TdxCustomNavBar);
|
|
procedure SynchronizeActiveGroupLinks;
|
|
protected
|
|
procedure UpdateData;
|
|
procedure UpdateOriginalData;
|
|
function IsInternal: Boolean; override;
|
|
public
|
|
constructor Create(APopupControl: TdxNavBarPopupControl); reintroduce; virtual;
|
|
end;
|
|
|
|
TdxNavBarPopupInnerControlControllerState = (icsOverSizeGrip);
|
|
TdxNavBarPopupInnerControlControllerStates = set of TdxNavBarPopupInnerControlControllerState;
|
|
|
|
TdxNavBarPopupInnerControlController = class(TdxNavBarNavigationPaneController)
|
|
private
|
|
FInternalState: TdxNavBarPopupInnerControlControllerStates;
|
|
function GetNavBar: TdxNavBarPopupInnerControl;
|
|
function GetMouseOverSizeGrip: Boolean;
|
|
function GetViewInfo: TdxNavBarOffice11NavPaneViewInfo;
|
|
procedure SetMouseOverSizeGrip(AValue: Boolean);
|
|
property MouseOverSizeGrip: Boolean read GetMouseOverSizeGrip write SetMouseOverSizeGrip;
|
|
protected
|
|
procedure DoLinkClick(ANavBar: TdxCustomNavBar; ALink: TdxNavBarItemLink); override;
|
|
procedure DoMouseDown(AButton: TMouseButton; AShift: TShiftState; const APoint: TPoint); override;
|
|
procedure DoMouseMove(AShift: TShiftState; const APoint: TPoint); override;
|
|
function GetCursor: HIcon; override;
|
|
|
|
property NavBar: TdxNavBarPopupInnerControl read GetNavBar;
|
|
property ViewInfo: TdxNavBarOffice11NavPaneViewInfo read GetViewInfo;
|
|
end;
|
|
|
|
{ TdxNavBarPopupInnerControl }
|
|
|
|
constructor TdxNavBarPopupInnerControl.Create(APopupControl: TdxNavBarPopupControl);
|
|
begin
|
|
inherited Create(APopupControl);
|
|
FNavBar := APopupControl.FNavBar;
|
|
OptionsView.NavigationPane.ShowHeader := False;
|
|
OptionsView.NavigationPane.ShowOverflowPanel := False;
|
|
end;
|
|
|
|
procedure TdxNavBarPopupInnerControl.UpdateData;
|
|
begin
|
|
View := FNavBar.View;
|
|
ViewStyle.Assign(FNavBar.ViewStyle);
|
|
AllowSelectLinks := FNavBar.AllowSelectLinks;
|
|
OptionsStyle := FNavBar.OptionsStyle;
|
|
OptionsImage := FNavBar.OptionsImage;
|
|
BeginUpdate;
|
|
try
|
|
Items.Assign(FNavBar.Items);
|
|
ActiveGroup.ClearLinks;
|
|
CloneActiveGroupLinks(FNavBar, Self);
|
|
AssignGroupProperties(FNavBar, Self);
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
TabStop := FNavBar.TabStop and not (Groups[0].UseControl and Groups[0].ShowControl);
|
|
end;
|
|
|
|
procedure TdxNavBarPopupInnerControl.UpdateOriginalData;
|
|
begin
|
|
FNavBar.BeginUpdate;
|
|
try
|
|
SynchronizeActiveGroupLinks;
|
|
AssignGroupProperties(Self, FNavBar);
|
|
finally
|
|
FNavBar.EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarPopupInnerControl.IsInternal: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TdxNavBarPopupInnerControl.AcceptActiveGroupControl(ASource, ADestination: TdxCustomNavBar);
|
|
var
|
|
AControl: TdxNavBarGroupControl;
|
|
ASourceGroup, ADestinationGroup: TdxNavBarGroup;
|
|
begin
|
|
ASourceGroup := ASource.ActiveGroup;
|
|
ADestinationGroup := ADestination.ActiveGroup;
|
|
AControl := ASourceGroup.Control;
|
|
AControl.Group := ADestinationGroup;
|
|
AControl.Parent := ADestination;
|
|
ADestinationGroup.AcceptControl(AControl);
|
|
ADestinationGroup.UseControl := True;
|
|
ADestinationGroup.ShowControl := ASourceGroup.ShowControl;
|
|
if ASource = Self then
|
|
begin
|
|
ASourceGroup.ReleaseControl;
|
|
AControl.Group := ADestinationGroup;
|
|
ASourceGroup.UseControl := False;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarPopupInnerControl.AssignGroupProperties(ASource, ADestination: TdxCustomNavBar);
|
|
var
|
|
ASourceGroup, ADestinationGroup: TdxNavBarGroup;
|
|
begin
|
|
ASourceGroup := ASource.ActiveGroup;
|
|
ADestinationGroup := ADestination.ActiveGroup;
|
|
if ASourceGroup = FNavBar.ActiveGroup then
|
|
begin
|
|
ADestinationGroup.CustomStyles := ASourceGroup.CustomStyles;
|
|
ADestinationGroup.LinksUseSmallImages := ASourceGroup.LinksUseSmallImages;
|
|
ADestinationGroup.ShowAsIconView := ASourceGroup.ShowAsIconView;
|
|
end;
|
|
if ASourceGroup.UseControl then
|
|
AcceptActiveGroupControl(ASource, ADestination);
|
|
ADestinationGroup.SelectedLinkIndex := ASourceGroup.SelectedLinkIndex;
|
|
ADestinationGroup.OnSelectedLinkChanged := ASourceGroup.OnSelectedLinkChanged;
|
|
ADestinationGroup.OnTopVisibleLinkChanged := ASourceGroup.OnTopVisibleLinkChanged;
|
|
ASourceGroup.OnSelectedLinkChanged := nil;
|
|
ASourceGroup.OnTopVisibleLinkChanged := nil;
|
|
end;
|
|
|
|
procedure TdxNavBarPopupInnerControl.CloneActiveGroupLinks(ASource, ADestination: TdxCustomNavBar);
|
|
var
|
|
I: Integer;
|
|
ASourceLink, ADestinationLink: TdxNavBarItemLink;
|
|
begin
|
|
for I := 0 to ASource.ActiveGroup.LinkCount - 1 do
|
|
begin
|
|
ASourceLink := ASource.ActiveGroup.Links[I];
|
|
ADestinationLink := ADestination.ActiveGroup.CreateLink(ADestination.Items[ASourceLink.Item.Index]);
|
|
if ASource = FNavBar then
|
|
ADestinationLink.Data := Integer(ASourceLink);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarPopupInnerControl.SynchronizeActiveGroupLinks;
|
|
var
|
|
I: Integer;
|
|
ASourceLink, ADestinationLink: TdxNavBarItemLink;
|
|
ASourceGroup, ADestinationGroup: TdxNavBarGroup;
|
|
begin
|
|
ASourceGroup := ActiveGroup;
|
|
ADestinationGroup := FNavBar.ActiveGroup;
|
|
for I := 0 to ASourceGroup.LinkCount - 1 do
|
|
begin
|
|
ASourceLink := ASourceGroup.Links[I];
|
|
ADestinationLink := TdxNavBarItemLink(ASourceGroup.Links[I].Data);
|
|
if ADestinationLink = nil then
|
|
ASourceLink.Data := Integer(ADestinationGroup.CreateLink(Items[ASourceLink.Item.Index]));
|
|
end;
|
|
for I := 0 to ASourceGroup.LinkCount - 1 do
|
|
begin
|
|
ASourceLink := ASourceGroup.Links[I];
|
|
ADestinationLink := TdxNavBarItemLink(ASourceGroup.Links[I].Data);
|
|
ADestinationLink.Index := ASourceLink.Index;
|
|
end;
|
|
for I := ADestinationGroup.LinkCount - 1 downto ASourceGroup.LinkCount do
|
|
ADestinationGroup.RemoveLink(I);
|
|
end;
|
|
|
|
{ TdxNavBarPopupInnerControlController }
|
|
|
|
procedure TdxNavBarPopupInnerControlController.DoLinkClick(ANavBar: TdxCustomNavBar; ALink: TdxNavBarItemLink);
|
|
begin
|
|
ALink.Selected := NavBar.AllowSelectLinks;
|
|
ALink := TdxNavBarItemLink(ALink.Data);
|
|
ANavBar := NavBar.FNavBar;
|
|
TdxNavBarNavigationPaneController(ANavBar.Painter.Controller).ClosePopupControl;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxNavBarPopupInnerControlController.DoMouseDown(AButton: TMouseButton; AShift: TShiftState; const APoint: TPoint);
|
|
begin
|
|
if MouseOverSizeGrip then
|
|
TdxNavBarPopupControl(NavBar.Parent).BeginResize(NavBar, AButton, AShift, APoint)
|
|
else
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxNavBarPopupInnerControlController.DoMouseMove(AShift: TShiftState; const APoint: TPoint);
|
|
begin
|
|
MouseOverSizeGrip := not (NavBar.IsPtBottomScrollButton(APoint) or NavBar.IsPtTopScrollButton(APoint)) and
|
|
cxRectPtIn(ViewInfo.SizeGripRect, APoint);
|
|
if not MouseOverSizeGrip then
|
|
inherited;
|
|
end;
|
|
|
|
function TdxNavBarPopupInnerControlController.GetCursor: HIcon;
|
|
begin
|
|
if MouseOverSizeGrip then
|
|
Result := Screen.Cursors[crSizeWE]
|
|
else
|
|
Result := inherited GetCursor;
|
|
end;
|
|
|
|
function TdxNavBarPopupInnerControlController.GetNavBar: TdxNavBarPopupInnerControl;
|
|
begin
|
|
Result := TdxNavBarPopupInnerControl(FNavBar);
|
|
end;
|
|
|
|
function TdxNavBarPopupInnerControlController.GetMouseOverSizeGrip: Boolean;
|
|
begin
|
|
Result := icsOverSizeGrip in FInternalState;
|
|
end;
|
|
|
|
function TdxNavBarPopupInnerControlController.GetViewInfo: TdxNavBarOffice11NavPaneViewInfo;
|
|
begin
|
|
Result := TdxNavBarOffice11NavPaneViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
procedure TdxNavBarPopupInnerControlController.SetMouseOverSizeGrip(AValue: Boolean);
|
|
begin
|
|
if MouseOverSizeGrip <> AValue then
|
|
if AValue then
|
|
Include(FInternalState, icsOverSizeGrip)
|
|
else
|
|
Exclude(FInternalState, icsOverSizeGrip);
|
|
end;
|
|
|
|
{ TdxNavBarPopupControl }
|
|
|
|
constructor TdxNavBarPopupControl.Create(ANavBar: TdxCustomNavBar);
|
|
begin
|
|
inherited Create(ANavBar);
|
|
CaptureFocus := True;
|
|
FNavBar := ANavBar;
|
|
FOriginalWidth := Painter.Controller.OriginalWidth;
|
|
end;
|
|
|
|
destructor TdxNavBarPopupControl.Destroy;
|
|
begin
|
|
FreeAndNil(FInnerControl);
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxNavBarPopupControl.CloseUp;
|
|
begin
|
|
TdxNavBarPopupInnerControl(FInnerControl).UpdateOriginalData;
|
|
if pcsSizing in FInternalState then
|
|
EndResize(True);
|
|
FreeAndNil(FViewInfo);
|
|
ActiveControl := nil;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxNavBarPopupControl.Popup(AFocusedControl: TWinControl);
|
|
begin
|
|
CreateViewInfo;
|
|
inherited;
|
|
end;
|
|
|
|
function TdxNavBarPopupControl.NeedAdjustWidth: Boolean;
|
|
begin
|
|
Result := FNavBar.OptionsBehavior.NavigationPane.AdjustWidthByPopup;
|
|
end;
|
|
|
|
function TdxNavBarPopupControl.CalculatePosition: TPoint;
|
|
begin
|
|
Result := FViewInfo.CalculatePosition;
|
|
end;
|
|
|
|
procedure TdxNavBarPopupControl.CalculateSize;
|
|
begin
|
|
FViewInfo.CalculateBounds(FOriginalWidth);
|
|
Width := cxRectWidth(FViewInfo.FRect);
|
|
Height := cxRectHeight(FViewInfo.FRect);
|
|
FInnerControl.Width := cxRectWidth(FViewInfo.ClientRect);
|
|
FInnerControl.Height := cxRectHeight(FViewInfo.ClientRect);
|
|
end;
|
|
|
|
procedure TdxNavBarPopupControl.BeginResize(AControl: TControl; AButton: TMouseButton; AShift: TShiftState; const APoint: TPoint);
|
|
var
|
|
ARealPoint: TPoint;
|
|
begin
|
|
SetCaptureControl(Self);
|
|
if AControl <> Self then
|
|
ARealPoint := dxNavBarCollns.ClientToParent(AControl, APoint, Self)
|
|
else
|
|
ARealPoint := APoint;
|
|
FCapturePointOffset := Width - ARealPoint.X;
|
|
Include(FInternalState, pcsSizing);
|
|
DrawSizeFrame(BoundsRect);
|
|
end;
|
|
|
|
procedure TdxNavBarPopupControl.EndResize(ACancel: Boolean = False);
|
|
begin
|
|
SetCaptureControl(nil);
|
|
Exclude(FInternalState, pcsSizing);
|
|
if not ACancel then
|
|
SetNewWidth(cxRectWidth(FSizeFrame.BoundsRect));
|
|
DrawSizeFrame(cxEmptyRect);
|
|
end;
|
|
|
|
procedure TdxNavBarPopupControl.DoShowed;
|
|
begin
|
|
inherited DoShowed;
|
|
if FInnerControl.Groups[0].UseControl and FInnerControl.Groups[0].ShowControl then
|
|
begin
|
|
TdxNavBarPainterAccess(FInnerControl.Painter).CheckDrawParamChanges;
|
|
ActiveControl := FindNextControl(nil, True, True, False);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarPopupControl.DrawSizeFrame(const R: TRect);
|
|
var
|
|
ABorderWidth: Integer;
|
|
begin
|
|
if not IsRectEmpty(R) then
|
|
begin
|
|
ABorderWidth := 1;
|
|
if FSizeFrame = nil then
|
|
FSizeFrame := TcxSizeFrame.Create(ABorderWidth);
|
|
FSizeFrame.Show;
|
|
FSizeFrame.DrawSizeFrame(R);
|
|
end
|
|
else
|
|
FreeAndNil(FSizeFrame);
|
|
end;
|
|
|
|
procedure TdxNavBarPopupControl.InitPopup;
|
|
begin
|
|
if FInnerControl = nil then
|
|
begin
|
|
FInnerControl := TdxNavBarPopupInnerControl.Create(Self);
|
|
FInnerControl.Parent := Self;
|
|
FInnerControl.Left := ViewInfo.GetBorderOffsets.Left;
|
|
FInnerControl.Top := ViewInfo.GetBorderOffsets.Top;
|
|
FInnerControl.Groups.Add; /////-> InnerControl
|
|
FInnerControl.ShowGroupCaptions := False; /////-> InnerControl
|
|
end;
|
|
TdxNavBarPopupInnerControl(FInnerControl).UpdateData;
|
|
if NeedAdjustWidth then
|
|
FOriginalWidth := Painter.Controller.OriginalWidth;
|
|
end;
|
|
|
|
procedure TdxNavBarPopupControl.Paint;
|
|
begin
|
|
FViewInfo.Painter.DrawPopupControl(Canvas, FViewInfo);
|
|
end;
|
|
|
|
procedure TdxNavBarPopupControl.RefreshPopupWindow;
|
|
begin
|
|
CalculateSize;
|
|
Refresh;
|
|
end;
|
|
|
|
procedure TdxNavBarPopupControl.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
|
|
begin
|
|
//inherited;
|
|
if (GetCaptureControl <> nil) and ViewInfo.IsPtSizeGrip(cxPoint(X, Y)) then
|
|
BeginResize(Self, Button, Shift, cxPoint(X, Y));
|
|
end;
|
|
|
|
procedure TdxNavBarPopupControl.MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
|
|
begin
|
|
if pcsSizing in FInternalState then
|
|
EndResize;
|
|
end;
|
|
|
|
procedure TdxNavBarPopupControl.MouseMove(Shift: TShiftState; X, Y: Integer);
|
|
begin
|
|
// inherited;
|
|
if not (pcsSizing in FInternalState) then
|
|
MouseOverSizeGrip := ViewInfo.IsPtSizeGrip(Point(X, Y))
|
|
else
|
|
if X + FCapturePointOffset > ViewInfo.GetMinWidth then
|
|
DrawSizeFrame(cxRectSetWidth(BoundsRect, X + FCapturePointOffset));
|
|
end;
|
|
|
|
function TdxNavBarPopupControl.NeedIgnoreMouseMessageAfterCloseUp(AWnd: THandle; AMsg: Cardinal;
|
|
AShift: TShiftState; const APos: TPoint): Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TdxNavBarPopupControl.KeyDown(var Key: Word; Shift: TShiftState);
|
|
begin
|
|
if Key = VK_ESCAPE then
|
|
if pcsSizing in FInternalState then
|
|
EndResize(True)
|
|
else
|
|
CloseUp
|
|
else
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxNavBarPopupControl.CreateViewInfo;
|
|
begin
|
|
FViewInfo := Painter.CreatePopupControlViewInfo;
|
|
end;
|
|
|
|
function TdxNavBarPopupControl.GetPainter: TdxNavBarNavigationPanePainter;
|
|
begin
|
|
Result := TdxNavBarNavigationPanePainter(FNavBar.Painter);
|
|
end;
|
|
|
|
procedure TdxNavBarPopupControl.SetNewWidth(AWidth: Integer);
|
|
begin
|
|
FOriginalWidth := FOriginalWidth + AWidth - Width;
|
|
if NeedAdjustWidth then
|
|
Painter.Controller.OriginalWidth := FOriginalWidth;
|
|
RefreshPopupWindow;
|
|
end;
|
|
|
|
function TdxNavBarPopupControl.GetMouseOverSizeGrip: Boolean;
|
|
begin
|
|
Result := pcsOverSizeGrip in FInternalState;
|
|
end;
|
|
|
|
procedure TdxNavBarPopupControl.SetMouseOverSizeGrip(AValue: Boolean);
|
|
begin
|
|
if MouseOverSizeGrip <> AValue then
|
|
if AValue then
|
|
begin
|
|
Include(FInternalState, pcsOverSizeGrip);
|
|
Cursor := crSizeWE;
|
|
end
|
|
else
|
|
begin
|
|
Exclude(FInternalState, pcsOverSizeGrip);
|
|
Cursor := crDefault;
|
|
end;
|
|
end;
|
|
|
|
{ TdxNavBarNavigationPaneController }
|
|
|
|
constructor TdxNavBarNavigationPaneController.Create(ANavBar: TdxCustomNavBar);
|
|
begin
|
|
inherited;
|
|
TdxCustomNavBarAccess(ANavBar).OnCollapseStateChanged := CollapseStateChaged;
|
|
FDroppedDownPart := dxNavBarPart(nbNone);
|
|
end;
|
|
|
|
destructor TdxNavBarNavigationPaneController.Destroy;
|
|
begin
|
|
TdxCustomNavBarAccess(FNavBar).OnCollapseStateChanged := nil;
|
|
FreeAndNil(FPopupControl);
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.ClosePopupControl;
|
|
begin
|
|
if IsPopupControlExists and IsPopupControlVisible then
|
|
PopupControl.CloseUp;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.ShowPopupControl;
|
|
begin
|
|
if FNavBar.ActiveGroup <> nil then
|
|
begin
|
|
if not IsPopupControlExists then
|
|
FPopupControl := TdxNavBarPopupControl.Create(FNavBar);
|
|
FPopupControl.OwnerBounds := FNavBar.BoundsRect;
|
|
FPopupControl.OwnerParent := FNavBar.Parent;
|
|
FPopupControl.Popup(nil);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.DoClick(const APart: TdxNavBarPart);
|
|
begin
|
|
case HotPart.MajorPartIndex of
|
|
nbOverflowPanelItem: DoOverflowPanelItemClick;
|
|
nbOverflowPanelSign: DoOverflowPanelSignClick;
|
|
nbHeaderSign:
|
|
begin
|
|
DoHeaderSignClick;
|
|
HotPart := dxNavBarPart(nbNone);
|
|
end;
|
|
nbItemPanelCollapseBar: DoCollapseBarClick;
|
|
nbItemPanelCollapseItem: DoCollapseItemClick;
|
|
else
|
|
inherited;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.DoCheckBounds(var ALeft, ATop, AWidth, AHeight: Integer);
|
|
begin
|
|
inherited;
|
|
if AWidth <> FNavBar.Width then
|
|
if Collapsed then
|
|
if AWidth >= ViewInfo.GetNavBarMinExpandedWidth then
|
|
begin
|
|
OriginalWidth := AWidth;
|
|
ChangeNavBarCollapseState;
|
|
end
|
|
else
|
|
AWidth := ViewInfo.GetNavBarCollapsedWidth
|
|
else
|
|
if AWidth < ViewInfo.GetNavBarMinExpandedWidth then
|
|
ChangeNavBarCollapseState;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.DoMouseDown(AButton: TMouseButton; AShift: TShiftState; const APoint: TPoint);
|
|
begin
|
|
if IsPopupControlExists and FPopupControl.JustClosed then
|
|
Include(FInternalState, npsPopupShowLocked)
|
|
else
|
|
begin
|
|
Exclude(FInternalState, npsPopupShowLocked);
|
|
if (ssLeft in AShift) then
|
|
begin
|
|
PressedPart := GetPartAtPos(APoint);
|
|
if IsdxNavBarPartsEqual(PressedPart, dxNavBarPart(nbNone)) then
|
|
inherited;
|
|
end
|
|
else
|
|
inherited;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.DoMouseMove(AShift: TShiftState; const APoint: TPoint);
|
|
begin
|
|
HotPart := GetPartAtPos(APoint);
|
|
if PressedPart.MajorPartIndex = nbSplitter then
|
|
DoSplitterDrag(APoint)
|
|
else
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.DoMouseLeave;
|
|
begin
|
|
HotPart := dxNavBarPart(nbNone);
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.DoSetHotPart(const APart: TdxNavBarPart);
|
|
begin
|
|
InvalidateAll(doRedraw);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.DoSetPressedPart(const APart: TdxNavBarPart);
|
|
begin
|
|
InvalidateAll(doRedraw);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.DoShowHint(var AHintInfo: THintInfo);
|
|
begin
|
|
if IsAnyItemHotTracked then
|
|
begin
|
|
if NavBar.ShowNavigationPaneOverflowPanelHints then
|
|
DoShowOverflowPanelHint(AHintInfo);
|
|
end
|
|
else
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.DoShowOverflowPanelHint(var AHintInfo: THintInfo);
|
|
begin
|
|
ViewInfo.HintText := GetNavPaneItemHintText;
|
|
ViewInfo.HintRect := GetNavPaneItemHintRect(AHintInfo.CursorPos);
|
|
AHintInfo.CursorRect := GetNavPaneItemHintCursorRect;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneController.GetNavPaneItemHintRect(const ACursorPos: TPoint): TRect;
|
|
var
|
|
ANavBarItem: TObject;
|
|
begin
|
|
case HotPart.MajorPartIndex of
|
|
nbOverflowPanelItem: ANavBarItem := ViewInfo.OverflowPanelItems[HotPart.MinorPartIndex].Group;
|
|
nbItemPanelCollapseItem: ANavBarItem := ViewInfo.ItemPanelViewInfo.Items[HotPart.MinorPartIndex].ItemLink.Item;
|
|
else
|
|
ANavBarItem := nil;
|
|
end;
|
|
Result := GetItemHintRect(ANavBarItem, CalcOverflowPanelHintRect);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneController.GetNavPaneItemHintText: string;
|
|
begin
|
|
case HotPart.MajorPartIndex of
|
|
nbOverflowPanelItem:
|
|
Result := RemoveAccelChars(ViewInfo.OverflowPanelItems[HotPart.MinorPartIndex].Group.Caption, False);
|
|
nbOverflowPanelSign:
|
|
Result := cxGetResourceString(@sdxNavigationPaneOverflowPanelCustomizeHint);
|
|
nbHeaderSign:
|
|
if Collapsed then
|
|
Result := cxGetResourceString(@sdxNavigationPaneExpandNavPaneSignHint)
|
|
else
|
|
Result := cxGetResourceString(@sdxNavigationPaneMinimizeNavPaneSignHint);
|
|
nbItemPanelCollapseItem:
|
|
Result := RemoveAccelChars(GetLinkHintText(ViewInfo.ItemPanelViewInfo.Items[HotPart.MinorPartIndex].ItemLink), False);
|
|
nbItemPanelCollapseBar:
|
|
Result := cxGetResourceString(@sdxNavigationPaneCollapseBarHint);
|
|
else
|
|
Result := '';
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneController.GetNavPaneItemHintCursorRect: TRect;
|
|
begin
|
|
case HotPart.MajorPartIndex of
|
|
nbOverflowPanelItem: Result := ViewInfo.OverflowPanelItems[HotPart.MinorPartIndex].SelectionRect;
|
|
nbOverflowPanelSign: Result := ViewInfo.OverflowPanelSignRect;
|
|
nbHeaderSign: Result := ViewInfo.HeaderSignRect;
|
|
nbItemPanelCollapseItem: Result := ViewInfo.ItemPanelViewInfo.Items[HotPart.MinorPartIndex].Rect;
|
|
nbItemPanelCollapseBar: Result := ViewInfo.ItemPanelViewInfo.CollapseBarRect;
|
|
else
|
|
Result := cxNullRect;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.DoOverflowPanelItemClick;
|
|
begin
|
|
FNavBar.ActiveGroup := OverflowPanelGroup[HotPart.MinorPartIndex]
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.DoOverflowPanelSignClick;
|
|
var
|
|
APoint: TPoint;
|
|
begin
|
|
APoint.Y := cxRectCenter(ViewInfo.OverflowPanelSignRect).Y;
|
|
APoint.X := ViewInfo.OverflowPanelSignRect.Right;
|
|
DroppedDownPart := dxNavBarPart(nbOverflowPanelSign);
|
|
ViewInfo.DoShowPopupMenu(FNavBar.ClientToScreen(APoint));
|
|
DroppedDownPart := dxNavBarPart(nbNone);
|
|
HotPart := GetPartAtPos(GetMouseCursorPos);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.DoHeaderSignClick;
|
|
begin
|
|
ChangeNavBarCollapseState;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.DoCollapseBarClick;
|
|
var
|
|
ALinkSelf: TcxObjectLink;
|
|
begin
|
|
if not IsPopupControlExists or not IsPopupControlVisible and not (npsPopupShowLocked in FInternalState) then
|
|
begin
|
|
DroppedDownPart := dxNavBarPart(nbItemPanelCollapseBar);
|
|
ALinkSelf := cxAddObjectLink(Self);
|
|
try
|
|
ShowPopupControl;
|
|
if ALinkSelf.Ref <> nil then
|
|
DroppedDownPart := dxNavBarPart(nbNone);
|
|
finally
|
|
cxRemoveObjectLink(ALinkSelf);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.DoCollapseItemClick;
|
|
begin
|
|
DoLinkClick(NavBar, ViewInfo.FItemPanelViewInfo.Items[HotPart.MinorPartIndex].ItemLink);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.DoSplitterDrag(const APoint: TPoint);
|
|
begin
|
|
if FNavBar.CanDecNavigationPaneOverflowPanelItemCount and
|
|
ViewInfo.IsPtDecNavigationPaneOverflowPanelItemCount(APoint) then
|
|
FNavBar.DoDecNavigationPaneOverflowPanelItemCount
|
|
else
|
|
if FNavBar.CanIncNavigationPaneOverflowPanelItemCount and
|
|
ViewInfo.IsPtIncNavigationPaneOverflowPanelItemCount(APoint) then
|
|
FNavBar.DoIncNavigationPaneOverflowPanelItemCount;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneController.CanFocusOnClick(const APoint: TPoint): Boolean;
|
|
begin
|
|
Result := not ViewInfo.IsPtNavigationPaneSplitter(APoint) and inherited CanFocusOnClick(APoint);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneController.GetCursor: HIcon;
|
|
|
|
function InternalGetCursor(const APart: TdxNavBarPart; out ACursor: HIcon): Boolean;
|
|
begin
|
|
Result := not IsdxNavBarPartsEqual(APart, dxNavBarPart(nbNone));
|
|
if IsdxNavBarPartsEqual(APart, dxNavBarPart(nbSplitter)) then
|
|
if FNavBar.ShowGroupCaptions then
|
|
ACursor := Screen.Cursors[crSizeNS]
|
|
else
|
|
ACursor := 0
|
|
else
|
|
ACursor := Screen.Cursors[FNavBar.HotTrackedGroupCursor];
|
|
end;
|
|
|
|
begin
|
|
if not (InternalGetCursor(PressedPart, Result) or InternalGetCursor(HotPart, Result)) then
|
|
Result := inherited GetCursor;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneController.Collapsible: Boolean;
|
|
begin
|
|
Result := FNavBar.OptionsBehavior.NavigationPane.Collapsible;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneController.Collapsed: Boolean;
|
|
begin
|
|
Result := FNavBar.OptionsBehavior.NavigationPane.Collapsed;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.CollapseStateChaged(Sender: TObject);
|
|
begin
|
|
ClosePopupControl;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.CalcOverflowPanelHintRect(AItem: TObject; var ARect: TRect);
|
|
begin
|
|
if Assigned(NavBar.OnCalcNavigationPaneOverflowPanelHintRect) then
|
|
NavBar.OnCalcNavigationPaneOverflowPanelHintRect(NavBar, TdxNavBarGroup(AItem), ViewInfo, ARect);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.ChangeNavBarCollapseState;
|
|
begin
|
|
FNavBar.OptionsBehavior.NavigationPane.Collapsed := not Collapsed;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneController.IsAnyItemHotTracked: Boolean;
|
|
begin
|
|
Result := not IsdxNavBarPartsEqual(HotPart, dxNavBarPart(nbNone));
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneController.IsPopupControlExists: Boolean;
|
|
begin
|
|
Result := FPopupControl <> nil;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneController.IsPopupControlVisible: Boolean;
|
|
begin
|
|
Result := IsPopupControlExists and FPopupControl.Visible;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneController.IsOverflowPanelGroupHotTracked: Boolean;
|
|
begin
|
|
Result := HotPart.MajorPartIndex = nbOverflowPanelItem;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneController.GetNavPanePartState(const APart: TdxNavBarPart): TdxNavBarNavPanePartState;
|
|
var
|
|
AGroup: TdxNavBarGroup;
|
|
begin
|
|
if APart.MajorPartIndex = nbOverflowPanelItem then
|
|
AGroup := OverflowPanelGroup[APart.MinorPartIndex]
|
|
else
|
|
AGroup := nil;
|
|
|
|
if (AGroup <> nil) and (FNavBar.ActiveGroup = AGroup) then
|
|
begin
|
|
if IsdxNavBarPartsEqual(HotPart, APart) and (IsdxNavBarPartsEqual(PressedPart, dxNavBarPart(nbNone)) or IsdxNavBarPartsEqual(PressedPart, APart)) then
|
|
Result := oisHotCheck
|
|
else
|
|
Result := oisChecked
|
|
end
|
|
else
|
|
if IsdxNavBarPartsEqual(FDroppedDownPart, APart) then
|
|
Result := oisDroppedDown
|
|
else
|
|
if IsdxNavBarPartsEqual(PressedPart, APart) then
|
|
if IsdxNavBarPartsEqual(HotPart, APart) then
|
|
Result := oisPressed
|
|
else
|
|
Result := oisNormal
|
|
else
|
|
if IsdxNavBarPartsEqual(HotPart, APart) and IsdxNavBarPartsEqual(PressedPart, dxNavBarPart(nbNone)) then
|
|
Result := oisHot
|
|
else
|
|
Result := oisNormal;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneController.GetOriginalWidth: Integer;
|
|
begin
|
|
Result := TdxCustomNavBarAccess(FNavBar).OriginalWidth;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneController.GetPartAtPos(const APoint: TPoint): TdxNavBarPart;
|
|
begin
|
|
Result.MinorPartIndex := ViewInfo.FOverflowPanelViewInfo.GetItemIndexAtPos(APoint);
|
|
if (Result.MinorPartIndex <> nbNone) then
|
|
Result.MajorPartIndex := nbOverflowPanelItem
|
|
else
|
|
if ViewInfo.IsPtNavigationPaneOverflowPanelSign(APoint) then
|
|
Result.MajorPartIndex := nbOverflowPanelSign
|
|
else
|
|
if ViewInfo.IsPtNavigationPaneHeaderSign(APoint) then
|
|
Result.MajorPartIndex := nbHeaderSign
|
|
else
|
|
if ViewInfo.IsPtNavigationPaneSplitter(APoint) then
|
|
Result.MajorPartIndex := nbSplitter
|
|
else
|
|
if Collapsed and ViewInfo.IsPtNavigationPaneItemPanel(APoint) then
|
|
begin
|
|
Result.MinorPartIndex := ViewInfo.FItemPanelViewInfo.GetItemIndexAtPos(APoint);
|
|
if Result.MinorPartIndex <> nbNone then
|
|
Result.MajorPartIndex := nbItemPanelCollapseItem
|
|
else
|
|
Result.MajorPartIndex := nbItemPanelCollapseBar;
|
|
end
|
|
else
|
|
Result := inherited GetPartAtPos(APoint);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneController.GetViewInfo: TdxNavBarNavigationPaneViewInfo;
|
|
begin
|
|
Result := TdxNavBarNavigationPaneViewInfo(inherited ViewInfo);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneController.GetOverflowPanelGroup(AIndex: Integer): TdxNavBarGroup;
|
|
begin
|
|
Result := ViewInfo.FOverflowPanelViewInfo.Items[AIndex].Group;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.SetDroppedDownPart(APart: TdxNavBarPart);
|
|
begin
|
|
if not IsdxNavBarPartsEqual(FDroppedDownPart, APart) then
|
|
begin
|
|
FDroppedDownPart := APart;
|
|
InvalidateAll(doRedraw);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneController.SetOriginalWidth(AValue: Integer);
|
|
begin
|
|
TdxCustomNavBarAccess(FNavBar).OriginalWidth := AValue;
|
|
end;
|
|
|
|
{ TdxNavBarNavigationPanePainter }
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawNavBarControl;
|
|
begin
|
|
inherited DrawNavBarControl;
|
|
DrawHeader;
|
|
DrawItemPanel;
|
|
DrawOverflowPanel;
|
|
DrawSplitter;
|
|
DrawBorder;
|
|
if TdxCustomNavBarAccess(NavBar).IsInternal then
|
|
DrawSizeGrip(Canvas, ViewInfo.SizeGripRect);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawGroupCaption(AGroupViewInfo: TdxNavBarGroupViewInfo);
|
|
begin
|
|
DrawGroupCaptionButton(AGroupViewInfo);
|
|
if not Controller.Collapsed then
|
|
DrawGroupCaptionText(AGroupViewInfo);
|
|
if AGroupViewInfo.IsCaptionImageVisible then
|
|
DrawGroupCaptionImage(AGroupViewInfo);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawSizeGrip(ACanvas: TCanvas; const ARect: TRect);
|
|
const
|
|
ASpace = 4;
|
|
ALineCount = 3;
|
|
var
|
|
I: Integer;
|
|
AStartPoint: TPoint;
|
|
begin
|
|
ACanvas.Pen.Color := clBlack;
|
|
AStartPoint := cxRectOffset(ARect, -ViewInfo.BorderWidth, -ViewInfo.BorderWidth).BottomRight;
|
|
Dec(AStartPoint.Y);
|
|
for I := 0 to ALineCount - 1 do
|
|
with AStartPoint do
|
|
begin
|
|
ACanvas.MoveTo(X - ASpace * (I + 1), Y);
|
|
ACanvas.LineTo(X, Y - ASpace* (I + 1));
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawHintWindow(AHintWindow: TdxNavBarHintWindow);
|
|
begin
|
|
if Controller.IsAnyItemHotTracked then
|
|
DrawOverflowPanelHintWindow(AHintWindow.Canvas, AHintWindow.ClientRect)
|
|
else
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawItemPanel;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
if Controller.Collapsed then
|
|
begin
|
|
DrawCollapseBar(ViewInfo.FItemPanelViewInfo);
|
|
for I := 0 to ViewInfo.FItemPanelViewInfo.ItemCount - 1 do
|
|
DrawCollapseItem(ViewInfo.FItemPanelViewInfo.Items[I], GetNavPanePartState(dxNavBarPart(nbItemPanelCollapseItem, I)));
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawGroupCaptionButton(AGroupViewInfo: TdxNavBarGroupViewInfo);
|
|
begin
|
|
with AGroupViewInfo do
|
|
TdxNavBarOffice11NavPaneGroupButtonPainter.DrawButton(Canvas, CaptionRect, CaptionImage,
|
|
CaptionBackColor, CaptionBackColor2, CaptionAlphaBlend, CaptionAlphaBlend2,
|
|
CaptionGradientMode, CaptionBorderColor, State);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawCollapseBar(AItemPanelViewInfo: TdxNavBarItemPanelViewInfo);
|
|
var
|
|
AState: TdxNavBarNavPanePartState;
|
|
begin
|
|
AState := GetNavPanePartState(dxNavBarPart(nbItemPanelCollapseBar));
|
|
DrawCollapseElementBackground(AItemPanelViewInfo.CollapseBarRect, AState);
|
|
DrawVertivalText(AItemPanelViewInfo.CollapseBarFont, AItemPanelViewInfo.CollapseBarText, AItemPanelViewInfo.CollapseBarRect, AState);
|
|
if AItemPanelViewInfo.CollapseBarIAccessibilityHelper.IsFocused then
|
|
DrawItemPanelPartFocusRect(AItemPanelViewInfo.CollapseBarRect);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawCollapseElementBackground(const ARect: TRect; AState: TdxNavBarNavPanePartState);
|
|
begin
|
|
case AState of
|
|
oisNormal:
|
|
begin
|
|
Canvas.Brush.Color := GetMiddleRGB(ViewInfo.OverflowPanelBackColor, ViewInfo.OverflowPanelBackColor2, 50);
|
|
Canvas.FillRect(ARect);
|
|
end;
|
|
else
|
|
DrawOverflowPanelItemBackground(Canvas, AState, ARect);
|
|
end;
|
|
cxCanvas.FrameRect(ARect, clBlack, 1, [bBottom]);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawCollapseItem(AItemViewInfo: TdxNavBarItemPanelViewInfoItem; AState: TdxNavBarNavPanePartState);
|
|
begin
|
|
DrawCollapseElementBackground(AItemViewInfo.Rect, AState);
|
|
DrawVertivalText(AItemViewInfo.Font, AItemViewInfo.Caption, AItemViewInfo.TextRect, AState);
|
|
if ImagePainterClass.IsValidImage(AItemViewInfo.ImageList, AItemViewInfo.ImageIndex) then
|
|
ImagePainterClass.DrawImage(Canvas, AItemViewInfo.ImageList, AItemViewInfo.ImageIndex, AItemViewInfo.ImageRect);
|
|
if ViewInfo.ItemPanelViewInfo.ItemIAccessibilityHelpers[AItemViewInfo.Index].IsFocused then
|
|
DrawItemPanelPartFocusRect(AItemViewInfo.Rect);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawBorder;
|
|
var
|
|
ABorderRect: TRect;
|
|
begin
|
|
with cxCanvas do
|
|
begin
|
|
SaveClipRegion;
|
|
try
|
|
ABorderRect := cxRectBounds(0, 0, ViewInfo.ClientWidth, ViewInfo.ClientHeight);
|
|
SetClipRegion(TcxRegion.Create(cxRectInflate(ABorderRect, - ViewInfo.BorderWidth, - ViewInfo.BorderWidth)),
|
|
roSubtract);
|
|
FillRect(ABorderRect, ViewInfo.BorderColor);
|
|
finally
|
|
RestoreClipRegion;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawHeader;
|
|
var
|
|
AHandled: Boolean;
|
|
begin
|
|
if not ViewInfo.IsHeaderVisible then Exit;
|
|
AHandled := False;
|
|
if Assigned(NavBar.OnCustomDrawNavigationPaneHeader) then
|
|
NavBar.OnCustomDrawNavigationPaneHeader(NavBar, Canvas, ViewInfo, AHandled);
|
|
if not AHandled then
|
|
DoDrawHeader;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawHeaderBackground;
|
|
var
|
|
R: TRect;
|
|
begin
|
|
R := ViewInfo.HeaderRect;
|
|
Inc(R.Top);
|
|
with ViewInfo do
|
|
BackgroundPainterClass.DrawBackground(Canvas, R, HeaderImage, False, clNone,
|
|
HeaderBackColor, HeaderBackColor2, HeaderAlphaBlend, HeaderAlphaBlend2,
|
|
OverflowPanelGradientMode);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawHeaderSign;
|
|
const
|
|
AStateMap: array[Boolean] of TdxNavBarObjectStates = ([sExpanded], []);
|
|
var
|
|
ACanvas: TcxCanvas;
|
|
ABitmap: TcxCustomBitmap;
|
|
ASignColor: TColor;
|
|
begin
|
|
ABitmap := TcxCustomBitmap.CreateSize(ViewInfo.FHeaderSignRect);
|
|
try
|
|
ACanvas := ABitmap.cxCanvas;
|
|
|
|
case GetNavPanePartState(dxNavBarPart(nbHeaderSign)) of
|
|
oisNormal:
|
|
begin
|
|
ASignColor := ViewInfo.HeaderFontColor;
|
|
ACanvas.CopyRect(ABitmap.ClientRect, Canvas, ViewInfo.FHeaderSignRect);
|
|
end;
|
|
else
|
|
ASignColor := clBlack;
|
|
DrawOverflowPanelItemBackground(ACanvas.Canvas, dxNavBarPart(nbHeaderSign), ABitmap.ClientRect);
|
|
end;
|
|
|
|
ABitmap.Rotate(raMinus90);
|
|
TdxNavBarOffice11ExplorerBarSignPainter.DrawSign(ACanvas.Canvas, ABitmap.ClientRect,
|
|
ASignColor, clNone, clNone, AStateMap[Controller.Collapsed]);
|
|
ABitmap.Rotate(raPlus90);
|
|
|
|
with ViewInfo.FHeaderSignRect.TopLeft do
|
|
Canvas.Draw(X, Y, ABitmap);
|
|
finally
|
|
ABitmap.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawHeaderText;
|
|
var
|
|
R: TRect;
|
|
AText: string;
|
|
begin
|
|
with ViewInfo do
|
|
begin
|
|
R := FHeaderTextRect;
|
|
Inc(R.Left, ViewInfo.GetGroupHeaderTextIndent);
|
|
|
|
if (NavBar.ActiveGroup <> nil) and NavBar.ActiveGroup.Visible then
|
|
AText := RemoveAccelChars(NavBar.ActiveGroup.Caption)
|
|
else
|
|
AText := '';
|
|
Canvas.Brush.Style := bsClear;
|
|
Canvas.Font := HeaderFont;
|
|
Canvas.Font.Color := HeaderFontColor;
|
|
cxDrawText(DC, AText, R, HeaderDrawEdgeFlag or DT_NOPREFIX);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawOverflowPanel;
|
|
var
|
|
AHandled: Boolean;
|
|
begin
|
|
if not OverflowPanelViewInfo.IsVisible then Exit;
|
|
AHandled := False;
|
|
if Assigned(NavBar.OnCustomDrawNavigationPaneOverflowPanel) then
|
|
NavBar.OnCustomDrawNavigationPaneOverflowPanel(NavBar, Canvas, ViewInfo, AHandled);
|
|
if not AHandled then
|
|
DoDrawOverflowPanel;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawOverflowPanelBackground;
|
|
begin
|
|
with ViewInfo do
|
|
TdxNavBarOffice11NavPaneGroupButtonPainter.DrawButton(Canvas, OverflowPanelRect, OverflowPanelImage,
|
|
OverflowPanelBackColor, OverflowPanelBackColor2, OverflowPanelAlphaBlend,
|
|
OverflowPanelAlphaBlend2, OverflowPanelGradientMode, BorderColor, []);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawOverflowPanelSign;
|
|
var
|
|
R: TRect;
|
|
begin
|
|
if dxOffice11NavPaneOverflowPanelBitmap <> nil then
|
|
begin
|
|
R := ViewInfo.OverflowPanelSignRect;
|
|
if R.Left > ViewInfo.OverflowPanelRect.Left then
|
|
begin
|
|
DrawOverflowPanelItemBackground(Canvas, dxNavBarPart(nbOverflowPanelSign), R);
|
|
|
|
with cxRectCenter(R, dxOffice11NavPaneOverflowPanelBitmap.Width, dxOffice11NavPaneOverflowPanelBitmap.Height).TopLeft do
|
|
Canvas.Draw(X, Y, dxOffice11NavPaneOverflowPanelBitmap);
|
|
// if ViewInfo.OverflowPanelSignIAccessibilityHelper.IsFocused then
|
|
// begin
|
|
// R := Bounds(X, Y, dxOffice11NavPaneOverflowPanelBitmap.Width,
|
|
// dxOffice11NavPaneOverflowPanelBitmap.Height);
|
|
// InflateRect(R, 1, 1);
|
|
// DrawSolidFocusRect(R, clBlack);
|
|
// end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawOverflowPanelItems;
|
|
var
|
|
I: Integer;
|
|
AGroup: TdxNavBarGroup;
|
|
R: TRect;
|
|
begin
|
|
for I := 0 to ViewInfo.OverflowPanelVisibleItemCount - 1 do
|
|
begin
|
|
R := ViewInfo.OverflowPanelItems[I].SelectionRect;
|
|
DrawOverflowPanelItemBackground(Canvas, dxNavBarPart(nbOverflowPanelItem, I), R);
|
|
|
|
R := ViewInfo.OverflowPanelItems[I].Rect;
|
|
AGroup := ViewInfo.OverflowPanelItems[I].Group;
|
|
if ImagePainterClass.IsValidImage(ViewInfo.FOverflowPanelViewInfo.GetImageList, ViewInfo.FOverflowPanelViewInfo.GetImageIndex(AGroup)) then
|
|
ImagePainterClass.DrawImage(Canvas, ViewInfo.FOverflowPanelViewInfo.GetImageList, ViewInfo.FOverflowPanelViewInfo.GetImageIndex(AGroup), R)
|
|
else
|
|
if NavBar.NavigationPaneOverflowPanelUseSmallImages then
|
|
Canvas.Draw(R.Left, R.Top, dxOffice11NavPaneDefaultSmallBitmap)
|
|
else
|
|
Canvas.Draw(R.Left, R.Top, dxOffice11NavPaneDefaultLargeBitmap);
|
|
// if ViewInfo.OverflowPanelItemIAccessibilityHelpers[I].IsFocused then
|
|
// begin
|
|
// InflateRect(R, 1, 1);
|
|
// DrawSolidFocusRect(R, clBlack);
|
|
// end;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawOverflowPanelHintWindow(ACanvas: TCanvas; const ARect: TRect);
|
|
var
|
|
AHandled: Boolean;
|
|
AGroup: TdxNavBarGroup;
|
|
begin
|
|
AHandled := False;
|
|
if Assigned(NavBar.OnCustomDrawNavigationPaneOverflowPanelHint) then
|
|
begin
|
|
if Controller.IsOverflowPanelGroupHotTracked then
|
|
AGroup := ViewInfo.OverflowPanelItems[Controller.HotPart.MinorPartIndex].Group
|
|
else
|
|
AGroup := nil;
|
|
NavBar.OnCustomDrawNavigationPaneOverflowPanelHint(NavBar, ACanvas, AGroup,
|
|
NavBar.ViewInfo.HintText, ARect, AHandled);
|
|
end;
|
|
if not AHandled then
|
|
with ViewInfo do
|
|
TdxNavBarCustomHintPainter.DrawHint(ACanvas, ARect,
|
|
ViewInfo.HintText, HintImage, HintBackColor, HintBackColor2,
|
|
HintAlphaBlend, HintAlphaBlend2, HintGradientMode, HintFont);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawPopupControl(ACanvas: TcxCanvas; AViewInfo: TdxNavBarPopupControlViewInfo);
|
|
begin
|
|
ACanvas.FrameRect(AViewInfo.FRect, ViewInfo.BorderColor);
|
|
ACanvas.SaveClipRegion;
|
|
try
|
|
ACanvas.ExcludeClipRect(AViewInfo.ClientRect);
|
|
ACanvas.FillRect(cxRectInflate(AViewInfo.FRect, -1, -1), $EEC6A9);
|
|
finally
|
|
ACanvas.RestoreClipRegion;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawSplitter;
|
|
var
|
|
AHandled: Boolean;
|
|
begin
|
|
if not ViewInfo.IsSplitterVisible then Exit;
|
|
AHandled := False;
|
|
if Assigned(NavBar.OnCustomDrawNavigationPaneSplitter) then
|
|
NavBar.OnCustomDrawNavigationPaneSplitter(NavBar, Canvas, ViewInfo, AHandled);
|
|
if not AHandled then
|
|
DoDrawSplitter;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawSplitterSign;
|
|
var
|
|
APoint: TPoint;
|
|
begin
|
|
if dxOffice11NavPaneSplitterBitmap <> nil then
|
|
begin
|
|
APoint := cxRectCenter(ViewInfo.SplitterRect, dxOffice11NavPaneSplitterBitmap.Width, dxOffice11NavPaneSplitterBitmap.Height).TopLeft;
|
|
if APoint.X > ViewInfo.OverflowPanelRect.Left then
|
|
Canvas.Draw(APoint.X, APoint.Y, dxOffice11NavPaneSplitterBitmap);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawPopupMenuItem(ACanvas: TCanvas; ARect: TRect; AImageList: TCustomImageList;
|
|
AImageIndex: Integer; AText: string; State: TdxNavBarObjectStates);
|
|
var
|
|
R: TRect;
|
|
begin
|
|
BackgroundPainterClass.DrawBackground(ACanvas, ARect, nil, False, clNone,
|
|
clMenu, clMenu, 255, 255, gmVertical);
|
|
R := ARect;
|
|
R.Right := R.Left + 2 * ViewInfo.FOverflowPanelViewInfo.GetPopupMenuImageIndent + ViewInfo.GetSmallImageWidth;
|
|
BackgroundPainterClass.DrawBackground(ACanvas, R, nil, False, clNone, dxOffice11NavPaneGroupCaptionColor1,
|
|
dxOffice11NavPaneGroupCaptionColor2, 255, 255, gmHorizontal);
|
|
|
|
if AText <> '-' then
|
|
begin
|
|
InflateRect(R, -1, -1);
|
|
if sSelected in State then
|
|
begin
|
|
ButtonPainterClass.DrawButton(ACanvas, ARect, nil, dxOffice11NavPaneGroupCaptionHotColor1,
|
|
dxOffice11NavPaneGroupCaptionHotColor2, 255, 255, gmVertical, dxOffice11NavPaneBorder, []);
|
|
if sActive in State then
|
|
ButtonPainterClass.DrawButton(ACanvas, R, nil, dxOffice11NavPaneGroupCaptionPressedColor1,
|
|
dxOffice11NavPaneGroupCaptionPressedColor2, 255, 255, gmVertical, dxOffice11NavPaneBorder, []);
|
|
end
|
|
else if sActive in State then
|
|
ButtonPainterClass.DrawButton(ACanvas, R, nil, dxOffice11NavPaneGroupCaptionHotColor1,
|
|
dxOffice11NavPaneGroupCaptionHotColor1, 255, 255, gmVertical, dxOffice11NavPaneBorder, []);
|
|
|
|
InflateRect(R, 1 - ViewInfo.FOverflowPanelViewInfo.GetPopupMenuImageIndent, 1 - ViewInfo.FOverflowPanelViewInfo.GetPopupMenuImageIndent);
|
|
AImageList.Draw(ACanvas, R.Left, R.Top, AImageIndex, not (sDisabled in State));
|
|
|
|
R := ARect;
|
|
R.Left := R.Left + 2 * ViewInfo.FOverflowPanelViewInfo.GetPopupMenuImageIndent + ViewInfo.GetSmallImageWidth + ViewInfo.FOverflowPanelViewInfo.GetPopupMenuTextIndent;
|
|
if sDisabled in State then
|
|
ACanvas.Font.Color := clGrayText
|
|
else ACanvas.Font.Color := clMenuText;
|
|
ACanvas.Brush.Style := bsClear;
|
|
cxDrawText(ACanvas.Handle, AText, R, DT_LEFT or DT_VCENTER or DT_SINGLELINE);
|
|
end
|
|
else
|
|
begin
|
|
ACanvas.Pen.Color := Dark(dxOffice11NavPaneGroupCaptionColor2, 80);
|
|
ACanvas.MoveTo(R.Right + cxRectWidth(R) div 2, R.Top + cxRectHeight(ARect) div 2);
|
|
ACanvas.LineTo(ARect.Right, R.Top + cxRectHeight(ARect) div 2);
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPanePainter.CreatePopupControlViewInfo: TdxNavBarPopupControlViewInfo;
|
|
begin
|
|
Result := GetPopupControlViewInfoClass.Create(NavBar.ViewInfo);
|
|
end;
|
|
|
|
class function TdxNavBarNavigationPanePainter.ButtonPainterClass: TdxNavBarCustomButtonPainterClass;
|
|
begin
|
|
Result := TdxNavBarNavigationPaneButtonPainter;
|
|
end;
|
|
|
|
class function TdxNavBarNavigationPanePainter.GetViewInfoClass: TdxNavBarViewInfoClass;
|
|
begin
|
|
Result := TdxNavBarNavigationPaneViewInfo;
|
|
end;
|
|
|
|
class function TdxNavBarNavigationPanePainter.GetGroupViewInfoClass: TdxNavBarGroupViewInfoClass;
|
|
begin
|
|
Result := TdxNavBarNavigationPaneGroupViewInfo;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPanePainter.GetControllerClass: TdxNavBarControllerClass;
|
|
begin
|
|
if TdxCustomNavBarAccess(NavBar).IsInternal then
|
|
Result := TdxNavBarPopupInnerControlController
|
|
else
|
|
Result := TdxNavBarNavigationPaneController;
|
|
end;
|
|
|
|
class function TdxNavBarNavigationPanePainter.GetPopupControlViewInfoClass: TdxNavBarPopupControlViewInfoClass;
|
|
begin
|
|
Result := TdxNavBarPopupControlViewInfo;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPanePainter.GetNavPanePartState(const APart: TdxNavBarPart): TdxNavBarNavPanePartState;
|
|
begin
|
|
Result := Controller.GetNavPanePartState(APart);
|
|
if (Result = oisNormal) and ViewInfo.NavPanePartIAccessibilityHelpers[APart].IsPressed then
|
|
Result := oisPressed;
|
|
if (Result = oisNormal) and
|
|
(APart.MajorPartIndex in [nbOverflowPanelSign, nbOverflowPanelItem, nbHeaderSign]) and
|
|
ViewInfo.NavPanePartIAccessibilityHelpers[APart].IsFocused then
|
|
Result := oisHot;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DoDrawHeader;
|
|
begin
|
|
DrawHeaderBackground;
|
|
if not Controller.Collapsed then
|
|
DrawHeaderText;
|
|
if Controller.Collapsible then
|
|
DrawHeaderSign;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DoDrawOverflowPanel;
|
|
begin
|
|
DrawOverflowPanelBackground;
|
|
DrawOverflowPanelSign;
|
|
DrawOverflowPanelItems;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DoDrawSplitter;
|
|
var
|
|
R: TRect;
|
|
begin
|
|
with ViewInfo do
|
|
begin
|
|
Canvas.Brush.Color := clWhite;
|
|
R := SplitterRect;
|
|
Canvas.FillRect(Rect(R.Left, R.Top, R.Right, R.Top + 1));
|
|
Inc(R.Top);
|
|
BackgroundPainterClass.DrawBackground(Canvas, R, nil, False, clNone,
|
|
SplitterBackColor, SplitterBackColor2, SplitterAlphaBlend, SplitterAlphaBlend2,
|
|
SplitterGradientMode);
|
|
end;
|
|
DrawSplitterSign;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPanePainter.GetViewInfo: TdxNavBarNavigationPaneViewInfo;
|
|
begin
|
|
if inherited ViewInfo is TdxNavBarNavigationPaneViewInfo then
|
|
Result := inherited ViewInfo as TdxNavBarNavigationPaneViewInfo
|
|
else Result := nil;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPanePainter.GetController: TdxNavBarNavigationPaneController;
|
|
begin
|
|
Result := TdxNavBarNavigationPaneController(inherited Controller);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPanePainter.GetOverflowPanelViewInfo: TdxNavBarOverflowPanelViewInfo;
|
|
begin
|
|
Result := ViewInfo.FOverflowPanelViewInfo;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawItemPanelPartFocusRect(
|
|
const APartRect: TRect);
|
|
begin
|
|
DrawSolidFocusRect(cxRectInflate(APartRect, -1, -0, -1, -1),
|
|
ViewInfo.HeaderFontColor);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawVertivalText(AFont: TFont; const AText: string; const ARect: TRect; AState: TdxNavBarNavPanePartState);
|
|
var
|
|
ACanvas: TcxCanvas;
|
|
ADrawRect, ABackgroundRect: TRect;
|
|
ABitmap: TcxCustomBitmap;
|
|
begin
|
|
ADrawRect := cxGetTextRect(AFont, AText, 1);
|
|
ABitmap := TcxCustomBitmap.CreateSize(cxRectRotate(ADrawRect));
|
|
try
|
|
ACanvas := ABitmap.cxCanvas;
|
|
|
|
ABackgroundRect := cxRectCenter(ARect, ABitmap.Width, ABitmap.Height);
|
|
ACanvas.CopyRect(cxRectRotate(ADrawRect), Canvas, ABackgroundRect);
|
|
|
|
ABitmap.Rotate(raMinus90);
|
|
ACanvas.Brush.Style := bsClear;
|
|
ACanvas.Font := AFont;
|
|
|
|
ACanvas.Font.Color := ViewInfo.CollapseBarFontColor;
|
|
{
|
|
if AState = oisNormal then
|
|
ACanvas.Font.Color := ViewInfo.BorderColor
|
|
else
|
|
ACanvas.Font.Color := ViewInfo.HeaderFontColor;
|
|
}
|
|
cxDrawText(ACanvas.Handle, AText, ADrawRect, DT_CENTER or DT_VCENTER or DT_SINGLELINE);
|
|
ABitmap.Rotate(raPlus90);
|
|
|
|
cxCanvas.SaveClipRegion;
|
|
try
|
|
cxCanvas.SetClipRegion(TcxRegion.Create(ARect), roIntersect);
|
|
with ABackgroundRect.TopLeft do
|
|
Canvas.Draw(X, Y, ABitmap);
|
|
finally
|
|
cxCanvas.RestoreClipRegion;
|
|
end;
|
|
finally
|
|
ABitmap.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawOverflowPanelItemBackground(ACanvas: TCanvas; AState: TdxNavBarNavPanePartState; const ARect: TRect);
|
|
var
|
|
AColor1, AColor2: TColor;
|
|
begin
|
|
case AState of
|
|
oisPressed, oisHotCheck, oisDroppedDown:
|
|
begin
|
|
AColor1 := dxOffice11NavPaneGroupCaptionPressedHotColor1;
|
|
AColor2 := dxOffice11NavPaneGroupCaptionPressedHotColor2;
|
|
end;
|
|
oisChecked:
|
|
begin
|
|
AColor1 := dxOffice11NavPaneGroupCaptionPressedColor1;
|
|
AColor2 := dxOffice11NavPaneGroupCaptionPressedColor2;
|
|
end;
|
|
oisHot:
|
|
begin
|
|
AColor1 := dxOffice11NavPaneGroupCaptionHotColor1;
|
|
AColor2 := dxOffice11NavPaneGroupCaptionHotColor2;
|
|
end;
|
|
else {oisNormal}
|
|
AColor1 := clNone;
|
|
AColor2 := clNone;
|
|
end;
|
|
|
|
if (AColor1 <> clNone) and (AColor2 <> clNone) then
|
|
BackgroundPainterClass.DrawBackground(ACanvas, ARect, nil, False, clNone,
|
|
AColor1, AColor2, 255, 255, gmVertical);
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPanePainter.DrawOverflowPanelItemBackground(ACanvas: TCanvas; const APart: TdxNavBarPart; const ARect: TRect);
|
|
begin
|
|
DrawOverflowPanelItemBackground(ACanvas, GetNavPanePartState(APart), ARect);
|
|
end;
|
|
|
|
{ TdxNavBarNavigationPaneButtonPainter }
|
|
|
|
class procedure TdxNavBarNavigationPaneButtonPainter.InternalDrawButton(ACanvas: TCanvas; ARect: TRect; APicture: TPicture;
|
|
AColor1, AColor2: TColor; AAlphaBlend1, AAlphaBlend2: Byte;
|
|
AGradientMode: TdxBarStyleGradientMode; ABorderColor: TColor;
|
|
AState: TdxNavBarObjectStates);
|
|
begin
|
|
inherited;
|
|
ACanvas.Brush.Style := bsClear;
|
|
ACanvas.Pen.Color := ColorToRGB(ABorderColor);
|
|
ACanvas.Pen.Style := psSolid;
|
|
ACanvas.Pen.Width := 1;
|
|
ACanvas.Rectangle(ARect.Left, ARect.Top, ARect.Right, ARect.Bottom);
|
|
end;
|
|
|
|
{ TdxNavBarOffice11NavPanePainter }
|
|
|
|
class function TdxNavBarOffice11NavPanePainter.GetGroupViewInfoClass: TdxNavBarGroupViewInfoClass;
|
|
begin
|
|
Result := TdxNavBarOffice11NavPaneGroupViewInfo;
|
|
end;
|
|
|
|
class function TdxNavBarOffice11NavPanePainter.GetViewInfoClass: TdxNavBarViewInfoClass;
|
|
begin
|
|
Result := TdxNavBarOffice11NavPaneViewInfo;
|
|
end;
|
|
|
|
class function TdxNavBarOffice11NavPanePainter.ButtonPainterClass: TdxNavBarCustomButtonPainterClass;
|
|
begin
|
|
Result := TdxNavBarOffice11NavPaneButtonPainter;
|
|
end;
|
|
|
|
{ TdxNavBarOffice11NavPaneGroupButtonPainter }
|
|
|
|
class procedure TdxNavBarOffice11NavPaneGroupButtonPainter.InternalDrawButton(ACanvas: TCanvas; ARect: TRect;
|
|
APicture: TPicture; AColor1, AColor2: TColor; AAlphaBlend1, AAlphaBlend2: Byte;
|
|
AGradientMode: TdxBarStyleGradientMode; ABorderColor: TColor; AState: TdxNavBarObjectStates);
|
|
var
|
|
ABackgroundRect: TRect;
|
|
begin
|
|
ABackgroundRect := ARect;
|
|
Inc(ABackgroundRect.Top);
|
|
inherited InternalDrawButton(ACanvas, ABackgroundRect, APicture, AColor1, AColor2,
|
|
AAlphaBlend1, AAlphaBlend2, AGradientMode, ABorderColor, AState);
|
|
ACanvas.Pen.Color := ColorToRGB(ABorderColor);
|
|
ACanvas.Pen.Style := psSolid;
|
|
ACanvas.Pen.Width := 1;
|
|
ACanvas.MoveTo(ARect.Left, ARect.Top);
|
|
ACanvas.LineTo(ARect.Right, ARect.Top);
|
|
end;
|
|
|
|
{ TdxNavBarOffice11SignPainter }
|
|
|
|
class procedure TdxNavBarOffice11SignPainter.PrepareBitmap(ACanvas: TCanvas;
|
|
ABitmap: TBitmap; ABackColor1, ABackColor2: TColor; AState: TdxNavBarObjectStates);
|
|
var
|
|
ABitmapColors: TRGBColors;
|
|
ATransparentColor, APixelColor: COLORREF;
|
|
AMinValue, AMaxValue, AValue: Byte;
|
|
I, J: Integer;
|
|
begin
|
|
if sExpanded in AState then
|
|
ABitmap.Assign(dxOffice11CaptionCollapseSignBitmap)
|
|
else
|
|
ABitmap.Assign(dxOffice11CaptionExpandSignBitmap);
|
|
|
|
ABitmapColors := GetBitmapBits(ABitmap, True);
|
|
|
|
RGBQuadToColorRef(ABitmapColors[0], ATransparentColor);
|
|
|
|
AMaxValue := 1;
|
|
AMinValue := 255;
|
|
for I := 0 to ABitmap.Width - 1 do
|
|
for J := 0 to ABitmap.Height - 1 do
|
|
begin
|
|
RGBQuadToColorRef(ABitmapColors[J * ABitmap.Width + I], APixelColor);
|
|
if (APixelColor <> ATransparentColor) and (APixelColor <> 0{mark}) then
|
|
begin
|
|
AValue := GetRValue(APixelColor);
|
|
AMaxValue := Max(AMaxValue, AValue);
|
|
AMinValue := Min(AMinValue, AValue);
|
|
end;
|
|
end;
|
|
|
|
for I := 0 to ABitmap.Width - 1 do
|
|
for J := 0 to ABitmap.Height - 1 do
|
|
begin
|
|
RGBQuadToColorRef(ABitmapColors[J * ABitmap.Width + I], APixelColor);
|
|
if (APixelColor <> ATransparentColor) and (APixelColor <> 0{mark}) then
|
|
begin
|
|
AValue := GetRValue(APixelColor);
|
|
APixelColor := GetMiddleRGB(ColorToRGB(ABackColor1), ColorToRGB(ABackColor2),
|
|
MulDiv(AValue - AMinValue, 100, AMaxValue - AMinValue));
|
|
ColorRefToRGBQuad(APixelColor, ABitmapColors[J * ABitmap.Width + I]);
|
|
end;
|
|
end;
|
|
|
|
SetBitmapBits(ABitmap, ABitmapColors, True);
|
|
ABitmap.Transparent := True;
|
|
end;
|
|
|
|
class procedure TdxNavBarOffice11SignPainter.InternalDrawSign(ACanvas: TCanvas; ARect: TRect;
|
|
AForeColor, ABackColor1, ABackColor2: TColor; AState: TdxNavBarObjectStates);
|
|
var
|
|
ABitmap: TBitmap;
|
|
begin
|
|
ABitmap := TBitmap.Create;
|
|
try
|
|
PrepareBitmap(ACanvas, ABitmap, ABackColor1, ABackColor2, AState);
|
|
ACanvas.Draw(ARect.Left, ARect.Top, ABitmap);
|
|
finally
|
|
ABitmap.Free;
|
|
end;
|
|
end;
|
|
|
|
{ TdxNavBarItemCollectionAccessibilityHelper }
|
|
|
|
constructor TdxNavBarItemCollectionAccessibilityHelper.Create(
|
|
AOwnerObject: TObject; AOwnerObjectControl: TWinControl);
|
|
begin
|
|
inherited Create(AOwnerObject, AOwnerObjectControl);
|
|
FItemIAccessibilityHelpers := TInterfaceList.Create;
|
|
end;
|
|
|
|
destructor TdxNavBarItemCollectionAccessibilityHelper.Destroy;
|
|
begin
|
|
SetItemIAccessibilityHelperCount(0);
|
|
FreeAndNil(FItemIAccessibilityHelpers);
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TdxNavBarItemCollectionAccessibilityHelper.CheckItemIAccessibilityHelperCount;
|
|
begin
|
|
SetItemIAccessibilityHelperCount(GetActualItemCount);
|
|
end;
|
|
|
|
function TdxNavBarItemCollectionAccessibilityHelper.GetChild(
|
|
AIndex: Integer): TcxAccessibilityHelper;
|
|
begin
|
|
if AIndex < inherited GetChildCount then
|
|
Result := inherited GetChild(AIndex)
|
|
else
|
|
begin
|
|
Dec(AIndex, inherited GetChildCount);
|
|
CheckItemIAccessibilityHelperCount;
|
|
Result := ItemIAccessibilityHelpers[AIndex].GetHelper;
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarItemCollectionAccessibilityHelper.GetChildCount: Integer;
|
|
begin
|
|
Result := inherited GetChildCount;
|
|
CheckItemIAccessibilityHelperCount;
|
|
Inc(Result, ItemIAccessibilityHelperCount);
|
|
end;
|
|
|
|
function TdxNavBarItemCollectionAccessibilityHelper.IsContainer: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TdxNavBarItemCollectionAccessibilityHelper.GetItemIAccessibilityHelper(
|
|
AIndex: Integer): IdxNavBarAccessibilityHelper;
|
|
begin
|
|
CheckItemIAccessibilityHelperCount;
|
|
Result := FItemIAccessibilityHelpers[AIndex] as IdxNavBarAccessibilityHelper;
|
|
end;
|
|
|
|
function TdxNavBarItemCollectionAccessibilityHelper.GetItemIAccessibilityHelperCount: Integer;
|
|
begin
|
|
CheckItemIAccessibilityHelperCount;
|
|
Result := FItemIAccessibilityHelpers.Count;
|
|
end;
|
|
|
|
procedure TdxNavBarItemCollectionAccessibilityHelper.SetItemIAccessibilityHelperCount(
|
|
Value: Integer);
|
|
var
|
|
AIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
I: Integer;
|
|
begin
|
|
if FItemIAccessibilityHelpers.Count <> Value then
|
|
if FItemIAccessibilityHelpers.Count < Value then
|
|
for I := 1 to Value - FItemIAccessibilityHelpers.Count do
|
|
begin
|
|
AIAccessibilityHelper := NavBarGetAccessibilityHelper(GetItemAccessibilityHelperClass.Create(Self,
|
|
OwnerObjectControl));
|
|
(AIAccessibilityHelper.GetHelper as TdxNavBarItemCollectionItemAccessibilityHelper).ItemIndex :=
|
|
FItemIAccessibilityHelpers.Count;
|
|
FItemIAccessibilityHelpers.Add(AIAccessibilityHelper);
|
|
end
|
|
else
|
|
for I := FItemIAccessibilityHelpers.Count - 1 downto Value do
|
|
begin
|
|
AIAccessibilityHelper := FItemIAccessibilityHelpers[I] as IdxNavBarAccessibilityHelper;
|
|
NavBarAccessibleObjectOwnerObjectDestroyed(AIAccessibilityHelper);
|
|
FItemIAccessibilityHelpers.Delete(I);
|
|
end;
|
|
end;
|
|
|
|
{ TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper }
|
|
|
|
destructor TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper.Destroy;
|
|
begin
|
|
NavBarAccessibleObjectOwnerObjectDestroyed(FSignIAccessibilityHelper);
|
|
inherited Destroy;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper.GetChild(
|
|
AIndex: Integer): TcxAccessibilityHelper;
|
|
begin
|
|
if AIndex < inherited GetChildCount then
|
|
Result := inherited GetChild(AIndex)
|
|
else
|
|
Result := SignIAccessibilityHelper.GetHelper;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper.GetChildCount: Integer;
|
|
begin
|
|
Result := inherited GetChildCount + 1;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper.GetParent: TcxAccessibilityHelper;
|
|
begin
|
|
Result := ViewInfo.NavBar.IAccessibilityHelper.GetHelper;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper.GetState(
|
|
AChildID: TcxAccessibleSimpleChildElementID): Integer;
|
|
begin
|
|
Result := Parent.States[cxAccessibleObjectSelfID];
|
|
if not ViewInfo.IsVisible then
|
|
Result := Result or cxSTATE_SYSTEM_INVISIBLE;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper.GetActualItemCount: Integer;
|
|
begin
|
|
Result := ViewInfo.ItemCount;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper.GetBounds: TRect;
|
|
begin
|
|
Result := ViewInfo.FRect;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper.GetItemAccessibilityHelperClass: TdxNavBarItemCollectionItemAccessibilityHelperClass;
|
|
begin
|
|
Result := TdxNavBarNavigationPaneOverflowPanelItemAccessibilityHelper;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper.GetSignAccessibilityHelperClass: TdxNavBarCustomAccessibilityHelperClass;
|
|
begin
|
|
Result := TdxNavBarNavigationPaneOverflowPanelSignAccessibilityHelper;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper.GetSignIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
begin
|
|
if FSignIAccessibilityHelper = nil then
|
|
FSignIAccessibilityHelper := NavBarGetAccessibilityHelper(
|
|
GetSignAccessibilityHelperClass.Create(Self, OwnerObjectControl));
|
|
Result := FSignIAccessibilityHelper;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper.GetViewInfo: TdxNavBarOverflowPanelViewInfo;
|
|
begin
|
|
Result := TdxNavBarOverflowPanelViewInfo(FOwnerObject);
|
|
end;
|
|
|
|
{ TdxNavBarNavigationPaneOverflowPanelItemAccessibilityHelper }
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelItemAccessibilityHelper.GetParent: TcxAccessibilityHelper;
|
|
begin
|
|
Result := TcxAccessibilityHelper(FOwnerObject);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelItemAccessibilityHelper.GetState(
|
|
AChildID: TcxAccessibleSimpleChildElementID): Integer;
|
|
begin
|
|
Result := Parent.States[cxAccessibleObjectSelfID];
|
|
if ItemIndex >= ViewInfo.OverflowPanelVisibleItemCount then
|
|
Result := Result or cxSTATE_SYSTEM_INVISIBLE;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneOverflowPanelItemAccessibilityHelper.Click(
|
|
AKey: Word);
|
|
begin
|
|
inherited Click(AKey);
|
|
TdxCustomNavBarAccess(OwnerObjectControl).DoGroupMouseUp(Group);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelItemAccessibilityHelper.GetBounds: TRect;
|
|
begin
|
|
Result := ViewInfo.OverflowPanelItems[ItemIndex].SelectionRect;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelItemAccessibilityHelper.IsClickKey(
|
|
AKey: Word): Boolean;
|
|
begin
|
|
Result := inherited IsClickKey(AKey) or (AKey in [VK_RETURN, VK_SPACE]);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelItemAccessibilityHelper.IsContainer: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelItemAccessibilityHelper.GetGroup: TdxNavBarGroup;
|
|
begin
|
|
Result := ViewInfo.OverflowPanelItems[ItemIndex].Group;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelItemAccessibilityHelper.GetViewInfo: TdxNavBarNavigationPaneViewInfo;
|
|
begin
|
|
Result := TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper(FOwnerObject).ViewInfo.ViewInfo;
|
|
end;
|
|
|
|
{ TdxNavBarNavigationPaneOverflowPanelSignAccessibilityHelper }
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelSignAccessibilityHelper.GetParent: TcxAccessibilityHelper;
|
|
begin
|
|
Result := TcxAccessibilityHelper(FOwnerObject);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelSignAccessibilityHelper.GetState(
|
|
AChildID: TcxAccessibleSimpleChildElementID): Integer;
|
|
begin
|
|
Result := Parent.States[cxAccessibleObjectSelfID];
|
|
end;
|
|
|
|
// IdxNavBarAccessibilityHelper
|
|
procedure TdxNavBarNavigationPaneOverflowPanelSignAccessibilityHelper.Click(
|
|
AKey: Word);
|
|
begin
|
|
inherited Click(AKey);
|
|
ViewInfo.DoShowPopupMenu(cxRectCenter(GetScreenBounds(cxAccessibleObjectSelfID)));
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelSignAccessibilityHelper.GetBounds: TRect;
|
|
begin
|
|
Result := ViewInfo.OverflowPanelSignRect;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelSignAccessibilityHelper.IsClickKey(
|
|
AKey: Word): Boolean;
|
|
begin
|
|
Result := inherited IsClickKey(AKey) or (AKey in [VK_RETURN, VK_SPACE]);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelSignAccessibilityHelper.IsContainer: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneOverflowPanelSignAccessibilityHelper.GetViewInfo: TdxNavBarNavigationPaneViewInfo;
|
|
begin
|
|
Result := TdxNavBarNavigationPaneOverflowPanelAccessibilityHelper(FOwnerObject).ViewInfo.ViewInfo;
|
|
end;
|
|
|
|
{ TdxNavBarNavigationPaneActiveGroupCaptionPanelAccessibilityHelper }
|
|
|
|
function TdxNavBarNavigationPaneActiveGroupCaptionPanelAccessibilityHelper.GetParent: TcxAccessibilityHelper;
|
|
begin
|
|
Result := NavBar.IAccessibilityHelper.GetHelper;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneActiveGroupCaptionPanelAccessibilityHelper.GetState(
|
|
AChildID: TcxAccessibleSimpleChildElementID): Integer;
|
|
begin
|
|
Result := Parent.States[cxAccessibleObjectSelfID];
|
|
if (NavBar.ActiveGroup = nil) or not NavBar.ActiveGroup.Visible or
|
|
not NavBar.ShowGroupCaptions or (GroupViewInfo = nil) then
|
|
Result := Result or cxSTATE_SYSTEM_INVISIBLE or cxSTATE_SYSTEM_UNAVAILABLE;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneActiveGroupCaptionPanelAccessibilityHelper.CanBeFocusedByDefault: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneActiveGroupCaptionPanelAccessibilityHelper.GetAssociatedObject: TdxNavBarCustomAccessibilityHelper;
|
|
begin
|
|
if Visible then
|
|
Result := NavBar.ActiveGroup.CaptionPanelIAccessibilityHelper.GetNavBarHelper
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneActiveGroupCaptionPanelAccessibilityHelper.GetBounds: TRect;
|
|
begin
|
|
Result := GroupViewInfo.Rect;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneActiveGroupCaptionPanelAccessibilityHelper.IsContainer: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneActiveGroupCaptionPanelAccessibilityHelper.GetGroupViewInfo: TdxNavBarGroupViewInfo;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
// Requires
|
|
Assert(NavBar.ActiveGroup <> nil);
|
|
//
|
|
Result := nil;
|
|
for I := NavBarViewInfo.GetRealGroupStartIndex to NavBarViewInfo.GroupCount - 1 do
|
|
if NavBar.ViewInfo.Groups[I].Group = NavBar.ActiveGroup then
|
|
begin
|
|
Result := NavBar.ViewInfo.Groups[I];
|
|
Break;
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneActiveGroupCaptionPanelAccessibilityHelper.GetNavBar: TdxCustomNavBar;
|
|
begin
|
|
Result := TdxNavBarOffice11NavPaneViewInfo(FOwnerObject).NavBar;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneActiveGroupCaptionPanelAccessibilityHelper.GetNavBarViewInfo: TdxNavBarNavigationPaneViewInfo;
|
|
begin
|
|
Result := TdxNavBarNavigationPaneViewInfo(NavBar.ViewInfo);
|
|
end;
|
|
|
|
{ TdxNavBarNavigationPaneHeaderSignAccessibilityHelper }
|
|
|
|
function TdxNavBarNavigationPaneHeaderSignAccessibilityHelper.GetParent: TcxAccessibilityHelper;
|
|
begin
|
|
Result := TdxCustomNavBar(OwnerObjectControl).IAccessibilityHelper.GetHelper;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneHeaderSignAccessibilityHelper.GetState(
|
|
AChildID: TcxAccessibleSimpleChildElementID): Integer;
|
|
begin
|
|
Result := Parent.States[cxAccessibleObjectSelfID];
|
|
if not ViewInfo.Painter.Controller.Collapsible then
|
|
Result := Result or cxSTATE_SYSTEM_INVISIBLE or cxSTATE_SYSTEM_UNAVAILABLE;
|
|
end;
|
|
|
|
procedure TdxNavBarNavigationPaneHeaderSignAccessibilityHelper.Click(AKey: Word);
|
|
begin
|
|
inherited Click(AKey);
|
|
ViewInfo.Painter.Controller.DoHeaderSignClick;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneHeaderSignAccessibilityHelper.GetBounds: TRect;
|
|
begin
|
|
Result := ViewInfo.HeaderSignRect;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneHeaderSignAccessibilityHelper.IsClickKey(
|
|
AKey: Word): Boolean;
|
|
begin
|
|
Result := inherited IsClickKey(AKey) or (AKey in [VK_RETURN, VK_SPACE]);
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneHeaderSignAccessibilityHelper.IsContainer: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxNavBarNavigationPaneHeaderSignAccessibilityHelper.GetViewInfo: TdxNavBarNavigationPaneViewInfo;
|
|
begin
|
|
Result := TdxNavBarNavigationPaneViewInfo(FOwnerObject);
|
|
end;
|
|
|
|
{ TdxNavBarItemPanelAccessibilityHelper }
|
|
|
|
destructor TdxNavBarItemPanelAccessibilityHelper.Destroy;
|
|
begin
|
|
NavBarAccessibleObjectOwnerObjectDestroyed(FCollapseBarIAccessibilityHelper);
|
|
inherited Destroy;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelAccessibilityHelper.GetChild(
|
|
AIndex: Integer): TcxAccessibilityHelper;
|
|
begin
|
|
if AIndex < inherited GetChildCount then
|
|
Result := inherited GetChild(AIndex)
|
|
else
|
|
Result := CollapseBarIAccessibilityHelper.GetHelper;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelAccessibilityHelper.GetChildCount: Integer;
|
|
begin
|
|
Result := inherited GetChildCount + 1;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelAccessibilityHelper.GetParent: TcxAccessibilityHelper;
|
|
begin
|
|
Result := ViewInfo.NavBar.IAccessibilityHelper.GetHelper;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelAccessibilityHelper.GetState(
|
|
AChildID: TcxAccessibleSimpleChildElementID): Integer;
|
|
begin
|
|
Result := Parent.States[cxAccessibleObjectSelfID];
|
|
if not ViewInfo.Painter.Controller.Collapsed then
|
|
Result := Result or cxSTATE_SYSTEM_INVISIBLE;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelAccessibilityHelper.GetActualItemCount: Integer;
|
|
begin
|
|
Result := ViewInfo.ItemCount;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelAccessibilityHelper.GetBounds: TRect;
|
|
begin
|
|
Result := ViewInfo.Rect;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelAccessibilityHelper.GetCollapseBarAccessibilityHelperClass: TdxNavBarCustomAccessibilityHelperClass;
|
|
begin
|
|
Result := TdxNavBarItemPanelCollapseBarAccessibilityHelper;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelAccessibilityHelper.GetItemAccessibilityHelperClass: TdxNavBarItemCollectionItemAccessibilityHelperClass;
|
|
begin
|
|
Result := TdxNavBarItemPanelItemAccessibilityHelper;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelAccessibilityHelper.GetCollapseBarIAccessibilityHelper: IdxNavBarAccessibilityHelper;
|
|
begin
|
|
if FCollapseBarIAccessibilityHelper = nil then
|
|
FCollapseBarIAccessibilityHelper := NavBarGetAccessibilityHelper(
|
|
GetCollapseBarAccessibilityHelperClass.Create(Self, OwnerObjectControl));
|
|
Result := FCollapseBarIAccessibilityHelper;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelAccessibilityHelper.GetViewInfo: TdxNavBarItemPanelViewInfo;
|
|
begin
|
|
Result := TdxNavBarItemPanelViewInfo(FOwnerObject);
|
|
end;
|
|
|
|
{ TdxNavBarItemPanelCollapseBarAccessibilityHelper }
|
|
|
|
function TdxNavBarItemPanelCollapseBarAccessibilityHelper.GetParent: TcxAccessibilityHelper;
|
|
begin
|
|
Result := TcxAccessibilityHelper(FOwnerObject);
|
|
end;
|
|
|
|
function TdxNavBarItemPanelCollapseBarAccessibilityHelper.GetState(
|
|
AChildID: TcxAccessibleSimpleChildElementID): Integer;
|
|
begin
|
|
Result := Parent.States[cxAccessibleObjectSelfID];
|
|
end;
|
|
|
|
function TdxNavBarItemPanelCollapseBarAccessibilityHelper.CanBeFocusedByDefault: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TdxNavBarItemPanelCollapseBarAccessibilityHelper.Click(AKey: Word);
|
|
begin
|
|
inherited Click(AKey);
|
|
ViewInfo.Painter.Controller.ShowPopupControl;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelCollapseBarAccessibilityHelper.GetBounds: TRect;
|
|
begin
|
|
Result := ViewInfo.CollapseBarRect;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelCollapseBarAccessibilityHelper.IsClickKey(
|
|
AKey: Word): Boolean;
|
|
begin
|
|
Result := inherited IsClickKey(AKey) or (AKey in [VK_RETURN, VK_SPACE]);
|
|
end;
|
|
|
|
function TdxNavBarItemPanelCollapseBarAccessibilityHelper.IsContainer: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelCollapseBarAccessibilityHelper.GetViewInfo: TdxNavBarItemPanelViewInfo;
|
|
begin
|
|
Result := TdxNavBarItemPanelAccessibilityHelper(FOwnerObject).ViewInfo;
|
|
end;
|
|
|
|
{ TdxNavBarItemPanelItemAccessibilityHelper }
|
|
|
|
function TdxNavBarItemPanelItemAccessibilityHelper.GetParent: TcxAccessibilityHelper;
|
|
begin
|
|
Result := TcxAccessibilityHelper(FOwnerObject);
|
|
end;
|
|
|
|
function TdxNavBarItemPanelItemAccessibilityHelper.GetState(
|
|
AChildID: TcxAccessibleSimpleChildElementID): Integer;
|
|
begin
|
|
Result := Parent.States[cxAccessibleObjectSelfID];
|
|
end;
|
|
|
|
function TdxNavBarItemPanelItemAccessibilityHelper.CanBeFocusedByDefault: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TdxNavBarItemPanelItemAccessibilityHelper.Click(AKey: Word);
|
|
begin
|
|
inherited Click(AKey);
|
|
TdxNavBarControllerAccess(ViewInfo.Painter.Controller).DoLinkClick(ViewInfo.NavBar,
|
|
ViewInfo.Items[ItemIndex].ItemLink);
|
|
end;
|
|
|
|
function TdxNavBarItemPanelItemAccessibilityHelper.GetBounds: TRect;
|
|
begin
|
|
Result := ViewInfo.Items[ItemIndex].Rect;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelItemAccessibilityHelper.IsClickKey(
|
|
AKey: Word): Boolean;
|
|
begin
|
|
Result := inherited IsClickKey(AKey) or (AKey in [VK_RETURN, VK_SPACE]);
|
|
end;
|
|
|
|
function TdxNavBarItemPanelItemAccessibilityHelper.IsContainer: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxNavBarItemPanelItemAccessibilityHelper.GetViewInfo: TdxNavBarItemPanelViewInfo;
|
|
begin
|
|
Result := TdxNavBarItemPanelAccessibilityHelper(FOwnerObject).ViewInfo;
|
|
end;
|
|
|
|
initialization
|
|
RegisterView(dxNavBarOffice11TaskPaneView, 'Office11TaskPaneView', TdxNavBarOffice11Painter);
|
|
RegisterView(dxNavBarOffice11ExplorerBarView, 'Office11ExplorerBarView', TdxNavBarOffice11ExplorerBarPainter);
|
|
RegisterView(dxNavBarOffice11NavigatorPaneView, 'Office11NavigationPaneView', TdxNavBarOffice11NavPanePainter);
|
|
|
|
finalization
|
|
UnRegisterView(dxNavBarOffice11TaskPaneView);
|
|
UnRegisterView(dxNavBarOffice11ExplorerBarView);
|
|
UnRegisterView(dxNavBarOffice11NavigatorPaneView);
|
|
|
|
end.
|