{*******************************************************************} { } { Developer Express Visual Component Library } { ExpressBars components } { } { Copyright (c) 1998-2007 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 EXPRESSBARS 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 dxBar; {$I cxVer.inc} interface uses SysUtils, TypInfo, Windows, Messages, Graphics, Controls, Forms, Classes, ImgList, ActnList, Menus, StdCtrls, dxCommon, dxThemeManager, cxLookAndFeels, cxLookAndFeelPainters, cxControls, cxContainer, IniFiles, cxClasses, cxGraphics, Contnrs, cxStyles, dxFading, cxAccessibility; (*$HPPEMIT '#define EMPTYSET System::Set () << 0'*) type TdxBarItemPosition = (ipBeginsNewRow, ipBeginsNewColumn, ipContinuesRow); TdxByteSet = set of Byte; TdxBarItemViewLevel = (ivlLargeIconWithText, ivlSmallIconWithText, ivlSmallIcon, ivlControlOnly, ivlDefault{D10 bug}); TdxBarItemRealViewLevel = ivlLargeIconWithText..ivlControlOnly; TdxBarItemViewLevels = set of TdxBarItemRealViewLevel; TdxBarButtonGroupPosition = (bgpNone, bgpStart, bgpMember); TdxBarButtonGroupRealPosition = (bgrpNone, bgrpStart, bgrpMember, bgrpFinish, bgrpSingle); TdxBarItemAlign = (iaLeft, iaCenter, iaRight, iaClient); TdxBarGlyphLayout = (glLeft, glRight, glTop, glBottom); TdxBarMenuItemSize = (misNormal, misLarge); TdxBarBehaviorOption = (bboAllowDetach, bboAllowSelectWindowItemsWithoutFocusing, bboAllowShowHints, bboClickItemsBySpaceKey, bboExtendItemWhenAlignedToClient, bboNeedsFocusWhenActive, bboMouseCantUnselectNavigationItem, bboUnmoved, bboItemCustomizePopup); TdxBarBehaviorOptions = set of TdxBarBehaviorOption; TdxBarItemViewLevelInfo = record Calculated: Boolean; Width: Integer; end; TdxBarItemStyleData = record AssignedValues: TcxStyleValues; Color: TColor; FontData: TFontData; TextColor: TColor; Style: TcxStyle; end; TdxBarMouseWheelEventReceiver = (mwrNone, mwrFocusedItemControl, mwrWindow); TdxBarMDIButton = (mdibMinimize, mdibRestore, mdibClose); TdxBarMDIButtons = set of TdxBarMDIButton; const WM_REPAINTBAR = WM_USER + 1; dxBarDefaultButtonArrowWidth = 11; dxBarDefaultLargeButtonArrowWidth = 13;//4; dxBarTransparentShadowSize = 4; dxBarOpaqueShadowSize = 2; dxBarItemAllViewLevels = [Low(TdxBarItemRealViewLevel)..High(TdxBarItemRealViewLevel)]; dxBarItemDefaultPosition = ipBeginsNewRow; MDIButtonCommands: array[TdxBarMDIButton] of Integer = (SC_MINIMIZE, SC_RESTORE, SC_CLOSE); type TCustomdxBarControl = class; TCustomdxBarControlClass = class of TCustomdxBarControl; TCustomdxBarControlDesignHelper = class; TCustomdxBarControlDesignHelperClass = class of TCustomdxBarControlDesignHelper; TCustomdxBarControlViewInfo = class; TCustomdxBarControlViewInfoClass = class of TCustomdxBarControlViewInfo; TCustomdxBarSubItem = class; TdxBar = class; TdxBarAccessibilityHelper = class; TdxBarApplicationMenu = class; TdxBarButton = class; TdxBarApplicationMenuButtonItem = class; TdxBarButtonLikeControl = class; TdxBarCaptionButtons = class; TdxBarComponentList = class; TdxBarControl = class; TdxBarControlClass = class of TdxBarControl; TdxBarCustomizingPopup = class; TdxBarCustomEditControl = class; TdxBarCustomStaticControl = class; TdxBarDockControl = class; TdxBarEditControl = class; TdxBarItem = class; TdxBarItemClass = class of TdxBarItem; TdxBarItemControl = class; TdxBarItemControlClass = class of TdxBarItemControl; TdxBarItemControlViewInfo = class; TdxBarItemLink = class; TdxBarItemLinks = class; TdxBarItemLinksClass = class of TdxBarItemLinks; TdxBarManager = class; TdxBarPainter = class; TdxBarPainterClass = class of TdxBarPainter; TdxBarPopupMenu = class; TdxBarPopupMenuLink = class; TdxBarQuickControl = class; TdxBarExtraPaneListItem = class; TdxBars = class; TdxBarShadow = class; TdxBarSubItem = class; TdxBarSubMenuControl = class; TdxDockControl = class; TdxDockRow = class; TdxObjectList = class; TdxBarScreenTip = class; TdxBarCustomHintViewInfo = class; TdxBarCustomHintViewInfoClass = class of TdxBarCustomHintViewInfo; TdxBarScreenTipViewInfo = class; TdxBarScreenTipCollection = class; TdxBarScreenTipBand = class; TdxBarScreenTipBandViewInfo = class; TdxBarHintWindow = class; TdxBarHintWindowClass = class of TdxBarHintWindow; TdxBarScreenTipRepository = class; TdxBarItemSeparatorKind = (skHorizontal, skVertical); TdxBarItemSeparatorData = record AssociatedItemControl: TObject; Bounds: TRect; Kind: TdxBarItemSeparatorKind; end; {-------------------------- Nonvisual components --------------------------} TdxBarSelectionStatus = (ssUnselected, ssActiveSelected, ssInactiveSelected); TdxBarSelectionOperation = (soAdd, soExclude, soExclusive); TdxBarCustomizationAction = (caReset, caDelete, caDeleteItem, caDeleteLink, caChangeCaption, caChangeButtonPaintStyle, caChangePosition, caChangeViewLevels, caChangeButtonGroup, caChangeBeginGroup, caChangeVisible, caChangeRecentList); TdxBarCustomizationActions = set of TdxBarCustomizationAction; IdxBarSelectableItem = interface ['{6DCCAA42-48D0-4D7D-BEDF-1EADC2197131}'] function CanDelete(ADestruction: Boolean = False): Boolean; procedure DeleteSelection(var AReference: IdxBarSelectableItem; ADestruction: Boolean); procedure ExecuteCustomizationAction(ABasicAction: TdxBarCustomizationAction); function GetBarManager: TdxBarManager; function GetInstance: TPersistent; procedure GetMasterObjects(AList: TdxObjectList); function GetNextSelectableItem: IdxBarSelectableItem; function GetSelectableParent: TPersistent; function GetSelectionStatus: TdxBarSelectionStatus; function GetSupportedActions: TdxBarCustomizationActions; procedure Invalidate; function IsComplex: Boolean; function IsComponentSelected: Boolean; procedure SelectComponent(ASelectionOperation: TdxBarSelectionOperation = soExclusive); function SelectParentComponent: Boolean; procedure SelectionChanged; end; IdxBarDesigner = interface ['{B364658F-B4CE-46C3-83D5-D537F34B9482}'] function CanDeleteComponent(AComponent: TComponent): Boolean; procedure GetSelection(AList: TList); function GetSelectionStatus(AComponent: TPersistent): TdxBarSelectionStatus; function IsComponentSelected(AComponent: TPersistent): Boolean; procedure SelectComponent(AComponent: TPersistent; ASelectionOperation: TdxBarSelectionOperation = soExclusive); procedure SetSelection(AList: TList); procedure ShowDefaultEventHandler(AItem: TdxBarItem); function UniqueName(const BaseName: string): string; end; IdxBarLinksOwner = interface ['{1CB4E538-769E-45F4-9BE3-20814F440106}'] function CanContainItem(AItem: TdxBarItem; out AErrorText: string): Boolean; function CreateBarControl: TCustomdxBarControl; function GetInstance: TComponent; function GetItemLinks: TdxBarItemLinks; end; IdxBarSubMenuOwner = interface ['{218A3250-D279-44EA-9E87-3D5443B3C0ED}'] function GetBarSize: Integer; procedure DoPaintBar(ACanvas: TCanvas; const R: TRect); end; IdxBarItemControlViewInfo = interface ['{99C4A703-E6D2-43AF-987E-F5DA81718295}'] function GetAlign: TdxBarItemAlign; function GetAllowedViewLevels: TdxBarItemViewLevels; function GetBounds: TRect; function GetColumnRowCount: Integer; function GetPosition: TdxBarItemPosition; function GetPositionInButtonGroup: TdxBarButtonGroupPosition; function GetRealPositionInButtonGroup: TdxBarButtonGroupRealPosition; function GetRow: Integer; function GetViewLevel: TdxBarItemViewLevel; function GetViewLevelForButtonGroup: TdxBarItemRealViewLevel; function GetWidth(AViewLevel: TdxBarItemRealViewLevel): Integer; function HasSeparator: Boolean; procedure SetBounds(const Value: TRect); procedure SetColumnRowCount(Value: Integer); procedure SetRealPositionInButtonGroup(Value: TdxBarButtonGroupRealPosition); procedure SetRow(Value: Integer); procedure SetViewLevel(Value: TdxBarItemViewLevel); end; IdxBarHintKeeper = interface ['{587A00C4-A7E0-4032-98E5-4DB8F3918ADF}'] function DoHint(var ANeedDeactivate: Boolean; out AHintText: string; out AShortCut: string): Boolean; function CreateHintViewInfo(const AHintText, AShortCut: string): TdxBarCustomHintViewInfo; function GetEnabled: Boolean; function GetHintPosition(const ACursorPos: TPoint; AHeight: Integer): TPoint; end; IdxBarKeyTipWindowsManager = interface ['{ABA47F3E-5F8B-4A4B-863F-B70AC02F3C1D}'] procedure Add(const ACaption: string; const ABasePoint: TPoint; AHorzAlign: TAlignment; AVertAlign: TcxAlignmentVert; AEnabled: Boolean; out AWindow: TObject); procedure Delete(AWindow: TObject); procedure Show; end; { TdxBarKeyTipInfo } TdxBarKeyTipInfo = record KeyTip: string; BasePoint: TPoint; HorzAlign: TAlignment; VertAlign: TcxAlignmentVert; Visible: Boolean; Enabled: Boolean; OnExecute: TNotifyEvent; end; { TdxBarKeyTipData } TdxBarKeyTipData = class private FKeyTipInfo: TdxBarKeyTipInfo; FKeyTipWindow: TObject; function GetNormalizedKeyTip: string; public constructor Create(const AKeyTipInfo: TdxBarKeyTipInfo); procedure HideKeyTipWindow(AKeyTipWindowsManager: IdxBarKeyTipWindowsManager); procedure ShowKeyTipWindow(AKeyTipWindowsManager: IdxBarKeyTipWindowsManager); property BasePoint: TPoint read FKeyTipInfo.BasePoint; property Enabled: Boolean read FKeyTipInfo.Enabled; property HorzAlign: TAlignment read FKeyTipInfo.HorzAlign; property KeyTip: string read FKeyTipInfo.KeyTip write FKeyTipInfo.KeyTip; property NormalizedKeyTip: string read GetNormalizedKeyTip; property VertAlign: TcxAlignmentVert read FKeyTipInfo.VertAlign; property Visible: Boolean read FKeyTipInfo.Visible write FKeyTipInfo.Visible; property OnExecute: TNotifyEvent read FKeyTipInfo.OnExecute; end; IdxBarAccessibilityHelper = interface(IcxAccessibilityHelper) ['{5AE17753-A04D-4496-B5A3-08B2CEDE40F7}'] function AreKeyTipsSupported( out AKeyTipWindowsManager: IdxBarKeyTipWindowsManager): Boolean; function CanNavigateToChildren(AKey: Word): Boolean; function GetBarHelper: TdxBarAccessibilityHelper; function GetBarManager: TdxBarManager; function GetDefaultAccessibleObject: IdxBarAccessibilityHelper; function GetNextAccessibleObject( ADirection: TcxAccessibilityNavigationDirection): IdxBarAccessibilityHelper; function GetRootAccessibleObject: IdxBarAccessibilityHelper; function HandleNavigationKey(var AKey: Word): Boolean; function IsNavigationKey(AKey: Word): Boolean; function IsSelected: Boolean; function LogicalNavigationGetNextAccessibleObject(AGoForward: Boolean): IdxBarAccessibilityHelper; procedure Select(ASetFocus: Boolean); procedure Unselect(ANextSelectedObject: IdxBarAccessibilityHelper); end; IdxBarAccessibleObject = interface ['{6411B5B8-FFF8-42BD-BFD4-0B53151C97DC}'] function GetAccessibilityHelper: IdxBarAccessibilityHelper; end; IdxSkin = interface ['{ABCD2B3A-5F77-45A1-ADE2-3C028D4DB64C}'] procedure DrawBackground(DC: HDC; const ARect: TRect; APart: Integer; AState: Integer = 0); procedure DrawCaption(DC: HDC; const ACaption: string; const ARect: TRect; APart: Integer; AState: Integer = 0); function GetCaptionRect(const ARect: TRect; APart: Integer): TRect; function GetContentOffsets(APart: Integer): TRect; function GetPartColor(APart: Integer; AState: Integer = 0): TColor; function GetPartOffset(APart: Integer): Integer; end; { TdxBarPersistent } TdxBarPersistent = class(TPersistent) private FBarManager: TdxBarManager; protected function GetOwner: TPersistent; override; public constructor Create(ABarManager: TdxBarManager); virtual; property BarManager: TdxBarManager read FBarManager; end; {$IFNDEF DELPHI6} TComponentList = class(Contnrs.TComponentList) public destructor Destroy; override; end; {$ENDIF} { TdxBarControlEditors } TdxBarControlEditor = class protected class function GetAddedItemClass(const AAddedItemName: string): TdxBarItemClass; virtual; class function GetPopupItemCaption: string; virtual; class procedure InitializePopupItem(AItemLink: TdxBarItemLink); virtual; class function PopupItemClass: TdxBarItemClass; virtual; class procedure AddItem(AClickedButton: TdxBarButton); class procedure InitializeAddedItem(AItemLink: TdxBarItemLink; AAddedItemName: string); virtual; class procedure OnButtonClick(Sender: TObject); public class procedure InitCustomizationPopup(AItemLinks: TdxBarItemLinks); virtual; end; TdxBarControlEditorClass = class of TdxBarControlEditor; TdxAddSubItemEditor = class(TdxBarControlEditor) protected class function GetAddedItemClass(const AAddedItemName: string): TdxBarItemClass; override; class function GetPopupItemCaption: string; override; class procedure InitializePopupItem(AItemLink: TdxBarItemLink); override; class function PopupItemClass: TdxBarItemClass; override; end; TdxAddButtonEditor = class(TdxAddSubItemEditor) protected class function GetAddedItemClass(const AAddedItemName: string): TdxBarItemClass; override; class function GetPopupItemCaption: string; override; end; TdxAddSeparatorEditor = class(TdxAddSubItemEditor) protected class function GetAddedItemClass(const AAddedItemName: string): TdxBarItemClass; override; class function GetPopupItemCaption: string; override; end; TdxItemsEditorEx = class(TdxBarControlEditor) protected class procedure InitSubItem(AItemLinks: TdxBarItemLinks); virtual; class function GetAddedItemClass(const AAddedItemName: string): TdxBarItemClass; override; class function GetPopupItemCaption: string; override; class procedure InitializePopupItem(AItemLink: TdxBarItemLink); override; class function PopupItemClass: TdxBarItemClass; override; end; { TdxBarCustomizingPopup } TdxChangeViewLevelAction = (vlaChangeLargeIconWithText, vlaChangeSmallIconWithText, vlaChangeSmallIcon, vlaChangeControl, vlaSetAll, vlaSetLargeIconWithTextOnly, vlaSetSmallIconWithTextOnly, vlaSetSmallIconOnly, vlaControlOnly); TdxChangeButtonGroupAction = (bgaNone, bgaStart, bgaMember, bgaGroup, bgaUngroup); { TdxBarDesignController } TdxDesignState = (dsDesignerModifying, dsKeyAlreadyProcessed); TdxDesignStates = set of TdxDesignState; TInitPopupProc = procedure (AItemLinks: TdxBarItemLinks) of object; TdxBarDesignController = class private FCustomizingBarControl: TCustomdxBarControl; FCustomizingBarManager: TdxBarManager; FCustomizingItemLink: TdxBarItemLink; FCustomizingItemLinks: TdxBarItemLinks; FInternalItems: TComponentList; FRegisteredBarControlDesignHelpers: TcxRegisteredClassList; FRegisteredBarControlEditors: TList; FLastSelectedItem: IdxBarSelectableItem; FLockDesignerModifiedCount: Integer; FCustomizationPopup: TdxBarCustomizingPopup; FQuickControl: TdxBarControl; FNotifyComponent: TcxFreeNotificator; function CanDeleteSelectedObjects: Boolean; procedure GetSelection(ASelection: TdxObjectList); procedure RemoveIrrelevantObjects(ASelection: TdxObjectList; ADestruction: Boolean = False); procedure ClearOwnedItems(AItemLinks: TdxBarItemLinks); procedure CustomizeItemClick(Sender: TObject); // CustomizationPopup procedure TextItemChange(Sender: TObject); procedure CustomizationPopupCloseUp(Sender: TObject); procedure CustomizationPopupDestroy(Sender: TObject); procedure CustomizationPopupItemClick(Sender: TObject); procedure InitCustomizationPopup(AItemLinks: TdxBarItemLinks); procedure SynchronizeAction(ABasicAction: TdxBarCustomizationAction); procedure UpdateViewLevelsSubItemButtonStates(AItemLinks: TdxBarItemLinks); // ToolbarsPopup procedure ToolbarsPopupClick(Sender: TObject); // QuickControl procedure QuickControlDestroy(Sender: TObject); function CanCustomize(ABarManager: TdxBarManager; AIsKeyboardAction: Boolean): Boolean; procedure FindCustomizingBarManager; procedure SetLastSelectedItem(Value: IdxBarSelectableItem); procedure FreeNotification(AComponent: TComponent); protected FDesignStates: TdxDesignStates; public constructor Create; destructor Destroy; override; procedure AddCustomizeItem(AItemLinks: TdxBarItemLinks; AItemClass: TdxBarItemClass; ABeginGroup: Boolean = True); function AddInternalItem(AItemLinks: TdxBarItemLinks; AItemClass: TdxBarItemClass; ACaption: string; AOnClick: TNotifyEvent = nil; ATag: Integer = 0; ABeginGroup: Boolean = False): TdxBarItemLink; overload; procedure AddInternalItem(AItem: TdxBarItem; AList: TList = nil); overload; procedure ClearInternalItems; procedure RemoveItemFromBarManagerList(AItem: TdxBarItem); function AddItem(ABarItemClass: TdxBarItemClass): TdxBarItemLink; procedure SelectItemLink(AItemLink: TdxBarItemLink); procedure DesignerModified; overload; procedure DesignerModified(AForm: TCustomForm); overload; function IsDesignerModifiedLocked: Boolean; procedure LockDesignerModified; procedure UnLockDesignerModified; function IsCustomizedByPopup: Boolean; procedure RegisterBarControlDesignHelper(ABarControlClass: TCustomdxBarControlClass; AHelperClass: TCustomdxBarControlDesignHelperClass); procedure RegisterBarControlEditor(AEditor: TdxBarControlEditorClass); procedure UnregisterBarControlDesignHelper(ABarControlClass: TCustomdxBarControlClass; AHelperClass: TCustomdxBarControlDesignHelperClass); procedure UnregisterBarControlEditor(AEditor: TdxBarControlEditorClass); procedure DropSelection(ASelectableItem: IdxBarSelectableItem); function IsItemCustomized(ASelectableItem: IdxBarSelectableItem): Boolean; function IsItemLastSelected(ASelectableItem: IdxBarSelectableItem): Boolean; function IsItemLinkCustomized: Boolean; function IsItemSingleSelected(ASelectableItem: IdxBarSelectableItem): Boolean; function IsSelectionComplex(ABarManager: TdxBarManager): Boolean; function IsSelectionSingle(ABarManager: TdxBarManager): Boolean; function NeedDefaultSelection(ASelectableItem: IdxBarSelectableItem): Boolean; procedure SelectItem(ASelectableItem: IdxBarSelectableItem; ASelectionOperation: TdxBarSelectionOperation = soExclusive); procedure SynchronizeLastSelectedItem; function DeleteSelectedObjects(ADestruction, AIsKeyboardAction: Boolean): Boolean; procedure DeleteCustomizingItem; procedure DeleteCustomizingItemLink; function SelectParentComponent: Boolean; // CustomCustomizePopup procedure ShowCustomCustomizePopup(ABarManager: TdxBarManager; AInitPopupProc: TInitPopupProc; APainter: TdxBarPainter; ACustomizingBarControl: TCustomdxBarControl = nil; ACustomizingItemLink: TdxBarItemLink = nil); // CustomizePopup procedure ShowCustomizePopup(ABarControl: TCustomdxBarControl; ACustomizingItemLink: TdxBarItemLink); procedure SetCustomizePopupTopMosts(AShow: Boolean); // ToolbarsPopup procedure InitToolBarPopup(AItemLinks: TdxBarItemLinks); procedure ShowToolbarsPopup(ABarManager: TdxBarManager; APainter: TdxBarPainter); // QuickControl procedure ShowQuickControl(ABarControl: TdxBarControl; AOwnerRect: TRect); property CustomizingBarControl: TCustomdxBarControl read FCustomizingBarControl; property CustomizingItemLink: TdxBarItemLink read FCustomizingItemLink; property CustomizingBarManager: TdxBarManager read FCustomizingBarManager; property LastSelectedItem: IdxBarSelectableItem read FLastSelectedItem write SetLastSelectedItem; property QuickControl: TdxBarControl read FQuickControl; end; { TdxBarCanvas } TdxBarCanvasState = record PrevDC: THandle; NewDC: THandle; NewDCIndex: Integer; end; TdxBarCanvasStates = array of TdxBarCanvasState; TdxBarCanvas = class(TcxCanvas) private FCounter: Integer; FSavedDCs: TdxBarCanvasStates; function HandleValid: Boolean; public constructor Create; reintroduce; destructor Destroy; override; procedure BeginPaint(ADC: THandle); overload; procedure BeginPaint(ACanvas: TcxCanvas); overload; procedure EndPaint; end; { TdxBarComponent } TdxBarItemVisible = (ivNever, ivInCustomizing, ivAlways); TdxBarComponent = class(TComponent, {$IFNDEF DELPHI6}IUnknown,{$ENDIF} IdxBarSelectableItem) protected FBarManager: TdxBarManager; FChangeNotifies: TObjectList; FEnabled: Boolean; FVisible: TdxBarItemVisible; procedure AddChangeNotify(AComponentList: TdxBarComponentList); procedure RemoveChangeNotify(AComponentList: TdxBarComponentList); procedure Changed(AllItems: Boolean = False); virtual; function GetEnabled: Boolean; virtual; abstract; procedure SetEnabled(Value: Boolean); virtual; abstract; procedure SetVisible(Value: TdxBarItemVisible); virtual; abstract; // IdxBarSelectableItem function CanDelete(ADestruction: Boolean = False): Boolean; virtual; procedure DeleteSelection(var AReference: IdxBarSelectableItem; ADestruction: Boolean); virtual; procedure ExecuteCustomizationAction(ABasicAction: TdxBarCustomizationAction); virtual; function GetBarManager: TdxBarManager; virtual; function IdxBarSelectableItem.GetInstance = GetPersistentInstance; procedure GetMasterObjects(AList: TdxObjectList); virtual; function GetNextSelectableItem: IdxBarSelectableItem; virtual; function GetSelectableParent: TPersistent; virtual; function GetSelectionStatus: TdxBarSelectionStatus; virtual; function GetSupportedActions: TdxBarCustomizationActions; virtual; procedure Invalidate; virtual; function IsComplex: Boolean; virtual; function IsComponentSelected: Boolean; virtual; procedure SelectComponent(ASelectionOperation: TdxBarSelectionOperation = soExclusive); virtual; function SelectParentComponent: Boolean; virtual; procedure SelectionChanged; virtual; function GetPersistentInstance: TPersistent; virtual; function GetComponentInstance: TComponent; virtual; property Enabled: Boolean read GetEnabled write SetEnabled; property Visible: TdxBarItemVisible read FVisible write SetVisible; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; property BarManager: TdxBarManager read GetBarManager; end; { TdxList } TdxObjectList = class(TObjectList) private procedure AddFromList(ASource, AExcludedList: TList); protected procedure CopyList(ASource, ADestination: TList); function GetItem(AIndex: Integer): TObject; public constructor Create; overload; procedure Add(AObject: TObject); procedure AddList(AObjects: TList); procedure CopyFrom(ASource: TList); procedure CopyTo(ADestination: TList); procedure XorList(ASourceA, ASourceB: TList); function First: TObject; function Last: TObject; end; TdxEventHandler = procedure (Sender: TObject; const AEventArgs) of object; TdxEventHandlerCollection = class(TObject) private FEvents: array of TdxEventHandler; procedure Delete(AIndex: Integer); function IndexOf(AEvent: TdxEventHandler): Integer; public procedure Add(AEvent: TdxEventHandler); procedure CallEvents(Sender: TObject; const AEventArgs); procedure Remove(AEvent: TdxEventHandler); end; { TdxComponentList } TdxBarListNotifyEvent = procedure (Sender: TObject; AComponent: TComponent; AAction: TListNotification) of object; TdxBarListChangeEvent = procedure (Sender: TObject; AComponent: TComponent; AAction: TcxComponentCollectionNotification) of object; TdxComponentList = class(TComponentList) private FUpdateCount: Integer; FOnComponentListChanged: TdxBarListChangeEvent; FOnNotify: TdxBarListNotifyEvent; protected procedure DoNotify(AItem: TComponent; AAction: TListNotification); virtual; function GetItemClass: TClass; virtual; procedure Notify(Ptr: Pointer; Action: TListNotification); override; procedure Update(AItem: TComponent = nil; AAction: TcxComponentCollectionNotification = ccnChanged); public destructor Destroy; override; procedure BeginUpdate; procedure EndUpdate(AForceUpdate: Boolean = True); property OnComponentListChanged: TdxBarListChangeEvent read FOnComponentListChanged write FOnComponentListChanged; property OnNotify: TdxBarListNotifyEvent read FOnNotify write FOnNotify; end; { TdxBarComponentList } TdxBarComponentList = class(TdxComponentList) protected procedure DoNotify(AItem: TComponent; AAction: TListNotification); override; function GetItemClass: TClass; override; end; { TdxBarGroup } TdxBarGroup = class(TdxBarComponent) private FItems: TdxBarComponentList; FItemsNames: TStringList; function GetCount: Integer; function GetIndex: Integer; function GetItem(Index: Integer): TComponent; function InternalGetCount: Integer; function InternalGetItemName(Index: Integer): string; procedure SetIndex(Value: Integer); procedure ReadItems(Reader: TReader); procedure WriteItems(Writer: TWriter); protected procedure DefineProperties(Filer: TFiler); override; function GetEnabled: Boolean; override; procedure Loaded; override; procedure SetName(const NewName: TComponentName); override; procedure SetEnabled(Value: Boolean); override; procedure SetVisible(Value: TdxBarItemVisible); override; property ItemList: TdxBarComponentList read FItems; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; function GetParentComponent: TComponent; override; function HasParent: Boolean; override; procedure SetParentComponent(AParent: TComponent); override; procedure Add(AItem: TdxBarComponent); procedure Delete(Index: Integer); function IndexOf(AItem: TdxBarComponent): Integer; procedure Move(FromIndex, ToIndex: Integer); procedure Remove(AItem: TdxBarComponent); property Count: Integer read GetCount; property Index: Integer read GetIndex write SetIndex; property Items[Index: Integer]: TComponent read GetItem; default; published property Enabled default True; property Visible default ivAlways; end; TdxBarPopupMenuLinkActionEvent = procedure(Sender: TdxBarPopupMenuLink; var X, Y: Integer; ClickedByMouse: Boolean; var AllowPopup: Boolean) of object; TdxBarPopupMenuLink = class(TCollectionItem) private FControl: TControl; FPopupMenu: TdxBarPopupMenu; FPrevWndProc: TWndMethod; FProcessChildren: Boolean; FOnAction: TdxBarPopupMenuLinkActionEvent; function GetBarManager: TdxBarManager; function GetWinControl: TWinControl; procedure SetControl(Value: TControl); procedure SetPopupMenu(Value: TdxBarPopupMenu); property WinControl: TWinControl read GetWinControl; protected function DoAction(const AScreenPopupPoint: TPoint): Boolean; overload; function IsShortCut(AShortCut: TShortCut): Boolean; procedure NewWndProc(var Message: TMessage); public constructor Create(Collection: TCollection); override; destructor Destroy; override; procedure Assign(Source: TPersistent); override; function DoAction(Wnd: HWND; const P: TPoint): Boolean; overload; property BarManager: TdxBarManager read GetBarManager; published property Control: TControl read FControl write SetControl; property PopupMenu: TdxBarPopupMenu read FPopupMenu write SetPopupMenu; property ProcessChildren: Boolean read FProcessChildren write FProcessChildren default True; property OnAction: TdxBarPopupMenuLinkActionEvent read FOnAction write FOnAction; end; TdxBarPopupMenuLinks = class(TCollection) private FBarManager: TdxBarManager; function GetItem(Index: Integer): TdxBarPopupMenuLink; procedure SetItem(Index: Integer; Value: TdxBarPopupMenuLink); protected function GetOwner: TPersistent; override; function IsShortCut(AControl: TWinControl; AShortCut: TShortCut): Boolean; public constructor Create(ABarManager: TdxBarManager); function Add: TdxBarPopupMenuLink; function DoAction(AControl: TWinControl; Wnd: HWND; const P: TPoint): Boolean; property BarManager: TdxBarManager read FBarManager; property Items[Index: Integer]: TdxBarPopupMenuLink read GetItem write SetItem; default; end; TdxBarBackgrounds = class(TdxBarPersistent) private FBarBackgroundBitmap: TBitmap; FSubMenuBackgroundBitmap: TBitmap; procedure BitmapChanged(Sender: TObject); procedure SetBarBackgroundBitmap(Value: TBitmap); procedure SetSubMenuBackgroundBitmap(Value: TBitmap); protected procedure Changed; public constructor Create(ABarManager: TdxBarManager); override; destructor Destroy; override; procedure Assign(Source: TPersistent); override; published property Bar: TBitmap read FBarBackgroundBitmap write SetBarBackgroundBitmap; property SubMenu: TBitmap read FSubMenuBackgroundBitmap write SetSubMenuBackgroundBitmap; end; TdxBarDockingStyle = (dsNone, dsLeft, dsTop, dsRight, dsBottom); TdxBarDockingStyles = set of TdxBarDockingStyle; TdxBarDockedDockingStyle = dsLeft..dsBottom; TdxBarManagerStyle = (bmsStandard, bmsEnhanced, bmsFlat, bmsXP, bmsOffice11, bmsUseLookAndFeel); TdxBarMenuAnimations = (maNone, maRandom, maUnfold, maSlide, maFade); TdxBarEvent = procedure(Sender: TdxBarManager; ABar: TdxBar) of object; TdxBarItemLinkEvent = procedure(Sender: TdxBarManager; AItemLink: TdxBarItemLink) of object; TdxBarVisibleChangeEvent = procedure(Sender: TdxBarManager; ABar: TdxBar) of object; TdxBarCanDockingEvent = procedure(Sender: TdxBar; Style: TdxBarDockingStyle; DockControl: TdxDockControl; var CanDocking: Boolean) of object; TdxBarShowPopupEvent = procedure(Sender: TdxBarManager; PopupItemLinks: TdxBarItemLinks) of object; TdxBarClickItemEvent = procedure(Sender: TdxBarManager; ClickedItem: TdxBarItem) of object; TdxBarIniFileEvent = procedure(Sender: TObject; AIniFile: TCustomIniFile; const ADelimiter: string; const ASection: string) of object; TdxBarItemMergeKind = (mkAdd, mkMergeByCaption, mkNone); TdxBarStoringKind = (skIni, skReg); TdxBarMergeEvent = procedure(Sender, ChildBarManager: TdxBarManager; AddItems: Boolean) of object; TdxBarMenuMergeEvent = TdxBarMergeEvent; TdxBarMergeItemLinkEvent = procedure(Sender: TdxBarManager; ADstItemLinks, ASrcItemLinks: TdxBarItemLinks; ASrcItemLink: TdxBarItemLink; var AMergeKind: TdxBarItemMergeKind; var AMergeIndex: Integer) of object; TdxBarInternalState = (bisAfterLoading, bisBarsLoading, bisCreating, bisHandleCreating, bisModalActivating, bisFormActivating, bisToolbarsVisibleChanging, bisWasActive, bisStateSaving); TdxBarInternalStates = set of TdxBarInternalState; TdxBarMDIStateChange = (scChildActivated, scChildDeactivated, scMaximizedChanged); TdxBarDraggingState = (dsNoDrag, dsNoDrop, dsBeginGroup, dsCategory, dsCopy, dsDrag); TdxBarItemSeparatorInfo = record Bounds: TRect; Kind: TdxBarItemSeparatorKind; end; TdxBarIniFileEventData = record IniFile: TCustomIniFile; StoringKind: TdxBarStoringKind; BaseSection: string; Delimiter: string; end; TdxBarMDIStateChangeEventData = record Change: TdxBarMDIStateChange; Wnd: HWND; end; TCustomdxBarControlViewInfo = class private FItemControlViewInfos: TList; FSeparatorsData: array of TdxBarItemSeparatorData; function GetItemControlCount: Integer; function GetItemControlViewInfo(AIndex: Integer): TdxBarItemControlViewInfo; function GetSeparatorCount: Integer; function GetSeparatorInfo(AIndex: Integer): TdxBarItemSeparatorInfo; procedure SetSeparatorInfo(AIndex: Integer; const Value: TdxBarItemSeparatorInfo); protected FBarControl: TCustomdxBarControl; procedure AddItemControlViewInfo(AViewInfo: TdxBarItemControlViewInfo); procedure AddSeparatorInfo(const ARect: TRect; AKind: TdxBarItemSeparatorKind; AAssociatedItemControl: TdxBarItemControl); procedure Clear; virtual; procedure RemoveItemControlViewInfo(AViewInfo: TdxBarItemControlViewInfo); procedure RemoveSeparatorInfos; public constructor Create(ABarControl: TCustomdxBarControl); virtual; destructor Destroy; override; procedure Calculate; virtual; function GetItemControlIndex(AItemControl: TdxBarItemControl): Integer; function IsAssociatedWithSeparator(AItemControl: TdxBarItemControl; out ASeparatorIndex: Integer): Boolean; function IsItemControlVisible(AItemControl: TdxBarItemControl): Boolean; property BarControl: TCustomdxBarControl read FBarControl; property ItemControlCount: Integer read GetItemControlCount; property ItemControlViewInfos[AIndex: Integer]: TdxBarItemControlViewInfo read GetItemControlViewInfo; property SeparatorCount: Integer read GetSeparatorCount; property SeparatorInfos[AIndex: Integer]: TdxBarItemSeparatorInfo read GetSeparatorInfo write SetSeparatorInfo; end; TdxBarDragInfo = class private FBarManager: TdxBarManager; FLockCount: Integer; FModified: Boolean; FCaptureWnd: HWND; FDefaultCursor: TCursor; FDragDownPoint: TPoint; FDragLineVisible: Boolean; FDragLineBarControlLink: TcxObjectLink; FDragLineFirstPart: Boolean; FDragLineRect: TRect; FDragLineVerticalDirection: Boolean; FDraggingItem: TdxBarItem; FDraggingItemLink: TdxBarItemLink; FDraggingItemLinkParentHandle: HWND; FDraggingState: TdxBarDraggingState; FDragOverFirstPart: Boolean; FDragOverBeginGroup: Boolean; FDragOverVerticalDirection: Boolean; FDragOverBarControlLink: TcxObjectLink; FDragOverItemLink: TdxBarItemLink; procedure CalcDragOverItemParameters(var ACursorPos: TPoint); function CategoriesList: TListBox; procedure DragInfoChanged; procedure DrawDraggingLine(AVisible: Boolean); function HasTarget: Boolean; function IsDragCopy: Boolean; function NoNeedDragLine: Boolean; procedure ChangeBeginGroup; procedure CreateNewItemLink; procedure DeleteDraggingItemLink; procedure InternalDrawDraggingLine; procedure MoveItemToAnotherCategory; function GetDraggingControl: TdxBarItemControl; function GetDragLineBarControl: TCustomdxBarControl; function GetDragOverBarControl: TCustomdxBarControl; function GetDragOverBarItemLinks: TdxBarItemLinks; function GetDragOverItemControl: TdxBarItemControl; procedure SetDraggingState(Value: TdxBarDraggingState); procedure SetDragLineBarControl(Value: TCustomdxBarControl); procedure SetDragOverBarControl(Value: TCustomdxBarControl); procedure SetDragOverBeginGroup(Value: Boolean); procedure SetDragOverFirstPart(Value: Boolean); procedure SetDragOverVerticalDirection(Value: Boolean); procedure SetDragOverItemLink(Value: TdxBarItemLink); property DragLineBarControl: TCustomdxBarControl read GetDragLineBarControl write SetDragLineBarControl; public constructor Create(ABarManager: TdxBarmanager); destructor Destroy; override; procedure BeginDrag(AItem: TdxBarItem; AItemLink: TdxBarItemLink); procedure DragDrop; procedure EndDrag; procedure HandleDragging; procedure BeginUpdate; procedure EndUpdate; property DraggingControl: TdxBarItemControl read GetDraggingControl; property DraggingItem: TdxBarItem read FDraggingItem write FDraggingItem; property DraggingItemLink: TdxBarItemLink read FDraggingItemLink write FDraggingItemLink; property DraggingState: TdxBarDraggingState read FDraggingState write SetDraggingState; property DragOverBeginGroup: Boolean read FDragOverBeginGroup write SetDragOverBeginGroup; property DragOverFirstPart: Boolean read FDragOverFirstPart write SetDragOverFirstPart; property DragOverVerticalDirection: Boolean read FDragOverVerticalDirection write SetDragOverVerticalDirection; property DragOverBarControl: TCustomdxBarControl read GetDragOverBarControl write SetDragOverBarControl; property DragOverBarItemLinks: TdxBarItemLinks read GetDragOverBarItemLinks; property DragOverItemControl: TdxBarItemControl read GetDragOverItemControl; property DragOverItemLink: TdxBarItemLink read FDragOverItemLink write SetDragOverItemLink; property DraggingItemLinkParentHandle: HWND read FDraggingItemLinkParentHandle write FDraggingItemLinkParentHandle; end; TdxBarImageOptions = class(TdxBarPersistent) private FDisabledImages: TCustomImageList; FDisabledLargeImages: TCustomImageList; FHotImages: TCustomImageList; FImages: TCustomImageList; FLargeImages: TCustomImageList; FImagesChangeLink: TChangeLink; FLargeImagesChangeLink: TChangeLink; FHotImagesChangeLink: TChangeLink; FDisabledImagesChangeLink: TChangeLink; FDisabledLargeImagesChangeLink: TChangeLink; FGlyphSize: Integer; FImageListBkColor: TColor; FLargeIcons: Boolean; FMakeDisabledImagesFaded: Boolean; FSmoothGlyphs: Boolean; FStretchGlyphs: Boolean; FUseLargeImagesForLargeIcons: Boolean; FUseLeftBottomPixelAsTransparent: Boolean; FOnImageOptionsChange: TNotifyEvent; FOnLargeIconsChange: TNotifyEvent; FNotifyComponent: TcxFreeNotificator; procedure SetImageList(var ANewValue, AOldValue: TCustomImageList; const AChangeLink: TChangeLink); procedure SetHotImages(Value: TCustomImageList); procedure SetImageListBkColor(Value: TColor); procedure SetImages(Value: TCustomImageList); procedure SetDisabledImages(Value: TCustomImageList); procedure SetDisabledLargeImages(Value: TCustomImageList); procedure SetLargeIcons(Value: Boolean); procedure SetLargeImages(Value: TCustomImageList); procedure SetMakeDisabledImagesFaded(Value: Boolean); procedure SetUseLargeImagesForLargeIcons(Value: Boolean); procedure SetUseLeftBottomPixelAsTransparent(Value: Boolean); procedure CalcGlyphSize; function IsLargeImagesForLargeIcons: Boolean; procedure FreeNotification(AComponent: TComponent); public constructor Create(ABarManager: TdxBarManager); override; destructor Destroy; override; procedure Assign(Source: TPersistent); override; property GlyphSize: Integer read FGlyphSize; published property DisabledImages: TCustomImageList read FDisabledImages write SetDisabledImages; property DisabledLargeImages: TCustomImageList read FDisabledLargeImages write SetDisabledLargeImages; property HotImages: TCustomImageList read FHotImages write SetHotImages; property ImageListBkColor: TColor read FImageListBkColor write SetImageListBkColor default clFuchsia; property Images: TCustomImageList read FImages write SetImages; property LargeImages: TCustomImageList read FLargeImages write SetLargeImages; property LargeIcons: Boolean read FLargeIcons write SetLargeIcons default False; property MakeDisabledImagesFaded: Boolean read FMakeDisabledImagesFaded write SetMakeDisabledImagesFaded default False; property SmoothGlyphs: Boolean read FSmoothGlyphs write FSmoothGlyphs default False; property StretchGlyphs: Boolean read FStretchGlyphs write FStretchGlyphs default True; property UseLargeImagesForLargeIcons: Boolean read FUseLargeImagesForLargeIcons write SetUseLargeImagesForLargeIcons default False; property UseLeftBottomPixelAsTransparent: Boolean read FUseLeftBottomPixelAsTransparent write SetUseLeftBottomPixelAsTransparent default True; end; TdxBarItemChangeProc = procedure (AItem: TdxBarItem) of object; TdxBarManager = class(TComponent, {$IFNDEF DELPHI6}IUnknown,{$ENDIF} IdxBarDesigner) private FAllowCallFromAnotherForm: Boolean; FAllowReset: Boolean; FAlwaysMerge: Boolean; FAlwaysSaveText: Boolean; FAutoDockColor: Boolean; FAutoHideEmptyBars: Boolean; FBackgrounds: TdxBarBackgrounds; FBarCaptionFont: TFont; FBarRestoringList: TList; FBars: TdxBars; FButtonArrowWidth: Integer; FCanCustomize: Boolean; FChangedSubMenuControl: TdxBarSubMenuControl; FChangingStyle: Boolean; FCategories: TStrings; FCreatedByMergingBarMergeDataList: TList; FDefaultPainter: TdxBarPainter; FDesignerModifiedInvoked: Boolean; // FSelectedLink: TdxBarItemLink; // #DG new FDisabledToolBarsList: TList; FDockColor: TColor; FDockControls: TList; FDragInfo: TdxBarDragInfo; FImageOptions: TdxBarImageOptions; FEditFont: TFont; FFlatCloseButton: Boolean; FFlatToolbarsBorderBrush: HBRUSH; FFlatToolbarsBrush: HBRUSH; FFlatToolbarsDownedBrush: HBRUSH; FFlatToolbarsDownedSelBrush: HBRUSH; FFlatToolbarsSelBrush: HBRUSH; FFocusedBarControl: TCustomdxBarControl; FFont: TFont; FGroups: TdxBarComponentList; //#DG list FHelpButtonGlyph: TBitmap; FHelpContext: THelpContext; FHideFloatingBarsWhenInactive: Boolean; FHintObject: TObject; FIniFileName: string; FInternalFontChange: Boolean; FInternalState: TdxBarInternalStates; FIsCustomizing: Boolean; FInternalItems: TComponentList; FItems: TdxBarComponentList; //#DG list FLargeButtonArrowWidth: Integer; FLockDesignerModifiedCount: Integer; FLockUpdate: Boolean; FLockUpdateCount: Integer; FLookAndFeel: TcxLookAndFeel; FMainFormActive: Boolean; FMainMenuBar: TdxBar; FMenuAnimations: TdxBarMenuAnimations; FMenusShowRecentItemsFirst: Boolean; FModified: Boolean; FMostRecentItemsPercents: Byte; FMostRecentlyUsedUseCount: Integer; FMouseTrackingBarControl: TCustomdxBarControl; FNewItems: TStringList; FNotDocking: TdxBarDockingStyles; FParentForm: TCustomForm; FPopupMenuLinks: TdxBarPopupMenuLinks; FPopupMenus: TComponentList; FPrevActiveMDIChild: HWND; FReadStateCount: Integer; FRegistryPath: string; FScaled: Boolean; FSelectedItem: TdxBarItemControl; // obsolete FShowCloseButton: Boolean; FShowFullMenusAfterDelay: Boolean; FShowHelpButton: Boolean; FShowHint: Boolean; FShowHintForDisabledItems: Boolean; FShowShortCutInHint: Boolean; FStoreInIniFile: Boolean; FStoreInRegistry: Boolean; FIniFileStream: TStream; FStyle: TdxBarManagerStyle; FSunkenBorder: Boolean; FThemeAvailable: Boolean; FThemeChangedNotificator: TdxThemeChangedNotificator; FThemeToolbarsBrush: HBRUSH; // FThemeToolbarsDownedBrush: HBRUSH; // FThemeToolbarsDownedSelBrush: HBRUSH; // FThemeToolbarsSelBrush: HBRUSH; FUseF10ForMenu: Boolean; FUseFullReset: Boolean; FUseSystemFont: Boolean; FWaitForDockingTime: Integer; FIsMDIMaximized: Boolean; FSavedState: TMemIniFile; FOnBarAdd: TdxBarEvent; FOnBarAfterReset: TdxBarEvent; FOnBarBeforeReset: TdxBarEvent; FOnBarClose: TdxBarEvent; FOnBarDelete: TdxBarEvent; FOnBarDockingStyleChange: TdxBarEvent; FOnBarVisibleChange: TdxBarVisibleChangeEvent; FOnItemLinkAdd: TdxBarItemLinkEvent; FOnItemLinkChange: TdxBarItemLinkEvent; FOnItemLinkDelete: TdxBarItemLinkEvent; FOnCloseButtonClick: TNotifyEvent; FOnDocking: TdxBarCanDockingEvent; FOnHelpButtonClick: TNotifyEvent; FOnHideCustomizingForm: TNotifyEvent; FOnMenuMerge: TdxBarMenuMergeEvent; FOnMerge: TdxBarMergeEvent; FOnMergeItemLink: TdxBarMergeItemLinkEvent; FOnShowCustomizingForm: TNotifyEvent; FOnShowCustomizingPopup: TdxBarShowPopupEvent; FOnShowToolbarsPopup: TdxBarShowPopupEvent; FOnClickItem: TdxBarClickItemEvent; FReadIniFileHandlers: TdxEventHandlerCollection; FWriteIniFileHandlers: TdxEventHandlerCollection; FSystemFontChangedHandlers: TdxEventHandlerCollection; FMDIStateChangedHandlers: TdxEventHandlerCollection; procedure BarDestroyHandler(Sender: TObject); procedure FormatRegistryPath(var ARegistryPath: string); function GetBarControlFocused: Boolean; function GetBarsLoading: Boolean; function GetCanModifyDesigner: Boolean; function GetCategoryItemsVisible(AIndex: Integer): TdxBarItemVisible; function GetCategoryVisible(AIndex: Integer): Boolean; function GetDesigning: Boolean; function GetDockColor: TColor; function GetDockControl(Index: Integer): TdxDockControl; function GetDockControlCount: Integer; function GetDragging: Boolean; function GetDraggingItem: TdxBarItem; function GetDraggingItemLink: TdxBarItemLink; function GetFlat: Boolean; function GetFlatToolbarsBorderColor: COLORREF; function GetFlatToolbarsColor: COLORREF; function GetFlatToolbarsDownedColor: COLORREF; function GetFlatToolbarsDownedSelColor: COLORREF; function GetFlatToolbarsSelColor: COLORREF; function GetGroup(Index: Integer): TdxBarGroup; function GetGroupCount: Integer; function GetInternalDockControl(ADockingStyle: TdxBarDockedDockingStyle): TdxDockControl; function GetIsCustomizing: Boolean; function GetIsDestroying: Boolean; function GetIsHandleCreating: Boolean; function GetIsInitializing: Boolean; function GetIsLoading: Boolean; function GetIsRecreating: Boolean; function GetIsStateSaving: Boolean; function GetItemCount: Integer; function GetItem(Index: Integer): TdxBarItem; function GetLastSelectedLinkAtDesign: TdxBarItemLink; function GetMainForm: TCustomForm; function GetMainMenuControl: TdxBarControl; function GetMasterForm: TCustomForm; function GetNotDocking: TdxBarDockingStyles; function GetParentBarManager: TdxBarManager; function GetParentedOwner: TWinControl; function GetParentForm: TCustomForm; function GetRestoringListBar(Index: Integer): TdxBar; function GetRestoringListBarCount: Integer; function GetTabOrder: Integer; procedure IniFileCollectionCallMethods(ACollection: TdxEventHandlerCollection; AIniFile: TCustomIniFile; AStoringKind: TdxBarStoringKind; ASection: string); function InternalGetPainterClass: TdxBarPainterClass; procedure SetAutoDockColor(Value: Boolean); procedure SetAutoHideEmptyBars(Value: Boolean); procedure SetBackgrounds(Value: TdxBarBackgrounds); procedure SetButtonArrowWidth(Value: Integer); procedure SetCategories(Value: TStrings); procedure SetCategoryItemsVisible(AIndex: Integer; Value: TdxBarItemVisible); procedure SetCategoryVisible(AIndex: Integer; Value: Boolean); procedure SetDockColor(Value: TColor); procedure SetFlatCloseButton(Value: Boolean); procedure SetFont(Value: TFont); procedure SetHelpButtonGlyph(Value: TBitmap); procedure SetHideFloatingBarsWhenInactive(Value: Boolean); procedure SetDraggingItem(Value: TdxBarItem); procedure SetDraggingItemLink(Value: TdxBarItemLink); procedure SetLargeButtonArrowWidth(Value: Integer); procedure SetLockUpdate(Value: Boolean); procedure SetLookAndFeel(Value: TcxLookAndFeel); procedure SetMenuAnimations(Value: TdxBarMenuAnimations); procedure SetMenusShowRecentItemsFirst(Value: Boolean); procedure SetMostRecentItemsPercents(Value: Byte); procedure SetNotDocking(Value: TdxBarDockingStyles); procedure SetPopupMenuLinks(Value: TdxBarPopupMenuLinks); procedure SetRegistryPath(Value: string); procedure SetScaled(Value: Boolean); procedure SetSelectedItem(Value: TdxBarItemControl); procedure SetShowCloseButton(Value: Boolean); procedure SetShowFullMenusAfterDelay(Value: Boolean); procedure SetShowHelpButton(Value: Boolean); procedure SetShowHint(Value: Boolean); procedure SetShowShortCutInHint(Value: Boolean); procedure SetStyle(Value: TdxBarManagerStyle); procedure SetSunkenBorder(Value: Boolean); procedure SetTabOrder(Value: Integer); procedure SetUseSystemFont(Value: Boolean); procedure SetWaitForDockingTime(Value: Integer); // ImageOptions begin function GetDisabledImages: TCustomImageList; function GetDisabledLargeImages: TCustomImageList; function GetGlyphSize: Integer; function GetHotImages: TCustomImageList; function GetImageListBkColor: TColor; function GetImages: TCustomImageList; function GetLargeImages: TCustomImageList; function GetLargeIcons: Boolean; function GetMakeDisabledImagesFaded: Boolean; function GetStretchGlyphs: Boolean; function GetUseLargeImagesForLargeIcons: Boolean; procedure SetDisabledImages(Value: TCustomImageList); procedure SetDisabledLargeImages(Value: TCustomImageList); procedure SetGlyphSize(Value: Integer); procedure SetHotImages(Value: TCustomImageList); procedure SetImageListBkColor(Value: TColor); procedure SetImages(Value: TCustomImageList); procedure SetLargeIcons(Value: Boolean); procedure SetLargeImages(Value: TCustomImageList); procedure SetMakeDisabledImagesFaded(Value: Boolean); procedure SetStretchGlyphs(Value: Boolean); procedure SetUseLargeImagesForLargeIcons(Value: Boolean); procedure DisabledImageListChange(Sender: TObject); procedure DisabledLargeImageListChange(Sender: TObject); procedure HotImageListChange(Sender: TObject); procedure ImageListChange(Sender: TObject); procedure ImageOptionsChange(Sender: TObject); procedure LargeIconsChange(Sender: TObject); procedure LargeImageListChange(Sender: TObject); // ImageOptions end function BarByNewName(const AName: string): TdxBar; procedure FontChanged(Sender: TObject); procedure CreateMDIChildSystemMenu(AWnd: HWND); procedure DestroyMDIChildSystemMenu; procedure MDIStateChanged(AChange: TdxBarMDIStateChange; AWnd: HWND); // function LoadMainFormFromBin: TForm; procedure CheckToolbarsVisibility; class function IsFormBroadcastMessage(AMsg: UINT): Boolean; procedure MainFormClientWndProc(Msg: UINT; wParam: WPARAM; lParam: LPARAM); procedure OwnerWndProc(AWnd: HWND; AMsg: UINT; wParam: WPARAM; lParam: LPARAM); class procedure SendFormBroadcastMessage(AOwnerHandle: HWND; AMsg: UINT; wParam: WPARAM; lParam: LPARAM); procedure DisplayHint; procedure HintActivate(AShow: Boolean; const CustomHint: string; AHintObject: TObject = nil); procedure DestroyItems; procedure HelpButtonGlyphChanged(Sender: TObject); procedure CalcMostRecentlyUsedUseCount; function ShowRecentItemsFirst: Boolean; procedure AddDockControl(ADockControl: TdxDockControl); procedure RemoveDockControl(ADockControl: TdxDockControl); procedure AddGroup(AGroup: TdxBarGroup); //#DG procedure RemoveGroup(AGroup: TdxBarGroup); function CorrectRegistryPath(var APath: string): Boolean; function GetSavedBarIndex(const ABarCaption: string): Integer; function IsDockColorStored: Boolean; procedure LoadLinkItemNames; procedure ReadBars(AReader: TReader); procedure ReadDockControlHeights(Reader: TReader); procedure SaveState; procedure WriteDockControlHeights(Writer: TWriter); procedure CreateFlatToolbarsBrushes; procedure DestroyFlatToolbarsBrushes; procedure CreateThemeToolbarsBrushes; procedure DestroyThemeToolbarsBrushes; procedure DestroyToolbarsBrushes; procedure CreateToolbarsBrushes; procedure RecreateToolbarsBrushes; procedure RefreshFloatingBarsShadows; procedure ResetBackgrounds; procedure InitPainter; procedure InternalStyleChanged; procedure ThemeChanged; procedure LFChanged(Sender: TcxLookAndFeel; AChangedValues: TcxLookAndFeelValues); procedure DoActivate(AState, AMinimized: WORD; AHandle, AWndPrevious: HWND); procedure DoActivateApp(AActivate: Boolean; AThreadID: DWORD); procedure DoCreate; procedure DoModalActivate; procedure DoLockUpdate(ALock: Boolean; ACheckBarsChanges: Boolean); function GetItemLinkWithAccel(AKey: Word; AShift: TShiftState): TdxBarItemLink; function HandleShortCut(AShortCut: TShortCut): Boolean; protected FdxBarDesignHelper: IdxBarDesigner; // IdxBarDesigner function CanDeleteComponent(AComponent: TComponent): Boolean; procedure GetSelection(AList: TList); function GetSelectionStatus(AComponent: TPersistent): TdxBarSelectionStatus; function IsComponentSelected(AComponent: TPersistent): Boolean; procedure SelectComponent(AComponent: TPersistent; ASelectionOperation: TdxBarSelectionOperation = soExclusive); procedure SetSelection(AList: TList); procedure ShowDefaultEventHandler(AItem: TdxBarItem); function UniqueName(const BaseName: string): string; procedure CreateBarRestoringList; procedure DestroyBarRestoringList; function BarRestoringListExists: Boolean; procedure AddBarToRestoringList(ABar: TdxBar); procedure RemoveBarFromRestoringList(ABar: TdxBar); procedure ShowBarsFromRestoringList(ADockControl: TdxBarDockControl); function GetBarIndexInRestoringList(ABar: TdxBar): Integer; property RestoringListBarCount: Integer read GetRestoringListBarCount; property RestoringListBars[Index: Integer]: TdxBar read GetRestoringListBar; procedure AssignFont; function CanReset: Boolean; procedure DefineProperties(Filer: TFiler); override; procedure DesignerModified; procedure DoBarAfterReset(ABar: TdxBar); dynamic; procedure DoBarBeforeReset(ABar: TdxBar); dynamic; procedure DoBarClose(ABar: TdxBar); dynamic; procedure DoBarDockingStyleChanged(ABar: TdxBar); dynamic; procedure DoClickItem(AItem: TdxBarItem); virtual; procedure DoCloseButtonClick; dynamic; function DoDocking(ABar: TdxBar; AStyle: TdxBarDockingStyle; ADockControl: TdxDockControl): Boolean; virtual; procedure DoItemLinkChange(AItemLink: TdxBarItemLink); procedure DoHelpButtonClick; dynamic; procedure DoMergeItemLink(ADstItemLinks, ASrcItemLinks: TdxBarItemLinks; ASrcItemLink: TdxBarItemLink; var AMergeKind: TdxBarItemMergeKind; var AMergeIndex: Integer); procedure DoShowCustomizingPopup(PopupItemLinks: TdxBarItemLinks); dynamic; procedure DoShowToolbarsPopup(PopupItemLinks: TdxBarItemLinks); dynamic; procedure DragAndDrop(AItem: TdxBarItem; AItemLink: TdxBarItemLink); function FindDockControl(APath: string): TdxBarDockControl; function GetCategoryRealIndex(AIndex: Integer): Integer; procedure GetChildren(Proc: TGetChildProc; Root: TComponent); override; function GetChildOwner: TComponent; override; function GetPainterClass: TdxBarPainterClass; virtual; function GetWindowForMouseCapturing: HWND; procedure SetChildOrder(Child: TComponent; Order: Integer); override; // function IsLinkSelected(AItemLink: TdxBarItemLink): Boolean; // procedure SelectLink(AItemLink: TdxBarItemLink; // ASelectionOperation: TdxBarSelectionOperation = soExclusive); // procedure SynchronizeSelectedLink; procedure ItemsChanged(Sender: TObject; AComponent: TComponent; AAction: TcxComponentCollectionNotification); // ImageOptions procedure CustomImagesChanged(AChangeProc: TdxBarItemChangeProc); procedure DisabledImagesChanged(AItem: TdxBarItem); procedure DisabledLargeImagesChanged(AItem: TdxBarItem); procedure HotImagesChanged(AItem: TdxBarItem); procedure ImagesChanged(AItem: TdxBarItem); function IsLargeImagesForLargeIcons: Boolean; procedure LargeImagesChanged(AItem: TdxBarItem); property GlyphSize: Integer read GetGlyphSize write SetGlyphSize; procedure DisableFloatToolBars; procedure EnableFloatToolBars; procedure ActivateFloatToolbars(AActivate, AForceHiding: Boolean; AActiveWindow: HWND); function IsInternalDockControl(ADockControl: TdxDockControl): Boolean; function IsUpdateLocked: Boolean; procedure Loaded; override; procedure LockDesignerModified(ALock: Boolean; AInvokeDesignerModifiedOnUnlock: Boolean = True); procedure Notification(AComponent: TComponent; Operation: TOperation); override; procedure ReadState(Reader: TReader); override; procedure SetName(const NewName: TComponentName); override; procedure ShowToolbars(Show, ForceHiding: Boolean; ActiveWindow: HWND); function GetBarManagerSection(const ABaseSection: string; AStoringKind: TdxBarStoringKind): string; function GetBaseIniSection: string; procedure LoadBarManager(ASource: TCustomIniFile; const ASection: string; AStoringKind: TdxBarStoringKind); procedure SaveBarManager(ADestination: TCustomIniFile; const ASection: string; AStoringKind: TdxBarStoringKind); function CreateBarAsByMerging: TdxBar; procedure InternalUnmerge(ABarManager: TdxBarManager; AForCustomization: Boolean); procedure RestoreMergeState; procedure GetActiveSelection(AList: TList); procedure BeginMouseTracking(ABarControl: TCustomdxBarControl); procedure EndMouseTracking(ABarControl: TCustomdxBarControl); function IsMouseTracking(ABarControl: TCustomdxBarControl): Boolean; property BarControlFocused: Boolean read GetBarControlFocused; property LastSelectedLinkAtDesign: TdxBarItemLink read GetLastSelectedLinkAtDesign; property GroupList: TdxBarComponentList read FGroups; //#DG property ItemList: TdxBarComponentList read FItems; //#DG property InternalState: TdxBarInternalStates read FInternalState; property DraggingItem: TdxBarItem read GetDraggingItem write SetDraggingItem; property DraggingItemLink: TdxBarItemLink read GetDraggingItemLink write SetDraggingItemLink; property Dragging: Boolean read GetDragging; property DragInfo: TdxBarDragInfo read FDragInfo; function IsOwnerVisible: Boolean; function IsUncustomizable: Boolean; property FocusedBarControl: TCustomdxBarControl read FFocusedBarControl; property IsDestroying: Boolean read GetIsDestroying; property IsHandleCreating: Boolean read GetIsHandleCreating; property IsInitializing: Boolean read GetIsInitializing; property IsLoading: Boolean read GetIsLoading; property IsRecreating: Boolean read GetIsRecreating; property IsStateSaving: Boolean read GetIsStateSaving; property MainFormActive: Boolean read FMainFormActive; property SavedState: TMemIniFile read FSavedState; property TabOrder: Integer read GetTabOrder write SetTabOrder; // TODO make published, default 0 function CanAddComponents: Boolean; function GetLightColor(ABtnFaceColorPart, AHighlightColorPart, AWindowColorPart: Integer): COLORREF; property BarCaptionFont: TFont read FBarCaptionFont; property CanModifyDesigner: Boolean read GetCanModifyDesigner; property Flat: Boolean read GetFlat; property FlatToolbarsBorderBrush: HBRUSH read FFlatToolbarsBorderBrush; property FlatToolbarsBrush: HBRUSH read FFlatToolbarsBrush; property FlatToolbarsDownedBrush: HBRUSH read FFlatToolbarsDownedBrush; property FlatToolbarsDownedSelBrush: HBRUSH read FFlatToolbarsDownedSelBrush; property FlatToolbarsSelBrush: HBRUSH read FFlatToolbarsSelBrush; property FlatToolbarsBorderColor: COLORREF read GetFlatToolbarsBorderColor; property FlatToolbarsColor: COLORREF read GetFlatToolbarsColor; property FlatToolbarsDownedColor: COLORREF read GetFlatToolbarsDownedColor; property FlatToolbarsDownedSelColor: COLORREF read GetFlatToolbarsDownedSelColor; property FlatToolbarsSelColor: COLORREF read GetFlatToolbarsSelColor; property ThemeToolbarsBrush: HBRUSH read FThemeToolbarsBrush; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; procedure ActivateHint(AShow: Boolean; const CustomHint: string; AHintObject: TObject = nil); function ActiveMDIChild: HWND; procedure BeginUpdate; procedure EndUpdate(ACheckBarsChanges: Boolean = True); function BarByCaption(const ACaption: string): TdxBar; function BarByComponentName(const AName: string): TdxBar; function BarByOldName(const AName: string): TdxBar; // function CheckBarName(const AName: string): string; function GetUniqueToolbarCaption(const ABaseName: string): string; function GetUniqueToolbarName(const ABaseName: string): string; function GetAllItemsByCategory(ACategory: Integer; List: TList): Integer; function GetCountByCategory(ACategory: Integer): Integer; function GetItemByCategory(ACategory, AIndex: Integer): TdxBarItem; function GetItemByName(const AName: string): TdxBarItem; function GetItemsByCategory(ACategory: Integer; List: TList): Integer; function GetUniqueItemName(ABarItemClass: TdxBarItemClass): string; function AddButton: TdxBarButton; function AddItem(AClass: TdxBarItemClass): TdxBarItem; function AddSubItem: TdxBarSubItem; function AddToolBar(AIsMainMenu: Boolean = False; ANeedEditCaption: Boolean = False): TdxBar; procedure DeleteToolBar(ABar: TdxBar; AConfirmation: Boolean); procedure ExchangeItems(Index1, Index2: Integer); // procedure FocusItem(AItem: TdxBarItem); procedure MoveItem(CurIndex, NewIndex: Integer); procedure RenameToolBar(ABar: TdxBar); procedure ResetToolBar(ABar: TdxBar); procedure Merge(ABarManager: TdxBarManager; ACanCreateNewBar: Boolean = True); procedure Unmerge(ABarManager: TdxBarManager = nil); procedure Customizing(Show: Boolean); procedure HideAll; procedure ResetUsageData; procedure ResetUsageDataWithConfirmation; //procedure WhatIsThis; procedure LoadFromRegistry(ARegistryPath: string); procedure SaveToRegistry(ARegistryPath: string); procedure LoadFromIniFile(const AFileName: string); procedure SaveToIniFile(const AFileName: string); procedure LoadFromStream(AStream: TStream); procedure SaveToStream(AStream: TStream); function CreateGroup: TdxBarGroup; function CanShowRecentItems: Boolean; function GetPaintStyle: TdxBarManagerStyle; function GetRealPaintStyle: TdxBarManagerStyle; property Bars: TdxBars read FBars; property BarsLoading: Boolean read GetBarsLoading; property CategoryItemsVisible[AIndex: Integer]: TdxBarItemVisible read GetCategoryItemsVisible write SetCategoryItemsVisible; property CategoryVisible[AIndex: Integer]: Boolean read GetCategoryVisible write SetCategoryVisible; property DefaultPainter: TdxBarPainter read FDefaultPainter; property Designing: Boolean read GetDesigning; property DockControlCount: Integer read GetDockControlCount; property DockControls[Index: Integer]: TdxDockControl read GetDockControl; property GroupCount: Integer read GetGroupCount; property Groups[Index: Integer]: TdxBarGroup read GetGroup; property InternalDockControls[ADockingStyle: TdxBarDockedDockingStyle]: TdxDockControl read GetInternalDockControl; property IsCustomizing: Boolean read GetIsCustomizing; property ItemCount: Integer read GetItemCount; property Items[Index: Integer]: TdxBarItem read GetItem; property IsMDIMaximized: Boolean read FIsMDIMaximized; property LockUpdate: Boolean read FLockUpdate write SetLockUpdate; property MainForm: TCustomForm read GetParentForm; { obsolete } property MasterForm: TCustomForm read GetMasterForm; property MainMenuControl: TdxBarControl read GetMainMenuControl; property MainMenuBar: TdxBar read FMainMenuBar; property Modified: Boolean read FModified write FModified; // only for Standard style property Owner: TWinControl read GetParentedOwner; property PainterClass: TdxBarPainterClass read InternalGetPainterClass; property ParentBarManager: TdxBarManager read GetParentBarManager; property ParentForm: TCustomForm read GetParentForm; property SelectedItem: TdxBarItemControl read FSelectedItem write SetSelectedItem; property ReadIniFileHandlers: TdxEventHandlerCollection read FReadIniFileHandlers; property WriteIniFileHandlers: TdxEventHandlerCollection read FWriteIniFileHandlers; property MDIStateChangedHandlers: TdxEventHandlerCollection read FMDIStateChangedHandlers; property SystemFontChangedHandlers: TdxEventHandlerCollection read FSystemFontChangedHandlers; published property AllowCallFromAnotherForm: Boolean read FAllowCallFromAnotherForm write FAllowCallFromAnotherForm default False; property AllowReset: Boolean read FAllowReset write FAllowReset default True; property AlwaysMerge: Boolean read FAlwaysMerge write FAlwaysMerge default False; property AlwaysSaveText: Boolean read FAlwaysSaveText write FAlwaysSaveText default False; property AutoDockColor: Boolean read FAutoDockColor write SetAutoDockColor default True; property AutoHideEmptyBars: Boolean read FAutoHideEmptyBars write SetAutoHideEmptyBars default False; property Scaled: Boolean read FScaled write SetScaled default True; // must be before Font property Font: TFont read FFont write SetFont; // must be before Bars property Backgrounds: TdxBarBackgrounds read FBackgrounds write SetBackgrounds; property ButtonArrowWidth: Integer read FButtonArrowWidth write SetButtonArrowWidth default dxBarDefaultButtonArrowWidth; property CanCustomize: Boolean read FCanCustomize write FCanCustomize default True; property Categories: TStrings read FCategories write SetCategories; property DockColor: TColor read GetDockColor write SetDockColor stored IsDockColorStored; property FlatCloseButton: Boolean read FFlatCloseButton write SetFlatCloseButton default False; property HelpButtonGlyph: TBitmap read FHelpButtonGlyph write SetHelpButtonGlyph; property HelpContext: THelpContext read FHelpContext write FHelpContext default 0; property HideFloatingBarsWhenInactive: Boolean read FHideFloatingBarsWhenInactive write SetHideFloatingBarsWhenInactive default True; // ImageOptions property ImageOptions: TdxBarImageOptions read FImageOptions write FImageOptions; // obsolete property DisabledImages: TCustomImageList read GetDisabledImages write SetDisabledImages stored False; property DisabledLargeImages: TCustomImageList read GetDisabledLargeImages write SetDisabledLargeImages stored False; property HotImages: TCustomImageList read GetHotImages write SetHotImages stored False; property ImageListBkColor: TColor read GetImageListBkColor write SetImageListBkColor stored False; property Images: TCustomImageList read GetImages write SetImages stored False; property LargeImages: TCustomImageList read GetLargeImages write SetLargeImages stored False; property LargeIcons: Boolean read GetLargeIcons write SetLargeIcons stored False; property MakeDisabledImagesFaded: Boolean read GetMakeDisabledImagesFaded write SetMakeDisabledImagesFaded stored False; property StretchGlyphs: Boolean read GetStretchGlyphs write SetStretchGlyphs stored False; property UseLargeImagesForLargeIcons: Boolean read GetUseLargeImagesForLargeIcons write SetUseLargeImagesForLargeIcons stored False; property IniFileName: string read FIniFileName write FIniFileName; property LargeButtonArrowWidth: Integer read FLargeButtonArrowWidth write SetLargeButtonArrowWidth default dxBarDefaultLargeButtonArrowWidth; property LookAndFeel: TcxLookAndFeel read FLookAndFeel write SetLookAndFeel; property MenuAnimations: TdxBarMenuAnimations read FMenuAnimations write SetMenuAnimations default maNone; property MenusShowRecentItemsFirst: Boolean read FMenusShowRecentItemsFirst write SetMenusShowRecentItemsFirst default True; property MostRecentItemsPercents: Byte read FMostRecentItemsPercents write SetMostRecentItemsPercents default 95; property NotDocking: TdxBarDockingStyles read GetNotDocking write SetNotDocking default []; property PopupMenuLinks: TdxBarPopupMenuLinks read FPopupMenuLinks write SetPopupMenuLinks; property RegistryPath: string read FRegistryPath write SetRegistryPath; property ShowCloseButton: Boolean read FShowCloseButton write SetShowCloseButton default False; property ShowFullMenusAfterDelay: Boolean read FShowFullMenusAfterDelay write SetShowFullMenusAfterDelay default True; property ShowHelpButton: Boolean read FShowHelpButton write SetShowHelpButton default False; property ShowHint: Boolean read FShowHint write SetShowHint default True; property ShowHintForDisabledItems: Boolean read FShowHintForDisabledItems write FShowHintForDisabledItems default True; property ShowShortCutInHint: Boolean read FShowShortCutInHint write SetShowShortCutInHint default False; property StoreInIniFile: Boolean read FStoreInIniFile write FStoreInIniFile default False; property StoreInRegistry: Boolean read FStoreInRegistry write FStoreInRegistry default False; property Style: TdxBarManagerStyle read FStyle write SetStyle default bmsEnhanced; property SunkenBorder: Boolean read FSunkenBorder write SetSunkenBorder default False; property UseF10ForMenu: Boolean read FUseF10ForMenu write FUseF10ForMenu default True; property UseFullReset: Boolean read FUseFullReset write FUseFullReset default False; property UseSystemFont: Boolean read FUseSystemFont write SetUseSystemFont; property WaitForDockingTime: Integer read FWaitForDockingTime write SetWaitForDockingTime default 21; property OnBarAdd: TdxBarEvent read FOnBarAdd write FOnBarAdd; property OnBarAfterReset: TdxBarEvent read FOnBarAfterReset write FOnBarAfterReset; property OnBarBeforeReset: TdxBarEvent read FOnBarBeforeReset write FOnBarBeforeReset; property OnBarClose: TdxBarEvent read FOnBarClose write FOnBarClose; property OnBarDelete: TdxBarEvent read FOnBarDelete write FOnBarDelete; property OnBarDockingStyleChange: TdxBarEvent read FOnBarDockingStyleChange write FOnBarDockingStyleChange; property OnBarVisibleChange: TdxBarVisibleChangeEvent read FOnBarVisibleChange write FOnBarVisibleChange; property OnItemLinkAdd: TdxBarItemLinkEvent read FOnItemLinkAdd write FOnItemLinkAdd; property OnItemLinkChange: TdxBarItemLinkEvent read FOnItemLinkChange write FOnItemLinkChange; property OnItemLinkDelete: TdxBarItemLinkEvent read FOnItemLinkDelete write FOnItemLinkDelete; property OnMergeItemLink: TdxBarMergeItemLinkEvent read FOnMergeItemLink write FOnMergeItemLink; property OnCloseButtonClick: TNotifyEvent read FOnCloseButtonClick write FOnCloseButtonClick; property OnDocking: TdxBarCanDockingEvent read FOnDocking write FOnDocking; property OnHelpButtonClick: TNotifyEvent read FOnHelpButtonClick write FOnHelpButtonClick; property OnHideCustomizingForm: TNotifyEvent read FOnHideCustomizingForm write FOnHideCustomizingForm; property OnMenuMerge: TdxBarMenuMergeEvent read FOnMenuMerge write FOnMenuMerge; property OnMerge: TdxBarMergeEvent read FOnMerge write FOnMerge; property OnShowCustomizingForm: TNotifyEvent read FOnShowCustomizingForm write FOnShowCustomizingForm; property OnShowCustomizingPopup: TdxBarShowPopupEvent read FOnShowCustomizingPopup write FOnShowCustomizingPopup; property OnShowToolbarsPopup: TdxBarShowPopupEvent read FOnShowToolbarsPopup write FOnShowToolbarsPopup; property OnClickItem: TdxBarClickItemEvent read FOnClickItem write FOnClickItem; end; TdxBarManagerList = class(TdxObjectList) private function GetBarManager(Index: Integer): TdxBarManager; function GetCustomizingBarManager: TdxBarManager; public destructor Destroy; override; function NextActive(ABarManager: TdxBarManager; AGoForward: Boolean): TdxBarManager; property BarManagers[Index: Integer]: TdxBarManager read GetBarManager; default; property CustomizingBarManager: TdxBarManager read GetCustomizingBarManager; end; TdxBarBorderStyle = (bbsNone, bbsSingle); TdxBarStaticBorderStyle = (sbsNone, sbsLowered, sbsRaised, sbsEtched, sbsBump); TdxBarSpinEditButton = (sbNone, sbUp, sbDown); TdxBarSpinEditButtons = set of TdxBarSpinEditButton; TdxBarMergeData = class private FFreeNotificator: TcxFreeNotificator; FMergedBarList: TList; FSavedMergedBarList: TList; procedure FreeNotification(Sender: TComponent); function GetSavedMergedBar(AIndex: Integer): TdxBar; function GetSavedMergedBarListCount: Integer; procedure SetFreeNotifications; protected property FreeNotificator: TcxFreeNotificator read FFreeNotificator; public CreatedByMerging: Boolean; MergedWith: TdxBar; PrevVisible: Boolean; constructor Create; destructor Destroy; override; procedure Assign(ASource: TdxBarMergeData); procedure ClearSavedMergedBarList; procedure SaveMergedBarList(AList: TList = nil); property MergedBarList: TList read FMergedBarList; property SavedMergedBarCount: Integer read GetSavedMergedBarListCount; property SavedMergedBars[AIndex: Integer]: TdxBar read GetSavedMergedBar; end; TdxCollectionNotifyEvent = procedure (Sender: TObject; AItem: TCollectionItem) of Object; { TdxBarAccessibilityHelper } TdxBarAccessibilityHelper = class(TcxAccessibilityHelper, IdxBarAccessibilityHelper) private function InternalGetChild(AIndex: Integer): TdxBarAccessibilityHelper; function InternalGetParent: TdxBarAccessibilityHelper; protected // IcxAccessibilityHelper procedure OwnerObjectDestroyed; override; // IdxBarAccessibilityHelper function AreKeyTipsSupported( out AKeyTipWindowsManager: IdxBarKeyTipWindowsManager): Boolean; virtual; function CanNavigateToChildren(AKey: Word): Boolean; virtual; function GetBarHelper: TdxBarAccessibilityHelper; function GetBarManager: TdxBarManager; virtual; function GetDefaultAccessibleObject: IdxBarAccessibilityHelper; virtual; function GetNextAccessibleObject( ADirection: TcxAccessibilityNavigationDirection): IdxBarAccessibilityHelper; overload; virtual; function GetRootAccessibleObject: IdxBarAccessibilityHelper; function HandleNavigationKey(var AKey: Word): Boolean; virtual; function IsNavigationKey(AKey: Word): Boolean; virtual; function IsSelected: Boolean; function LogicalNavigationGetNextAccessibleObject( AGoForward: Boolean): IdxBarAccessibilityHelper; virtual; procedure Select(ASetFocus: Boolean); virtual; procedure Unselect(ANextSelectedObject: IdxBarAccessibilityHelper); virtual; procedure GetChildrenForNavigation( ASelectedObject, AParentObject: TdxBarAccessibilityHelper; const ASelectedObjectScreenBounds: TRect; ADirection: TcxAccessibilityNavigationDirection; AAreOnlyNearObjectsAccepted: Boolean; AObjects: TList); procedure GetChilds(AChilds: TList; AOnlyVisible: Boolean = True); function GetAssignedKeyTip: string; virtual; abstract; function GetDefaultKeyTip: string; virtual; abstract; function GetKeyTip: string; virtual; function CreateKeyTipData: TdxBarKeyTipData; virtual; procedure GetKeyTipInfo(out AKeyTipInfo: TdxBarKeyTipInfo); virtual; procedure GetKeyTipData(AKeyTipsData: TList); virtual; procedure DoGetKeyTipsData(AKeyTipsData: TList); virtual; procedure GetKeyTipsData(AKeyTipsData: TList); procedure GenerateUniqueKeyTips(AKeyTipsData: TList); function GetParentForKeyTip: TdxBarAccessibilityHelper; virtual; function IsKeyTipContainer: Boolean; virtual; procedure KeyTipHandler(Sender: TObject); virtual; procedure KeyTipsEscapeHandler; virtual; function LogicalNavigationGetChild(AIndex: Integer): TdxBarAccessibilityHelper; virtual; function LogicalNavigationGetChildCount: Integer; virtual; function LogicalNavigationGetChildIndex( AChild: TdxBarAccessibilityHelper): Integer; virtual; function LogicalNavigationGetNextChild(AChildIndex: Integer; AGoForward: Boolean): TdxBarAccessibilityHelper; property ParentForKeyTip: TdxBarAccessibilityHelper read GetParentForKeyTip; public function GetFirstSelectableObject: TdxBarAccessibilityHelper; property BarManager: TdxBarManager read GetBarManager; property Childs[AIndex: Integer]: TdxBarAccessibilityHelper read InternalGetChild; property Parent: TdxBarAccessibilityHelper read InternalGetParent; end; TdxBarAccessibilityHelperClass = class of TdxBarAccessibilityHelper; TdxBarCaptionButton = class(TCollectionItem, {$IFNDEF DELPHI6}IUnknown, {$ENDIF}IdxBarHintKeeper) private FEnabled: Boolean; FGlyph: TBitmap; FHint: string; FIAccessibilityHelper: IdxBarAccessibilityHelper; FKeyTip: string; FNotifyComponent: TcxFreeNotificator; FRect: TRect; FScreenTip: TdxBarScreenTip; FState: Integer; FOnClick: TNotifyEvent; function GetCollection: TdxBarCaptionButtons; function GetIAccessibilityHelper: IdxBarAccessibilityHelper; function GetParent: TdxBarControl; procedure GlyphChanged(Sender: TObject); procedure SetEnabled(Value: Boolean); procedure SetGlyph(Value: TBitmap); procedure SetScreenTip(Value: TdxBarScreenTip); procedure SetState(Value: Integer); procedure SetOnClick(Value: TNotifyEvent); procedure FreeNotification(AComponent: TComponent); property Parent: TdxBarControl read GetParent; protected function GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; virtual; // IUnknown function _AddRef: Integer; stdcall; function _Release: Integer; stdcall; function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall; // IdxBarHintKeeper function DoHint(var ANeedDeactivate: Boolean; out AHintText: string; out AShortCut: string): Boolean; function CreateHintViewInfo(const AHintText, AShortCut: string): TdxBarCustomHintViewInfo; function GetEnabled: Boolean; function GetHintPosition(const ACursorPos: TPoint; AHeight: Integer): TPoint; public constructor Create(Collection: TCollection); override; destructor Destroy; override; procedure Assign(Source: TPersistent); override; procedure Click; property Collection: TdxBarCaptionButtons read GetCollection; property Glyph: TBitmap read FGlyph write SetGlyph; property IAccessibilityHelper: IdxBarAccessibilityHelper read GetIAccessibilityHelper; property Rect: TRect read FRect write FRect; property State: Integer read FState write SetState; published property Enabled: Boolean read FEnabled write SetEnabled default True; property Hint: string read FHint write FHint; property KeyTip: string read FKeyTip write FKeyTip; property ScreenTip: TdxBarScreenTip read FScreenTip write SetScreenTip; property OnClick: TNotifyEvent read FOnClick write SetOnClick; end; TdxBarCaptionButtons = class(TCollection) private FBar: TdxBar; FIAccessibilityHelper: IdxBarAccessibilityHelper; FOnNotify: TdxCollectionNotifyEvent; function GetIAccessibilityHelper: IdxBarAccessibilityHelper; function GetItem(Index: Integer): TdxBarCaptionButton; function GetRect: TRect; procedure SetItem(Index: Integer; Value: TdxBarCaptionButton); protected function GetOwner: TPersistent; override; procedure Update(Item: TCollectionItem); override; function GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; virtual; function GetButtonIndex(const APoint: TPoint): Integer; public constructor Create(ABar: TdxBar); destructor Destroy; override; function Add: TdxBarCaptionButton; procedure UpdateButtonStates(const AMousePos: TPoint; AMousePressed: Boolean = False); property Bar: TdxBar read FBar; property IAccessibilityHelper: IdxBarAccessibilityHelper read GetIAccessibilityHelper; property Items[Index: Integer]: TdxBarCaptionButton read GetItem write SetItem; default; property Rect: TRect read GetRect; property OnNotify: TdxCollectionNotifyEvent read FOnNotify write FOnNotify; end; TdxBar = class(TcxComponentCollectionItem, {$IFNDEF DELPHI6}IUnknown,{$ENDIF} IdxBarSelectableItem, IdxBarLinksOwner) private FAllowClose: Boolean; FAllowCustomizing: Boolean; FAllowQuickCustomizing: Boolean; FAllowReset: Boolean; FAlphaBlendValue: Byte; FBackgroundBitmap: TBitmap; FBorderStyle: TdxBarBorderStyle; FCaption: string; FCaptionButtons: TdxBarCaptionButtons; FChanged: Boolean; FColor: TColor; FChangingDockingStyle: Boolean; FDockControl: TdxBarDockControl; FDockedDockControl: TdxBarDockControl; FDockedDockingStyle: TdxBarDockingStyle; FDockedLeft: Integer; FDockedTop: Integer; FDockingStyle: TdxBarDockingStyle; FDockRow: TdxDockRow; FEditFont: TFont; FFloatLeft: Integer; FFloatTop: Integer; FFloatClientWidth: Integer; FFloatClientHeight: Integer; FFont: TFont; FFreeNotificationItems: TList; FGlyph: TBitmap; FHidden: Boolean; // if True, then doesn't show in customizing form in run-time FInternalFontChange: Boolean; FInternallyHidden: Boolean; FIsMainMenu: Boolean; FIsNameLocked: Boolean; FIsPredefined: Boolean; FItemLinks: TdxBarItemLinks; FKeyTip: string; FLoadedDockControl: TdxBarDockControl; FLoadedDockingStyle: TdxBarDockingStyle; FLoadedVisible: Boolean; FLockUpdate: Boolean; FMergeData: TdxBarMergeData; FNeedUpdateControlPosition: Boolean; // FName: TComponentName; FNotDocking: TdxBarDockingStyles; FMultiLine: Boolean; FOneOnRow: Boolean; FOldName: string; FRotateWhenVertical: Boolean; FRow: Integer; FShowMark: Boolean; FSizeGrip: Boolean; FUseOwnFont: Boolean; FUseRestSpace: Boolean; FVisible: Boolean; // is it currently visible or not? FWholeRow: Boolean; FOnDestroy: TNotifyEvent; procedure BitmapChanged(Sender: TObject); procedure DoDestroy; function GetBars: TdxBars; function GetControl: TdxBarControl; function GetDockControl: TdxBarDockControl; function GetDockedDockingStyle: TdxBarDockingStyle; function GetDockingStyle: TdxBarDockingStyle; function GetNext: TdxBar; function GetNotDocking: TdxBarDockingStyles; function GetPainter: TdxBarPainter; function GetRealDockControl: TdxDockControl; function GetRow: Integer; function GetUseRecentItems: Boolean; function GetVisible: Boolean; procedure GlyphChanged(Sender: TObject); procedure SetAllowClose(Value: Boolean); procedure SetAllowQuickCustomizing(Value: Boolean); procedure SetAlphaBlendValue(Value: Byte); procedure SetBackgroundBitmap(Value: TBitmap); procedure SetBorderStyle(Value: TdxBarBorderStyle); procedure SetCaption(Value: string); procedure SetCaptionButtons(Value: TdxBarCaptionButtons); procedure SetColor(Value: TColor); procedure SetDockControl(Value: TdxBarDockControl); procedure SetDockedDockControl(Value: TdxBarDockControl); procedure SetDockedValue(Index: Integer; Value: Integer); procedure SetDockingStyle(Value: TdxBarDockingStyle); procedure SetDockRow(Value: TdxDockRow); procedure SetFloatValue(Index: Integer; Value: Integer); procedure SetFont(Value: TFont); procedure SetGlyph(Value: TBitmap); procedure SetHidden(Value: Boolean); procedure SetIsMainMenu(Value: Boolean); procedure SetItemLinks(Value: TdxBarItemLinks); procedure SetLockUpdate(Value: Boolean); procedure SetMultiLine(Value: Boolean); procedure SetNotDocking(Value: TdxBarDockingStyles); procedure SetOneOnRow(Value: Boolean); procedure SetRotateWhenVertical(Value: Boolean); procedure SetRow(Value: Integer); procedure SetShowMark(Value: Boolean); procedure SetSizeGrip(Value: Boolean); procedure SetUseOwnFont(Value: Boolean); procedure SetUseRecentItems(Value: Boolean); procedure SetUseRestSpace(Value: Boolean); procedure SetVisible(Value: Boolean); procedure SetWholeRow(Value: Boolean); procedure FontChanged(Sender: TObject); procedure UpdateControlPosition; function IsDockedDockingStyleStored: Boolean; function IsDockingStyleStored: Boolean; protected procedure AddFreeNotification(AItem: TdxBarItem); procedure RemoveFreeNotification(AItem: TdxBarItem); procedure MakeFreeNotification; procedure RemoveFromDockRow(ADestroyEmptyDockRow: Boolean); procedure SetName(const NewName: TComponentName); override; procedure Updated; override; procedure Updating; override; function CreateControl: TdxBarControl; function GetControlClass: TdxBarControlClass; virtual; procedure ShowControl; class function GetIniSection(const ABaseSection: string; ABarIndex: Integer): string; procedure LoadFromIni(ASource: TCustomIniFile; const ABaseSection: string; ABarIndex: Integer; AStoringKind: TdxBarStoringKind; AFullLoad: Boolean = True); procedure LoadUsageData(ASource: TCustomIniFile; const ABaseSection: string; ABarIndex: Integer); procedure SaveToIni(ADestination: TCustomIniFile; const ABaseSection: string; ABarIndex: Integer; AStoringKind: TdxBarStoringKind); procedure InternalMerge(ABar: TdxBar; ASaveMergingBarVisibility: Boolean); procedure InternalUnmergeFromBar(ABar: TdxBar; ARestoreMergedBarsVisibility: Boolean); procedure InternalUnmergeFromBarManager(ABarManager: TdxBarManager; ARestoreMergedBarsVisibility: Boolean); procedure RestoreMergeState; procedure SaveMergeState; procedure SetVisibility(Value: Boolean); procedure CaptionButtonsNotification(Sender: TObject; AItem: TCollectionItem); virtual; procedure DoChanged; function BarNCSizeX(AStyle: TdxBarDockingStyle): Integer; function BarNCSizeY(AStyle: TdxBarDockingStyle): Integer; function CanClose: Boolean; function CanMoving: Boolean; function CanReset: Boolean; function GetDockedPosition: Integer; function HasSizeGrip: Boolean; function IsFloat: Boolean; function IsShortCut(AShortCut: TShortCut): Boolean; function IsStatusBar: Boolean; // IdxBarSelectableItem function CanDelete(ADestruction: Boolean = False): Boolean; procedure DeleteSelection(var AReference: IdxBarSelectableItem; ADestruction: Boolean); procedure ExecuteCustomizationAction(ABasicAction: TdxBarCustomizationAction); function GetBarManager: TdxBarManager; function IdxBarSelectableItem.GetInstance = GetPersistentInstance; procedure GetMasterObjects(AList: TdxObjectList); function GetNextSelectableItem: IdxBarSelectableItem; function GetSelectableParent: TPersistent; function GetSelectionStatus: TdxBarSelectionStatus; function GetSupportedActions: TdxBarCustomizationActions; procedure Invalidate; function IsComplex: Boolean; function IsComponentSelected: Boolean; procedure SelectComponent(ASelectionOperation: TdxBarSelectionOperation = soExclusive); function SelectParentComponent: Boolean; procedure SelectionChanged; // IdxBarLinksOwner function CanContainItem(AItem: TdxBarItem; out AErrorText: string): Boolean; function CreateBarControl: TCustomdxBarControl; function IdxBarLinksOwner.GetInstance = GetComponentInstance; function GetItemLinks: TdxBarItemLinks; function GetComponentInstance: TComponent; function GetPersistentInstance: TPersistent; property MergeData: TdxBarMergeData read FMergeData; property Painter: TdxBarPainter read GetPainter; property OnDestroy: TNotifyEvent read FOnDestroy write FOnDestroy; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; procedure Assign(Source: TPersistent); override; procedure ChangeDockingStyle(AStyle: TdxBarDockingStyle; ADockControl: TdxDockControl); function GetCollectionFromParent(AParent: TComponent): TcxComponentCollection; override; function IsVertical: Boolean; procedure Move(X, Y: Integer); overload; procedure Move(ADockControl: TdxDockControl; ARow, APosition: Integer); overload; procedure Move(ADockingStyle: TdxBarDockedDockingStyle; ARow, APosition: Integer); overload; procedure Move(ABar: TdxBar; AInsertAfter: Boolean = True); overload; procedure Reset; procedure ResetWithConfirmation; procedure SetParentComponent(AParent: TComponent); override; procedure Merge(ABar: TdxBar); procedure Unmerge(ABar: TdxBar = nil); property BarManager: TdxBarManager read GetBarManager; property Bars: TdxBars read GetBars; property Control: TdxBarControl read GetControl; property DockRow: TdxDockRow read FDockRow write SetDockRow; property IsPredefined: Boolean read FIsPredefined; property LockUpdate: Boolean read FLockUpdate write SetLockUpdate; property RealDockControl: TdxDockControl read GetRealDockControl; published property AllowClose: Boolean read FAllowClose write SetAllowClose default True; property AllowCustomizing: Boolean read FAllowCustomizing write FAllowCustomizing default True; property AllowQuickCustomizing: Boolean read FAllowQuickCustomizing write SetAllowQuickCustomizing default True; property AllowReset: Boolean read FAllowReset write FAllowReset default True; property BorderStyle: TdxBarBorderStyle read FBorderStyle write SetBorderStyle default bbsSingle; property Caption: string read FCaption write SetCaption; property CaptionButtons: TdxBarCaptionButtons read FCaptionButtons write SetCaptionButtons; property Color: TColor read FColor write SetColor default clDefault; property DockControl: TdxBarDockControl read GetDockControl write SetDockControl; property DockedDockControl: TdxBarDockControl read FDockedDockControl write SetDockedDockControl; property DockedDockingStyle: TdxBarDockingStyle read GetDockedDockingStyle write FDockedDockingStyle stored IsDockedDockingStyleStored; property DockedLeft: Integer index 1 read FDockedLeft write SetDockedValue; property DockedTop: Integer index 2 read FDockedTop write SetDockedValue; property DockingStyle: TdxBarDockingStyle read GetDockingStyle write SetDockingStyle stored IsDockingStyleStored; property FloatLeft: Integer index 1 read FFloatLeft write SetFloatValue; property FloatTop: Integer index 2 read FFloatTop write SetFloatValue; property FloatClientWidth: Integer index 3 read FFloatClientWidth write SetFloatValue; property FloatClientHeight: Integer index 4 read FFloatClientHeight write SetFloatValue; property Font: TFont read FFont write SetFont stored FUseOwnFont; property Glyph: TBitmap read FGlyph write SetGlyph; property Hidden: Boolean read FHidden write SetHidden default False; property IsMainMenu: Boolean read FIsMainMenu write SetIsMainMenu default False; property ItemLinks: TdxBarItemLinks read GetItemLinks write SetItemLinks; property KeyTip: string read FKeyTip write FKeyTip; property MultiLine: Boolean read FMultiLine write SetMultiLine default False; // property Name: TComponentName read FName write SetName; property NotDocking: TdxBarDockingStyles read GetNotDocking write SetNotDocking default []; property OldName: string read FOldName write FOldName; property OneOnRow: Boolean read FOneOnRow write SetOneOnRow; property RotateWhenVertical: Boolean read FRotateWhenVertical write SetRotateWhenVertical default True; property Row: Integer read GetRow write SetRow; property ShowMark: Boolean read FShowMark write SetShowMark default True; property SizeGrip: Boolean read FSizeGrip write SetSizeGrip default True; property UseOwnFont: Boolean read FUseOwnFont write SetUseOwnFont; property UseRecentItems: Boolean read GetUseRecentItems write SetUseRecentItems default True; property UseRestSpace: Boolean read FUseRestSpace write SetUseRestSpace default False; property Visible: Boolean read GetVisible write SetVisible; property WholeRow: Boolean read FWholeRow write SetWholeRow; property BackgroundBitmap: TBitmap read FBackgroundBitmap write SetBackgroundBitmap; property AlphaBlendValue: Byte read FAlphaBlendValue write SetAlphaBlendValue default 255; end; TdxDockControls = array[dsLeft..dsBottom] of TdxDockControl; TdxBars = class(TcxComponentCollection) private FDockControls: TdxDockControls; FDocking: Boolean; FDockingZoneSize: Integer; FBarManager: TdxBarManager; FMoving: Boolean; FMovingBarControl: TdxBarControl; FMovingBarOriginalDockingStyle: TdxBarDockingStyle; FMovingOffset: TPoint; FMovingStaticOffset: TPoint; function GetDockControl(Index: TdxBarDockingStyle): TdxDockControl; function GetItem(Index: Integer): TdxBar; procedure SetItem(Index: Integer; Value: TdxBar); protected // function GetOwner: TPersistent; override; procedure RegInDock(AStyle: TdxBarDockingStyle; ADockControl: TdxDockControl; ABarControl: TdxBarControl; APos: TPoint); procedure UnregFromDock(AStyle: TdxBarDockingStyle; ADockControl: TdxDockControl; ABarControl: TdxBarControl); procedure ChangeBarControlPos(ABarControl: TdxBarControl; APos: TPoint); function GetDockingStyleAtPos(Bar: TdxBar; Pos: TPoint; var DockControl: TdxDockControl): TdxBarDockingStyle; procedure Moving(AMovingBarControl: TdxBarControl); procedure Repaint; procedure SetItemName(AItem: TcxComponentCollectionItem); override; procedure Update(AItem: TcxComponentCollectionItem; AAction: TcxComponentCollectionNotification); override; property DockingZoneSize: Integer read FDockingZoneSize write FDockingZoneSize; public constructor Create(ABarManager: TdxBarManager); reintroduce; destructor Destroy; override; function Add: TdxBar; function GetUniqueToolbarName(const ABaseName: string): string; function Insert(Index: Integer): TdxBar; property BarManager: TdxBarManager read FBarManager; property DockControls[Index: TdxBarDockingStyle]: TdxDockControl read GetDockControl; property IsMoving: Boolean read FMoving; property Items[Index: Integer]: TdxBar read GetItem write SetItem; default; end; TdxBarUserDefine = (udCaption, udGlyph, udPaintStyle, udWidth); TdxBarUserDefines = set of TdxBarUserDefine; TdxBarPaintStyle = (psStandard, psCaption, psCaptionInMenu, psCaptionGlyph); TdxBarItemControlPart = (cpIcon, cpText); TdxBarItemControlViewStructure = set of TdxBarItemControlPart; TdxBarItemControlViewSize = (cvsSmall, cvsMedium, cvsLarge); TdxBarItemOptionValue = (ioShowDescriptions, ioShowShortCuts, ioSize); TdxBarItemOptionValues = set of TdxBarItemOptionValue; TdxBarItemOptions = class(TPersistent) private FItemLinks: TdxBarItemLinks; FAssignedValues: TdxBarItemOptionValues; FShowDescriptions: Boolean; FShowShortCuts: Boolean; FSize: TdxBarMenuItemSize; function GetAssignedValues: TdxBarItemOptionValues; function GetDefaultValue(AOption: TdxBarItemOptionValue): Variant; function GetValue(AOption: TdxBarItemOptionValue): Variant; function GetShowDescriptions: Boolean; function GetShowShortCuts: Boolean; function GetSize: TdxBarMenuItemSize; procedure SetAssignedValues(AValue: TdxBarItemOptionValues); procedure SetShowDescriptions(AValue: Boolean); procedure SetShowShortCuts(AValue: Boolean); procedure SetSize(AValue: TdxBarMenuItemSize); function IsValueStored(AOption: TdxBarItemOptionValue): Boolean; function IsShowDescriptionsStored: Boolean; function IsShowShortCutsStored: Boolean; function IsSizeStored: Boolean; public constructor Create(AItemLinks: TdxBarItemLinks); procedure Assign(Source: TPersistent); override; published property AssignedValues: TdxBarItemOptionValues read GetAssignedValues write SetAssignedValues stored False; property ShowDescriptions: Boolean read GetShowDescriptions write SetShowDescriptions stored IsShowDescriptionsStored; property ShowShortCuts: Boolean read GetShowShortCuts write SetShowShortCuts stored IsShowShortCutsStored; property Size: TdxBarMenuItemSize read GetSize write SetSize stored IsSizeStored; end; TdxBarItemLink = class(TCollectionItem,{$IFNDEF DELPHI6} IUnknown,{$ENDIF} IdxBarSelectableItem) private FBeginGroup: Boolean; FButtonGroup: TdxBarButtonGroupPosition; FControl: TdxBarItemControl; FCreatedFromMergingWith: TdxBar; FData: {$IFDEF CLR}TObject{$ELSE}Integer{$ENDIF}; FIsMarkedForDeletion: Boolean; FItem: TdxBarItem; FItemRect: TRect; FLoadedItemName: string; FLoadedRecentIndex: Integer; FLoadedUseCount: Integer; FLoadedVisible: Boolean; FMostRecentlyUsed: Boolean; FOriginalItemLink: TdxBarItemLink; FPosition: TdxBarItemPosition; FPrevItemName: string; FPrevRecentIndex: Integer; FRefCount: Integer; FRowHeight: Integer; FUseCount: Integer; FUserCaption: string; FUserDefine: TdxBarUserDefines; FUserGlyph: TBitmap; FUserPaintStyle: TdxBarPaintStyle; FUserWidth: Integer; FViewLevels: TdxBarItemViewLevels; FVisible: Boolean; function GetAllowedViewLevels: TdxBarItemViewLevels; function GetAvailableIndex: Integer; function GetBarControl: TCustomdxBarControl; function GetBeginGroup: Boolean; function GetCanVisibleIndex: Integer; function GetCaption: string; function GetCollection: TdxBarItemLinks; function GetGlyph: TBitmap; function GetItem: TdxBarItem; function GetNext: TdxBarItemLink; function GetOwnerValue: TdxBarItemLinks; function GetPaintStyle: TdxBarPaintStyle; function GetUserDefine: TdxBarUserDefines; function GetVisibleIndex: Integer; function GetWidth: Integer; procedure ReadItemName(AReader: TReader); procedure SetBeginGroup(Value: Boolean); procedure SetButtonGroup(Value: TdxBarButtonGroupPosition); procedure SetCollection(Value: TdxBarItemLinks); reintroduce; virtual; procedure SetItem(Value: TdxBarItem); procedure SetItemRect(Value: TRect); procedure SetMostRecentlyUsed(Value: Boolean); procedure SetPosition(Value: TdxBarItemPosition); procedure ForceSetUserDefine(AValue: TdxBarUserDefine); procedure SetUserDefine(Value: TdxBarUserDefines); procedure SetUserCaption(const Value: string); procedure SetUserGlyph(Value: TBitmap); procedure SetUserPaintStyle(Value: TdxBarPaintStyle); procedure SetUserWidth(Value: Integer); procedure SetViewLevels(Value: TdxBarItemViewLevels); procedure SetVisible(Value: Boolean); procedure WriteItemName(AWriter: TWriter); procedure AddToRecentList; procedure RemoveFromRecentList; procedure RestoreRecentIndex; procedure SaveRecentIndex; procedure InternalBringToTopInRecentList(IncCount: Boolean); procedure Synchronize(AItemLink: TdxBarItemLink); procedure CheckMostRecentlyUsed; function GetRecentIndex: Integer; procedure SetRecentIndex(Value: Integer); property RecentIndex: Integer read GetRecentIndex write SetRecentIndex; function CanVisible: Boolean; function GetRealItemLink: TdxBarItemLink; procedure OnUserGlyphChanged(Sender: TObject); protected procedure DefineProperties(Filer: TFiler); override; procedure LoadItemName; class function GetIniSection(const ABaseSection: string; ALinkIndex: Integer; AStoringKind: TdxBarStoringKind): string; procedure LoadFromIni(ASource: TCustomIniFile; const ABaseSection: string; ALinkIndex: Integer; AStoringKind: TdxBarStoringKind); procedure LoadUsageData(ASource: TCustomIniFile; ABaseSection: string; ALinkIndex: Integer); procedure SaveToIni(ADestination: TCustomIniFile; const ABaseSection: string; ALinkIndex: Integer; AStoringKind: TdxBarStoringKind); procedure InitiateAction; function CanChangePaintStyle: Boolean; function HasItem(AItem: TdxBarItem): Boolean; function IsReferencedBy(ALinksOwner: IdxBarLinksOwner): Boolean; function IsAccel(Key: Word; Shift: TShiftState): Boolean; procedure MoveBeginGroupItemIfNeeded; function ScreenToClient(const AScreenPos: TPoint): TPoint; procedure UserGlyphChanged; virtual; // IUnknown function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall; function _AddRef: Integer; stdcall; function _Release: Integer; stdcall; // IdxBarSelectableItem function CanDelete(ADestruction: Boolean = False): Boolean; procedure DeleteSelection(var AReference: IdxBarSelectableItem; ADestruction: Boolean); procedure ExecuteCustomizationAction(ABasicAction: TdxBarCustomizationAction); function GetBarManager: TdxBarManager; function GetInstance: TPersistent; procedure GetMasterObjects(AList: TdxObjectList); function GetNextSelectableItem: IdxBarSelectableItem; function GetSelectableParent: TPersistent; function GetSelectionStatus: TdxBarSelectionStatus; function GetSupportedActions: TdxBarCustomizationActions; procedure Invalidate; function IsComplex: Boolean; function IsComponentSelected: Boolean; procedure SelectComponent(ASelectionOperation: TdxBarSelectionOperation = soExclusive); function SelectParentComponent: Boolean; procedure SelectionChanged; property IsMarkedForDeletion: Boolean read FIsMarkedForDeletion; property RowHeight: Integer read FRowHeight write FRowHeight; public constructor Create(Collection: TCollection); override; destructor Destroy; override; procedure Assign(Source: TPersistent); override; procedure BringToTopInRecentList(IncCount: Boolean); procedure CreateControl; procedure DestroyControl; procedure SendToBottomInRecentList; property AvailableIndex: Integer read GetAvailableIndex; property BarControl: TCustomdxBarControl read GetBarControl; property BarManager: TdxBarManager read GetBarManager; property CanVisibleIndex: Integer read GetCanVisibleIndex; property Caption: string read GetCaption; property Collection: TdxBarItemLinks read GetCollection write SetCollection; property Control: TdxBarItemControl read FControl; property Data: {$IFDEF CLR}TObject{$ELSE}Integer{$ENDIF} read FData write FData {$IFNDEF CLR}default 0{$ENDIF}; property Glyph: TBitmap read GetGlyph; property ItemRect: TRect read FItemRect write SetItemRect; property OriginalItemLink: TdxBarItemLink read FOriginalItemLink; property Owner: TdxBarItemLinks read GetOwnerValue; property PaintStyle: TdxBarPaintStyle read GetPaintStyle; property RealItemLink: TdxBarItemLink read GetRealItemLink; property VisibleIndex: Integer read GetVisibleIndex; property Width: Integer read GetWidth; published property BeginGroup: Boolean read GetBeginGroup write SetBeginGroup default False; property ButtonGroup: TdxBarButtonGroupPosition read FButtonGroup write SetButtonGroup default bgpNone; property Item: TdxBarItem read GetItem write SetItem stored False; property MostRecentlyUsed: Boolean read FMostRecentlyUsed write SetMostRecentlyUsed default True; property Position: TdxBarItemPosition read FPosition write SetPosition default dxBarItemDefaultPosition; property UserCaption: string read FUserCaption write SetUserCaption; property UserDefine: TdxBarUserDefines read GetUserDefine write SetUserDefine default []; property UserGlyph: TBitmap read FUserGlyph write SetUserGlyph; property UserPaintStyle: TdxBarPaintStyle read FUserPaintStyle write SetUserPaintStyle default psStandard; property UserWidth: Integer read FUserWidth write SetUserWidth default 0; property ViewLevels: TdxBarItemViewLevels read FViewLevels write SetViewLevels default dxBarItemAllViewLevels; property Visible: Boolean read FVisible write SetVisible; end; TdxBarIterationProc = procedure(Index: Integer; ItemLink: TdxBarItemLink; var Stop: Boolean; var Data: Pointer) of object; TdxBarItemLinks = class(TCollection) private FAssigning: Boolean; FAvailableItems, FCanVisibleItems, FVisibleItems: TList; FBarControl: TCustomdxBarControl; FBarManager: TdxBarManager; FInternal: Boolean; FItemOptions: TdxBarItemOptions; FLinksOwner: IdxBarLinksOwner; FPrevRecentItemCount: Integer; FRecentItems: TList; FRecentItemCount: Integer; FUseRecentItems: Boolean; FOnChange: TNotifyEvent; procedure DesignerModified; function GetAvailableItem(Index: Integer): TdxBarItemLink; function GetAvailableItemCount: Integer; function GetCanVisibleItem(Index: Integer): TdxBarItemLink; function GetCanVisibleItemCount: Integer; function GetIndexByItemName(const AItemName: string): Integer; function GetItem(Index: Integer): TdxBarItemLink; function GetMostRecentItemCount: Integer; function GetParentLinks: TdxBarItemLinks; function GetRealVisibleItemCount: Integer; function GetItemShowDescriptions: Boolean; function GetItemShowShortCuts: Boolean; function GetItemSize: TdxBarMenuItemSize; function GetVisibleItem(Index: Integer): TdxBarItemLink; function GetVisibleItemCount: Integer; procedure SetItem(Index: Integer; Value: TdxBarItemLink); procedure SetItemOptions(AValue: TdxBarItemOptions); procedure SetRecentItemCount(Value: Integer); function IsUpdateLocked: Boolean; procedure RefreshVisibilityLists; property MostRecentItemCount: Integer read GetMostRecentItemCount; procedure RestoreRecentItemCount; property RecentItemCount: Integer read FRecentItemCount write SetRecentItemCount; procedure Loaded(CheckVisible: Boolean); procedure CheckVisibleIntegrity; property ParentLinks: TdxBarItemLinks read GetParentLinks; protected procedure EmptyItemRects; function CanUseRecentItems: Boolean; procedure InitiateActions; function IsShortCut(AShortCut: TShortCut): Boolean; function IsScrollable: Boolean; virtual; function DoFindItemWithAccel(AKey: Word; AShift: TShiftState; ACurrentLink: TdxBarItemLink): TdxBarItemLink; virtual; abstract; function FindItemWithAccel(AKey: Word; AShift: TShiftState; ACurrentLink: TdxBarItemLink): TdxBarItemLink; function First: TdxBarItemLink; function Last: TdxBarItemLink; function Next(Current: TdxBarItemLink; AAnyone: Boolean = False): TdxBarItemLink; function Prev(Current: TdxBarItemLink; AAnyone: Boolean = False): TdxBarItemLink; procedure CheckLinks(ASource: TCustomIniFile; const ABaseSection: string); procedure LoadFromIni(ASource: TCustomIniFile; const ASection: string; AStoringKind: TdxBarStoringKind); procedure LoadUsageData(ASource: TCustomIniFile; ASection: string); procedure SaveToIni(ADestination: TCustomIniFile; const ASection: string; AStoringKind: TdxBarStoringKind); procedure Merge(AItemLinks: TdxBarItemLinks); procedure Unmerge(ABar: TdxBar); function AddItem(AItemClass: TdxBarItemClass; AOwner: TComponent): TdxBarItemLink; overload; function GetOwner: TPersistent; override; function GetOwnerComponent: TComponent; procedure LoadItemNames; procedure Update(Item: TCollectionItem); override; property Internal: Boolean read FInternal write FInternal; property RealVisibleItemCount: Integer read GetRealVisibleItemCount; function GetDefaultValue(AOption: TdxBarItemOptionValue): Variant; virtual; function GetOptionsValue(AOption: TdxBarItemOptionValue; AItemLinks: TdxBarItemLinks): Variant; virtual; property ItemShowDescriptions: Boolean read GetItemShowDescriptions; property ItemShowShortCuts: Boolean read GetItemShowShortCuts; property ItemSize: TdxBarMenuItemSize read GetItemSize; public constructor Create(ABarManager: TdxBarManager; ALinksOwner: IdxBarLinksOwner); destructor Destroy; override; function Add: TdxBarItemLink; overload; function Add(AItem: TdxBarItem): TdxBarItemLink; overload; function AddItem(AItemClass: TdxBarItemClass): TdxBarItemLink; overload; function AddButton: TdxBarItemLink; function AddSubItem: TdxBarItemLink; procedure Assign(Source: TPersistent); override; function AvailableIndexOf(Value: TdxBarItemLink): Integer; function CanContainItem(AItem: TdxBarItem; out AErrorText: string): Boolean; function CanVisibleIndexOf(Value: TdxBarItemLink): Integer; procedure CreateBarControl; procedure DestroyBarControl; procedure FreeForeignItems(ForeignBarManager: TdxBarManager); function HasItem(AItem: TdxBarItem): Boolean; function IsControlExists(AItem: TdxBarItemControl): Boolean; function IsReferencedBy(ALinksOwner: IdxBarLinksOwner): Boolean; function IndexOf(Value: TdxBarItemLink): Integer; function Insert(AIndex: Integer): TdxBarItemLink; function VisibleIndexOf(Value: TdxBarItemLink): Integer; procedure Move(ACurIndex, ANewIndex: Integer); property AvailableItems[Index: Integer]: TdxBarItemLink read GetAvailableItem; property AvailableItemCount: Integer read GetAvailableItemCount; property BarControl: TCustomdxBarControl read FBarControl write FBarControl; property BarManager: TdxBarManager read FBarManager; property CanVisibleItems[Index: Integer]: TdxBarItemLink read GetCanVisibleItem; property CanVisibleItemCount: Integer read GetCanVisibleItemCount; property Items[Index: Integer]: TdxBarItemLink read GetItem write SetItem; default; property ItemOptions: TdxBarItemOptions read FItemOptions write SetItemOptions; property VisibleItems[Index: Integer]: TdxBarItemLink read GetVisibleItem; property VisibleItemCount: Integer read GetVisibleItemCount; {$WARNINGS OFF} property Owner: TComponent read GetOwnerComponent; // TdxBar, TdxBarPopupMenu, TCustomdxBarSubItem, nil {$WARNINGS ON} property OnChange: TNotifyEvent read FOnChange write FOnChange; end; TdxBarControlItemLinks = class(TdxBarItemLinks) protected function DoFindItemWithAccel(AKey: Word; AShift: TShiftState; ACurrentLink: TdxBarItemLink): TdxBarItemLink; override; end; TdxBarSubMenuControlItemLinks = class(TdxBarItemLinks) protected function DoFindItemWithAccel(AKey: Word; AShift: TShiftState; ACurrentLink: TdxBarItemLink): TdxBarItemLink; override; function IsScrollable: Boolean; override; end; TdxBarPaintSubMenuBarEvent = procedure(Sender: TObject; Canvas: TCanvas; const R: TRect) of object; TdxBarCustomPopupMenu = class(TdxBarComponent, IcxPopupMenu, IdxBarLinksOwner, IdxBarSubMenuOwner) private FBackgroundBitmap: TBitmap; FBarSize: Integer; FEditFont: TFont; FFont: TFont; FInternalFontChange: Boolean; FItemLinks: TdxBarItemLinks; FOwnerBounds: PRect; FOwnerItemControl: TdxBarItemControl; FOwnerControl: TWinControl; FOwnerWidth, FOwnerHeight: Integer; FPopupMenuVisible: Boolean; FShowAnimation: Boolean; FUseOwnFont: Boolean; FUseOwnMessageLoop: Boolean; FOnCloseUp: TNotifyEvent; FOnPaintBar: TdxBarPaintSubMenuBarEvent; FOnPopup: TNotifyEvent; function GetItemOptions: TdxBarItemOptions; function GetSubMenuControl: TdxBarSubMenuControl; function GetUseRecentItems: Boolean; procedure SetBackgroundBitmap(Value: TBitmap); procedure SetBarManager(Value: TdxBarManager); procedure SetBarSize(Value: Integer); procedure SetFont(Value: TFont); procedure SetItemLinks(Value: TdxBarItemLinks); procedure SetItemOptions(Value: TdxBarItemOptions); procedure SetUseOwnFont(Value: Boolean); procedure SetUseRecentItems(Value: Boolean); procedure FontChanged(Sender: TObject); procedure SubMenuCloseUp(Sender: TObject); procedure SubMenuPopup(Sender: TObject); procedure OwnerDesignerModified; protected function GetEnabled: Boolean; override; procedure SetEnabled(Value: Boolean); override; procedure SetVisible(Value: TdxBarItemVisible); override; function GetControlClass: TCustomdxBarControlClass; virtual; function GetItemLinksClass: TdxBarItemLinksClass; virtual; function IsShortCut(AShortCut: TShortCut): Boolean; function IsShortCutKey(var Message: TWMKey): Boolean; procedure Loaded; override; // IdxBarLinksOwner function CanContainItem(AItem: TdxBarItem; out AErrorText: string): Boolean; function CreateBarControl: TCustomdxBarControl; virtual; function IdxBarLinksOwner.GetInstance = GetComponentInstance; function GetItemLinks: TdxBarItemLinks; // IdxBarSubMenuOwner function GetBarSize: Integer; procedure DoPaintBar(Canvas: TCanvas; const R: TRect); virtual; property ItemOptions: TdxBarItemOptions read GetItemOptions write SetItemOptions; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; procedure Popup(X, Y: Integer); procedure PopupEx(X, Y, AOwnerWidth, AOwnerHeight: Integer; AShowAnimation: Boolean; AOwnerBounds: PRect; AUseOwnMessageLoop: Boolean = True; AOwnerControl: TWinControl = nil); procedure PopupFromCursorPos; property BackgroundBitmap: TBitmap read FBackgroundBitmap write SetBackgroundBitmap; property BarManager: TdxBarManager read GetBarManager write SetBarManager; property BarSize: Integer read GetBarSize write SetBarSize default 0; property Font: TFont read FFont write SetFont stored FUseOwnFont; property ItemLinks: TdxBarItemLinks read GetItemLinks write SetItemLinks; property SubMenuControl: TdxBarSubMenuControl read GetSubMenuControl; property UseOwnFont: Boolean read FUseOwnFont write SetUseOwnFont; property UseRecentItems: Boolean read GetUseRecentItems write SetUseRecentItems default False; property Visible: Boolean read FPopupMenuVisible; property OnCloseUp: TNotifyEvent read FOnCloseUp write FOnCloseUp; property OnPaintBar: TdxBarPaintSubMenuBarEvent read FOnPaintBar write FOnPaintBar; property OnPopup: TNotifyEvent read FOnPopup write FOnPopup; end; TdxBarPopupMenu = class(TdxBarCustomPopupMenu) published property BackgroundBitmap; property BarManager; property BarSize; property Font; property ItemLinks; property ItemOptions; property UseOwnFont; property UseRecentItems; property OnCloseUp; property OnPaintBar; property OnPopup; end; TdxBarExtraPaneNotifyEvent = procedure(Sender: TObject; AIndex: Integer) of object; TdxBarExtraPaneItem = class(TCollectionItem) private FData: Integer; FText: string; procedure SetText(const Value: string); public procedure Assign(Source: TPersistent); override; property Data: Integer read FData write FData; published property Text: string read FText write SetText; end; TdxBarExtraPaneItems = class(TCollection) private FApplicationMenu: TdxBarApplicationMenu; function GetItem(Index: Integer): TdxBarExtraPaneItem; procedure SetItem(Index: Integer; Value: TdxBarExtraPaneItem); protected function GetOwner: TPersistent; override; public constructor Create(AApplicationMenu: TdxBarApplicationMenu); function Add: TdxBarExtraPaneItem; function IndexOf(const AItemText: string): Integer; function Insert(AIndex: Integer): TdxBarExtraPaneItem; property Items[Index: Integer]: TdxBarExtraPaneItem read GetItem write SetItem; default; end; TdxBarApplicationMenuButtons = class; TdxBarApplicationMenuButton = class(TCollectionItem) private FInternalItem: TdxBarApplicationMenuButtonItem; FItem: TdxBarButton; function GetCollection: TdxBarApplicationMenuButtons; function GetWidth: Integer; procedure SetItem(Value: TdxBarButton); procedure SetWidth(Value: Integer); protected property InternalItem: TdxBarApplicationMenuButtonItem read FInternalItem; public constructor Create(Collection: TCollection); override; destructor Destroy; override; procedure Assign(Source: TPersistent); override; procedure Update; property Collection: TdxBarApplicationMenuButtons read GetCollection; published property Item: TdxBarButton read FItem write SetItem; property Width: Integer read GetWidth write SetWidth default 0; end; TdxBarApplicationMenuButtons = class(TCollection) private FApplicationMenu: TdxBarApplicationMenu; function GetItem(Index: Integer): TdxBarApplicationMenuButton; procedure SetItem(Index: Integer; Value: TdxBarApplicationMenuButton); protected function GetOwner: TPersistent; override; procedure Update(Item: TCollectionItem); override; public constructor Create(AApplicationMenu: TdxBarApplicationMenu); function Add: TdxBarApplicationMenuButton; function Insert(AIndex: Integer): TdxBarApplicationMenuButton; property Items[Index: Integer]: TdxBarApplicationMenuButton read GetItem write SetItem; default; end; TdxBarApplicationMenuButtonItemLinks = class(TdxBarSubMenuControlItemLinks) protected function IsScrollable: Boolean; override; end; TdxBarApplicationMenuButtonsViewInfo = class private FApplicationMenuButtons: TdxBarApplicationMenuButtons; FItemLinks: TdxBarItemLinks; procedure PopulateItemLinks; public constructor Create(ApplicationMenuButtons: TdxBarApplicationMenuButtons; ABarControl: TCustomdxBarControl; ABarManager: TdxBarManager); destructor Destroy; override; procedure Calculate(ARect: TRect); property ItemLinks: TdxBarItemLinks read FItemLinks; end; TdxBarApplicationMenu = class(TdxBarCustomPopupMenu) private FButtons: TdxBarApplicationMenuButtons; FExtraPaneSize: Integer; FExtraPaneWidthRatio: Double; FExtraPaneItems: TdxBarExtraPaneItems; FExtraPaneListItem: TdxBarExtraPaneListItem; FOnExtraPaneItemClick: TdxBarExtraPaneNotifyEvent; function GetExtraPaneHeader: string; function GetExtraPaneListItem: TdxBarExtraPaneListItem; procedure SetButtons(AValue: TdxBarApplicationMenuButtons); procedure SetExtraPaneItems(AValue: TdxBarExtraPaneItems); procedure SetExtraPaneHeader(AValue: string); procedure ExtraPaneItemClick(Sender: TObject); function IsExtraPaneHeaderStored: Boolean; function IsExtraPaneWidthRatioStored: Boolean; property ExtraPaneListItem: TdxBarExtraPaneListItem read GetExtraPaneListItem; protected function GetControlClass: TCustomdxBarControlClass; override; function GetItemLinksClass: TdxBarItemLinksClass; override; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; published property BackgroundBitmap; property BarManager; property BarSize; property Buttons: TdxBarApplicationMenuButtons read FButtons write SetButtons; property ExtraPaneWidthRatio: Double read FExtraPaneWidthRatio write FExtraPaneWidthRatio stored IsExtraPaneWidthRatioStored; property ExtraPaneSize: Integer read FExtraPaneSize write FExtraPaneSize default 0; property Font; property ItemLinks; property ItemOptions; property ExtraPaneItems: TdxBarExtraPaneItems read FExtraPaneItems write SetExtraPaneItems; property ExtraPaneHeader: string read GetExtraPaneHeader write SetExtraPaneHeader stored IsExtraPaneHeaderStored; property UseOwnFont; property OnCloseUp; property OnPaintBar; property OnPopup; property OnExtraPaneItemClick: TdxBarExtraPaneNotifyEvent read FOnExtraPaneItemClick write FOnExtraPaneItemClick; end; {----------------------- Visual components -----------------------} { dock controls } TdxDockControl = class(TCustomControl) private FAllowDocking: Boolean; FBackgroundBitmap: TBitmap; FBackgroundTempBitmap: TBitmap; FBarManager: TdxBarManager; FDockingStyle: TdxBarDockingStyle; FIAccessibilityHelper: IdxBarAccessibilityHelper; FIsBarHandleDestroying: Boolean; FRowList: TList; FRowMarginSize: Integer; procedure BitmapChanged(Sender: TObject); function GetBars: TdxBars; function GetDockingStyle: TdxBarDockingStyle; function GetHorizontal: Boolean; function GetIAccessibilityHelper: IdxBarAccessibilityHelper; function GetIsDesigning: Boolean; function GetIsLoading: Boolean; function GetMain: Boolean; function GetRow(Index: Integer): TdxDockRow; function GetRowCount: Integer; function GetTopLeft: Boolean; function GetVertical: Boolean; procedure SetBarManager(Value: TdxBarManager); procedure SetBackgroundBitmap(Value: TBitmap); procedure WMDestroy(var Message: TMessage); message WM_DESTROY; procedure WMEraseBkgnd(var Message: TWMEraseBkgnd); message WM_ERASEBKGND; procedure WMGetObject(var Message: TMessage); message WM_GETOBJECT; procedure WMLButtonDblClk(var Message: TWMLButtonDblClk); message WM_LBUTTONDBLCLK; procedure WMMouseActivate(var Message: TWMMouseActivate); message WM_MOUSEACTIVATE; procedure WMNCCalcSize(var Message: TWMNCCalcSize); message WM_NCCALCSIZE; procedure WMNCPaint(var Message: TWMNCPaint); message WM_NCPAINT; procedure WMRButtonDown(var Message: TWMRButtonDown); message WM_RBUTTONDOWN; procedure WMSize(var Message: TWMSize); message WM_SIZE; procedure WMWindowPosChanged(var Message: TWMWindowPosChanged); message WM_WINDOWPOSCHANGED; procedure CMSysColorChange(var Message: TMessage); message CM_SYSCOLORCHANGE; protected procedure AlignControls(AControl: TControl; var Rect: TRect); override; procedure CreateParams(var Params: TCreateParams); override; procedure Notification(AComponent: TComponent; Operation: TOperation); override; procedure RequestAlign; override; procedure AddBarControl(ABarControl: TdxBarControl; APos: TPoint; Update: Boolean); procedure DeleteBarControl(ABarControl: TdxBarControl; ADockCol: TObject; Update: Boolean); procedure MoveBarControl(ABarControl: TdxBarControl; APos: TPoint); procedure AssignPositions; procedure BarManagerChanged; virtual; procedure CalcLayout; virtual; procedure CalcRowToolbarPositions(ARowIndex: Integer; AClientSize: Integer); virtual; function CanDocking(Bar: TdxBar): Boolean; virtual; procedure ColorChanged; virtual; function GetDockZoneBounds: TRect; procedure GetDockZoneMargins(Row, ZoneNumber: Integer; var M1, M2: Integer); function GetRectForRow(ARow: Integer): TRect; function GetClientSize: Integer; virtual; function GetSize: Integer; function GetRowAtPos(APos: TPoint; var Insert: Boolean): Integer; function GetColAtPos(ARow: Integer; APos: TPoint): Integer; procedure GetPosForRow(Row: Integer; OneOnRow: Boolean; var P: TPoint); function GetSunkenBorder: Boolean; virtual; function GetMainForm: TCustomForm; function GetMasterForm: TCustomForm; function GetParentForm: TCustomForm; function IsMultiRow: Boolean; virtual; procedure NCChanged; procedure PaintBarControls; procedure SetSize; virtual; procedure ShowCustomizePopup; virtual; procedure UpdateDock; function GetDockedBarControlClass: TdxBarControlClass; virtual; function GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; virtual; function GetPainter: TdxBarPainter; virtual; procedure FillBackground(DC: HDC; const ADestR, ASourceR: TRect; ABrush: HBRUSH; AColor: TColor); virtual; function IsBackgroundBitmap: Boolean; virtual; function IsDrawDesignBorder: Boolean; virtual; function IsTransparent: Boolean; virtual; procedure RepaintBarControls; virtual; procedure ResetBackground; virtual; procedure UpdateDoubleBuffered; virtual; property BackgroundTempBitmap: TBitmap read FBackgroundTempBitmap; property AllowDocking: Boolean read FAllowDocking write FAllowDocking default True; property BackgroundBitmap: TBitmap read FBackgroundBitmap write SetBackgroundBitmap; property Horizontal: Boolean read GetHorizontal; property IsBarHandleDestroying: Boolean read FIsBarHandleDestroying write FIsBarHandleDestroying; property IsDesigning: Boolean read GetIsDesigning; property IsLoading: Boolean read GetIsLoading; property Main: Boolean read GetMain; property MainForm: TCustomForm read GetMainForm; property MasterForm: TCustomForm read GetMasterForm; property Painter: TdxBarPainter read GetPainter; property ParentForm: TCustomForm read GetParentForm; property RowMarginSize: Integer read FRowMarginSize write FRowMarginSize; property SunkenBorder: Boolean read GetSunkenBorder; property TopLeft: Boolean read GetTopLeft; property Vertical: Boolean read GetVertical; public constructor Create(AOwner: TComponent); override; constructor CreateEx(AOwner: TComponent; ABarManager: TdxBarManager; ADockStyle: TdxBarDockingStyle); destructor Destroy; override; procedure InitiateAction; override; property BarManager: TdxBarManager read FBarManager write SetBarManager; property Bars: TdxBars read GetBars; property DockingStyle: TdxBarDockingStyle read GetDockingStyle; property IAccessibilityHelper: IdxBarAccessibilityHelper read GetIAccessibilityHelper; property RowCount: Integer read GetRowCount; property RowList: TList read FRowList; property Rows[Index: Integer]: TdxDockRow read GetRow; end; TdxBarDockAlign = (dalNone, dalTop, dalBottom, dalLeft, dalRight); TdxBarDockControl = class(TdxDockControl) private FAllowZeroSizeInDesignTime: Boolean; FSunkenBorder: Boolean; FUseOwnColor: Boolean; FUseOwnSunkenBorder: Boolean; function GetAlign: TdxBarDockAlign; function GetColor: TColor; function GetIsLoading: Boolean; function GetParentColor: Boolean; procedure SetAlign(Value: TdxBarDockAlign); procedure SetAllowZeroSizeInDesignTime(Value: Boolean); procedure SetColor(Value: TColor); procedure SetParentColor(Value: Boolean); procedure SetSunkenBorder(Value: Boolean); procedure SetUseOwnColor(Value: Boolean); procedure SetUseOwnSunkenBorder(Value: Boolean); function IsColorStored: Boolean; procedure WMCreate(var Message: TWMCreate); message WM_CREATE; procedure WMSize(var Message: TWMSize); message WM_SIZE; protected procedure CreateParams(var Params: TCreateParams); override; procedure Paint; override; procedure BarManagerChanged; override; function CanDocking(Bar: TdxBar): Boolean; override; procedure ColorChanged; override; function GetClientSize: Integer; override; function GetMinSize: Integer; function GetSunkenBorder: Boolean; override; property IsLoading: Boolean read GetIsLoading; public constructor Create(AOwner: TComponent); override; published property Align: TdxBarDockAlign read GetAlign write SetAlign; property AllowDocking; property AllowZeroSizeInDesignTime: Boolean read FAllowZeroSizeInDesignTime write SetAllowZeroSizeInDesignTime default False; property Anchors; property BarManager; property Color read GetColor write SetColor stored IsColorStored; property ParentColor: Boolean read GetParentColor write SetParentColor stored IsColorStored; property SunkenBorder: Boolean read GetSunkenBorder write SetSunkenBorder stored FUseOwnSunkenBorder; property UseOwnColor: Boolean read FUseOwnColor write SetUseOwnColor default False; property UseOwnSunkenBorder: Boolean read FUseOwnSunkenBorder write SetUseOwnSunkenBorder default False; property Visible; property BackgroundBitmap; property OnClick; property OnDblClick; property OnMouseDown; property OnMouseMove; property OnMouseUp; property OnResize; end; { shadow support } TdxBarShadowCorner = (scLeft, scRight, scTop); TdxBarShadowCorners = set of TdxBarShadowCorner; TdxBarShadowPartKind = (spHorizontal, spVertical); TdxBarShadowPart = class(TCustomControl) private FCorners: TdxBarShadowCorners; FImage: TBitmap; FKind: TdxBarShadowPartKind; FOwner: TdxBarShadow; function GetControl: TWinControl; function GetShadowSize: Integer; function GetTransparent: Boolean; procedure WMNCHitTest(var Message: TWMNCHitTest); message WM_NCHITTEST; protected function CanShow: Boolean; procedure CreateParams(var Params: TCreateParams); override; procedure Paint; override; procedure UpdateImage; property Control: TWinControl read GetControl; property Image: TBitmap read FImage; property Owner: TdxBarShadow read FOwner; property ShadowSize: Integer read GetShadowSize; property Transparent: Boolean read GetTransparent; public constructor CreateEx(AOwner: TdxBarShadow; AKind: TdxBarShadowPartKind; ACorners: TdxBarShadowCorners); destructor Destroy; override; procedure Hide; procedure Show; procedure UpdateBounds(const ABounds: TRect); property Corners: TdxBarShadowCorners read FCorners; property Kind: TdxBarShadowPartKind read FKind; end; TdxBarShadow = class private FHorizontal: Boolean; FOwner: TWinControl; FParts: array[0..4] of TdxBarShadowPart; FVisible: Boolean; function GetShadowSize: Integer; function GetTransparent: Boolean; procedure SetVisible(Value: Boolean); protected R1, R2: TRect; procedure CreateParts; procedure DestroyParts; procedure Hide; procedure Show; property Transparent: Boolean read GetTransparent; public constructor Create(AOwner: TWinControl); destructor Destroy; override; procedure Refresh; procedure SetOwnerBounds(AR1, AR2: TRect); property Horizontal: Boolean read FHorizontal; property Owner: TWinControl read FOwner; property ShadowSize: Integer read GetShadowSize; property Visible: Boolean read FVisible write SetVisible; end; { TCustomdxBarControl } TdxBarMarkState = (msNone, msSelected, msPressed); TdxBarKind = (bkBarControl, bkBarQuickControl, bkSubMenu); TdxBarKinds = set of TdxBarKind; TdxBarState = (bsCreatingControls, bsDestroyingControls, bsDestroyingWindow, bsHideAll, bsPaintItem, bsRepaintBar, bsUpdatingCanvasFont); TdxBarStates = set of TdxBarState; TdxBarViewState = (bvsNormal, bvsHot); TdxBarPaintType = (ptHorz, ptMenu, ptVert); TCustomdxBarControl = class(TCustomControl, IcxMouseTrackingCaller) private FActiveCanvas: TcxCanvas; FBackgroundTempBitmap: TBitmap; FBkBrush: HBRUSH; FCanvas: TcxCanvas; FChildBar: TCustomdxBarControl; FClickedControl: TdxBarItemControl; FClosedByEscape: Boolean; FCurrentMessage: TMessage; FDockControl: TdxDockControl; FDockingStyle: TdxBarDockingStyle; FDragDown: Boolean; FDragPoint: TPoint; FExpandedItemLinks: TList; FIAccessibilityHelper: IdxBarAccessibilityHelper; FIgnoreMouseClick: Boolean; FIsActive: Boolean; FIsDowned: Boolean; FItemLinks: TdxBarItemLinks; FMovingChanging: Boolean; FOwnerBounds: TRect; FOwnerControl: TWinControl; FParentBar: TCustomdxBarControl; FPrevActiveBarControl: TCustomdxBarControl; FPrevFocusedBarControlLink: TcxObjectLink; FPrevTrackedLink: TdxBarItemLink; //#DG !! //#DG FSelectedItem: TdxBarItemControl; // obsolete FSelectedLink: TdxBarItemLink; // to replace obsolete SelectedItem FShadow: TdxBarShadow; FTextSize, FEditTextSize: Integer; FMenuArrowHeight, FMenuArrowWidth: Integer; FComboBoxArrowWidth: Integer; FIconAreaSize: Integer; FRatio: Double; FOnDestroy: TNotifyEvent; procedure MouseDownNotifyControls(ALinkAtPos: TdxBarItemLink; const AMousePos: TPoint; Button: TMouseButton; Shift: TShiftState); procedure MouseNotifyControls(ALinkAtPos: TdxBarItemLink; const AMousePos: TPoint; Shift: TShiftState); procedure MouseUpNotifyControls(ALinkAtPos: TdxBarItemLink; const AMousePos: TPoint; Button: TMouseButton; Shift: TShiftState); function GetActiveCanvas: TcxCanvas; function GetBarControlOwnerBrush: HBRUSH; function GetBarManager: TdxBarManager; function GetCanvas: TcxCanvas; function GetFlat: Boolean; function GetIAccessibilityHelper: IdxBarAccessibilityHelper; function GetIsDestroying: Boolean; function GetOwnerLinkBounds(AOwnerPart: Boolean): TRect; function GetPainterClass: TdxBarPainterClass; function GetSelectedControlAtDesign: TdxBarItemControl; function GetSelectedControl: TdxBarItemControl; function ItemAtMousePos: TdxBarItemControl; procedure SetChildBar(Value: TCustomdxBarControl); procedure SetDockControl(Value: TdxDockControl); procedure SetIsActive(Value: Boolean); procedure SetParentBar(Value: TCustomdxBarControl); procedure SetViewState(Value: TdxBarViewState); procedure WMCaptureChanged(var Message: TMessage); message WM_CAPTURECHANGED; procedure WMDestroy(var Message: TMessage); message WM_DESTROY; procedure WMEraseBkgnd(var Message: TWMEraseBkgnd); message WM_ERASEBKGND; procedure WMKeyDown(var Message: TWMKeyDown); message WM_KEYDOWN; procedure WMLButtonDblClk(var Message: TWMLButtonDblClk); message WM_LBUTTONDBLCLK; procedure WMLButtonDown(var Message: TWMLButtonDown); message WM_LBUTTONDOWN; procedure WMLButtonUp(var Message: TWMLButtonUp); message WM_LBUTTONUP; procedure WMMouseActivate(var Message: TWMMouseActivate); message WM_MOUSEACTIVATE; procedure WMMouseMove(var Message: TWMMouseMove); message WM_MOUSEMOVE; procedure WMPaint(var Message: TWMPaint); message WM_PAINT; procedure WMRepaintBar(var Message: TMessage); message WM_REPAINTBAR; procedure WMSetCursor(var Message: TWMSetCursor); message WM_SETCURSOR; procedure WMSize(var Message: TWMSize); message WM_SIZE; procedure WMWindowPosChanged(var Message: TWMWindowPosChanged); message WM_WINDOWPOSCHANGED; protected FItemsRect: TRect; FLastMousePos: TPoint; FMarkState: TdxBarMarkState; FPainter: TdxBarPainter; FState: TdxBarStates; FViewInfo: TCustomdxBarControlViewInfo; FViewState: TdxBarViewState; FVisibleItemsRect: TRect; procedure AdjustSize; override; procedure AdjustHintWindowPosition(var APos: TPoint; const ABoundsRect: TRect; AHeight: Integer); virtual; procedure AfterControlEscape(AControl: TdxBarItemControl); virtual; procedure AfterMouseMove(Shift: TShiftState; X, Y: Integer); virtual; procedure CreateWindowHandle(const Params: TCreateParams); override; procedure CreateWnd; override; procedure DestroyWindowHandle; override; procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override; procedure MouseLeave; dynamic; { IcxMouseTrackingCaller } procedure MouseMove(Shift: TShiftState; X, Y: Integer); override; procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override; procedure Resize; override; procedure WndProc(var Message: TMessage); override; function CalcChildBarBounds(out ARect: TRect): Boolean; virtual; procedure CalcControlsPositions; virtual; procedure CalcDragOverParameters(const ACursorPos: TPoint; out ADragOverItemLink: TdxBarItemLink; out AIsBeginGroup, AIsFirstPart, AIsVerticalDirection: Boolean); virtual; procedure CalcDrawingConsts; virtual; procedure CalcItemsRect; virtual; procedure CalcColumnItemRects(ATopIndex: Integer = 0); virtual; procedure CalcRowItemRects; virtual; procedure CalcItemRects(APaintStyle: TdxBarPaintType; ATopIndex: Integer = 0); virtual; procedure CalcLayout; virtual; procedure BeforeDestroyHandle; procedure CreateControls; virtual; procedure DestroyControls; virtual; procedure ExpandContainerItems; procedure CollapseContainerItems; procedure LayoutChanged; virtual; procedure RecreateControls; function CanActiveChange: Boolean; virtual; function CanAlignControl(AControl: TdxBarItemControl): Boolean; virtual; function CanCallInheritedNCCalcSize: Boolean; virtual; // obsolete //function CanCallInheritedNCPaint: Boolean; virtual; function CanCustomizing: Boolean; virtual; function CanDeactivate(ABarManager: TdxBarManager; AActiveWindow: HWND): Boolean; virtual; function CanDrawClippedItem(AItemRect: TRect): Boolean; virtual; function CanHide: Boolean; function CanProcessMouseMessage: Boolean; virtual; function CanShowPopupMenuOnMouseClick(AMousePressed: Boolean): Boolean; virtual; function CanShowHint: Boolean; virtual; function CheckLockUpdate: Boolean; virtual; function ChildrenHaveShadows: Boolean; virtual; procedure CorrectVisibleItemsRectTop; virtual; procedure CorrectVisibleItemsRectBottom; virtual; procedure CustomizePrepare(APoint: TPoint; ASecondClick: Boolean); virtual; procedure DblClickOnItem(AItemControl: TdxBarItemControl); dynamic; procedure DoBarGetFocus(ASelectedItem: TdxBarItemControl); virtual; procedure DoBarLostFocus; virtual; procedure DoBarMouseEnter(Shift: TShiftState; const APoint: TPoint; AItemControl: TdxBarItemControl); virtual; procedure DoBarMouseDown(Button: TMouseButton; Shift: TShiftState; const APoint: TPoint; AItemControl: TdxBarItemControl; APointInClientRect: Boolean); virtual; procedure DoBarMouseLeave; virtual; procedure DoBarMouseMove(Shift: TShiftState; const APoint: TPoint; AItemControl: TdxBarItemControl); virtual; procedure DoBarMouseUp(Button: TMouseButton; Shift: TShiftState; const APoint: TPoint; AItemControl: TdxBarItemControl; APointInClientRect: Boolean); virtual; procedure DoCreateControls; virtual; procedure DoDestroy; virtual; procedure DoDestroyControls; virtual; procedure DoHideAll; virtual; procedure DoPaintItem(AControl: TdxBarItemControl; ACanvas: TcxCanvas; const AItemRect: TRect); virtual; procedure DoRepaintBar(ARecreateControls: Boolean); virtual; procedure DoSetIsActive(AValue: Boolean); virtual; procedure DrawSelectedItem(ADC: HDC; AControl: TdxBarItemControl; const AItemRect: TRect); procedure DragOver(X, Y: Integer; var Accept: Boolean); reintroduce; virtual; function DoFindLinkWithAccel(AKey: Word; AShift: TShiftState; ACurrentLink: TdxBarItemLink): TdxBarItemLink; virtual; function FindLinkWithAccel(AKey: Word; AShift: TShiftState; ACurrentLink: TdxBarItemLink; out ADuplicate: Boolean): TdxBarItemLink; virtual; procedure FocusItemControl(AItemControl: TdxBarItemControl); virtual; procedure FocusNextBarControl(AForward: Boolean); function GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; virtual; abstract; function GetBackgroundBitmap: TBitmap; virtual; abstract; function GetBeginGroupSize: Integer; virtual; abstract; function GetBehaviorOptions: TdxBarBehaviorOptions; virtual; function GetClientOffset: TPoint; function GetDefaultItemHeight(AItem: TdxBarItemControl): Integer; virtual; function GetDefaultItemGlyph: TBitmap; virtual; function GetEditFont: TFont; virtual; function GetEditFontHandle: HFONT; function GetEquivalentParentBar: TCustomdxBarControl; function GetFader: TdxFader; virtual; function GetFullItemRect(Item: TdxBarItemControl): TRect; virtual; function GetIsCustomizing: Boolean; virtual; function GetIsFocused: Boolean; function GetIsMainMenu: Boolean; virtual; abstract; function GetIsShadowVisible: Boolean; virtual; function GetItemControlDefaultViewLevel(AItemControl: TdxBarItemControl): TdxBarItemViewLevel; virtual; function GetItemControlOffset(AItemLink: TdxBarItemLink): Integer; virtual; function GetItemRectEx(Item: TdxBarItemControl; IsBeginGroup: Boolean): TRect; virtual; function GetItemRegion(Item: TdxBarItemControl): HRGN; virtual; function GetItemScreenRect(Item: TdxBarItemControl): TRect; function GetMarkDrawState: TdxBarMarkState; virtual; function GetNormalItemHeight: Integer; virtual; function GetOwnerControl: TWinControl; virtual; function GetPainter: TdxBarPainter; virtual; function GetPaintType: TdxBarPaintType; virtual; function GetSelectableObject: TPersistent; virtual; function GetSelectionOperation(AButton: TMouseButton; AShift: TShiftState; ASelectableItem: IdxBarSelectableItem): TdxBarSelectionOperation; function GetToolbarBrush: HBRUSH; virtual; function GetToolbarDownedBrush: HBRUSH; virtual; function GetToolbarDownedSelBrush: HBRUSH; virtual; function GetToolbarSelBrush: HBRUSH; virtual; function GetViewInfoClass: TCustomdxBarControlViewInfoClass; virtual; abstract; procedure RepaintBarEx(ARecreateControls: Boolean); procedure SetControlVisible(AControl: TdxBarItemControl); virtual; function GetBorderSize: Integer; virtual; function GetIconAreaSize: Integer; virtual; function GetTextSize: Integer; virtual; function GetClientBounds: TRect; function GetNCRect: TRect; function GetWindowRect: TRect; function GetWindowPoint(const AClientPoint: TPoint): TPoint; function HasShadow: Boolean; virtual; procedure Hide; procedure HideAllByEscape; virtual; function HideOnClick: Boolean; virtual; function IsChildBar(Value: TCustomdxBarControl): Boolean; virtual; function IsChildWindow(AWnd: HWND): Boolean; function IsControlExists(ABarItemControl: TdxBarItemControl): Boolean; virtual; function IsLinkedToOwner: Boolean; virtual; function IsMeaningParent(AWnd: HWND): Boolean; virtual; function IsPopup: Boolean; virtual; function IsVerticalDirection: Boolean; virtual; function IsWindowEnabled: Boolean; virtual; procedure MakeItemControlFullyVisible(AItemControl: TdxBarItemControl); virtual; function MarkExists: Boolean; virtual; function MarkRect: TRect; virtual; function MouseOnMark(const AMousePos: TPoint): Boolean; overload; function MouseOnMark: Boolean; overload; procedure SetMarkState(Value: TdxBarMarkState); virtual; abstract; procedure ActivateHint(AShow: Boolean; const ACustomHint: string; AHintObject: TObject = nil); function CreateHintViewInfo(const AHintText, AShortCut: string; AScreenTip: TdxBarScreenTip): TdxBarCustomHintViewInfo; function GetHintPosition(const AItemBounds: TRect; const ACursorPos: TPoint; AHeight: Integer): TPoint; function NeedShowGlyphAndCheckForItem: Boolean; virtual; function NotHandleMouseMove(ACheckLastMousePos: Boolean = True): Boolean; virtual; procedure PaintItem(AControl: TdxBarItemControl); virtual; procedure ResizeShadow; procedure SetCursorForMoving(AMoving: Boolean); procedure SetDockingStyle(Value: TdxBarDockingStyle); virtual; procedure SetFont; virtual; abstract; procedure SetLayeredAttributes; virtual; function SelectedItemWantsKey(Key: Word): Boolean; procedure SelectItemControl(AItemControl: TdxBarItemControl; AButton: TMouseButton; AShift: TShiftState); virtual; procedure SetAccelSelectedItem(AItemControl: TdxBarItemControl; ADuplicate: Boolean); virtual; procedure SetKeySelectedItem(Value: TdxBarItemControl); virtual; procedure SetMouseSelectedItem(Value: TdxBarItemControl); virtual; procedure SetSelectedControl(Value: TdxBarItemControl); virtual; procedure Show; procedure UpdateCanvasFont; procedure UpdateControlStyle; procedure UpdateItem(AControl: TdxBarItemControl); virtual; abstract; procedure ViewStateChanged(APrevValue: TdxBarViewState); virtual; function WantMouse: Boolean; procedure DoShowPopup(ASelectedControl: TdxBarItemControl); procedure InitCustomizationPopup(AItemLinks: TdxBarItemLinks); virtual; procedure ShowPopup(AItem: TdxBarItemControl); virtual; procedure FillBackground(DC: HDC; const ARect: TRect; ABrush: HBRUSH; AColor: TColor; AIsClientArea: Boolean); virtual; abstract; procedure FillBackgroundRgn(DC: HDC; ARgn: HRGN; ABrush: HBRUSH; AIsClientArea: Boolean); virtual; procedure FullInvalidate; procedure FullRepaint; procedure InvalidateNCRect(ARect: TRect); function IsInternal: Boolean; virtual; function IsBackgroundBitmap: Boolean; virtual; function IsTransparent: Boolean; virtual; function NCOffset: TPoint; virtual; function PointBarToDock(const APoint: TPoint): TPoint; procedure ResetBackground; virtual; procedure UpdateDoubleBuffered; virtual; property BackgroundTempBitmap: TBitmap read FBackgroundTempBitmap; property ChildBar: TCustomdxBarControl read FChildBar write SetChildBar; property ClosedByEscape: Boolean read FClosedByEscape write FClosedByEscape; property DockControl: TdxDockControl read FDockControl write SetDockControl; property DockingStyle: TdxBarDockingStyle read FDockingStyle write SetDockingStyle; property Flat: Boolean read GetFlat; // TODO: obsolete property IgnoreMouseClick: Boolean read FIgnoreMouseClick write FIgnoreMouseClick; property IsDestroying: Boolean read GetIsDestroying; property IsDowned: Boolean read FIsDowned write FIsDowned; property IsMainMenu: Boolean read GetIsMainMenu; property IsShadowVisible: Boolean read GetIsShadowVisible; property MarkState: TdxBarMarkState read FMarkState write SetMarkState; property MarkDrawState: TdxBarMarkState read GetMarkDrawState; property SelectedControlAtDesign: TdxBarItemControl read GetSelectedControlAtDesign; property SelectedControl: TdxBarItemControl read GetSelectedControl write SetSelectedControl; property SelectedLink: TdxBarItemLink read FSelectedLink write FSelectedLink; property Shadow: TdxBarShadow read FShadow; property ViewState: TdxBarViewState read FViewState write SetViewState; property IconAreaSize: Integer read FIconAreaSize; property BeginGroupSize: Integer read GetBeginGroupSize; property OwnerBounds: TRect read FOwnerBounds write FOwnerBounds; property OwnerControl: TWinControl read GetOwnerControl; property OwnerLinkBounds[AOwnerPart: Boolean]: TRect read GetOwnerLinkBounds; property RealOwnerControl: TWinControl read FOwnerControl; property BarControlOwnerBrush: HBRUSH read GetBarControlOwnerBrush; property EditFont: TFont read GetEditFont; property Painter: TdxBarPainter read GetPainter; property PainterClass: TdxBarPainterClass read GetPainterClass; property ToolbarBrush: HBRUSH read GetToolbarBrush; property ToolbarDownedBrush: HBRUSH read GetToolbarDownedBrush; property ToolbarDownedSelBrush: HBRUSH read GetToolbarDownedSelBrush; property ToolbarSelBrush: HBRUSH read GetToolbarSelBrush; property ItemsRect: TRect read FItemsRect; property NCRect: TRect read GetNCRect; property VisibleItemsRect: TRect read FVisibleItemsRect; property WindowRect: TRect read GetWindowRect; property ActiveCanvas: TcxCanvas read GetActiveCanvas; property Ratio: Double read FRatio; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; procedure BarGetFocus(ASelectedItem: TdxBarItemControl); procedure BarLostFocus; procedure BeforeDestruction; override; function GetItemRect(Item: TdxBarItemControl): TRect; procedure HideAll; virtual; function IsRealVertical: Boolean; virtual; function IsVertical: Boolean; virtual; function ItemAtPos(const APos: TPoint): TdxBarItemControl; function Kind: TdxBarKind; virtual; abstract; procedure RepaintBar; virtual; property BarManager: TdxBarManager read GetBarManager; property BkBrush: HBRUSH read FBkBrush; property BehaviorOptions: TdxBarBehaviorOptions read GetBehaviorOptions; property Canvas: TcxCanvas read GetCanvas; property ClientBounds: TRect read GetClientBounds; property ComboBoxArrowWidth: Integer read FComboBoxArrowWidth; property EditFontHandle: HFONT read GetEditFontHandle; property EditTextSize: Integer read FEditTextSize; property Font; property IAccessibilityHelper: IdxBarAccessibilityHelper read GetIAccessibilityHelper; property IsActive: Boolean read FIsActive write SetIsActive; property IsCustomizing: Boolean read GetIsCustomizing; property IsFocused: Boolean read GetIsFocused; property ItemLinks: TdxBarItemLinks read FItemLinks write FItemLinks; property MenuArrowHeight: Integer read FMenuArrowHeight; property MenuArrowWidth: Integer read FMenuArrowWidth; property ParentBar: TCustomdxBarControl read FParentBar write SetParentBar; property TextSize: Integer read FTextSize; property ViewInfo: TCustomdxBarControlViewInfo read FViewInfo; property OnDestroy: TNotifyEvent read FOnDestroy write FOnDestroy; end; { TCustomdxBarControlDesignHelper } TCustomdxBarControlDesignHelper = class public class procedure FilterItemActions(var ASupportedActions: TdxBarCustomizationActions); virtual; class procedure GetEditors(AEditors: TList); virtual; class function GetForbiddenActions: TdxBarCustomizationActions; virtual; end; TdxBarControlDesignHelper = class(TCustomdxBarControlDesignHelper) public class function GetForbiddenActions: TdxBarCustomizationActions; override; end; TdxBarSubMenuControlDesignHelper = class(TCustomdxBarControlDesignHelper) public class procedure GetEditors(AEditors: TList); override; class function GetForbiddenActions: TdxBarCustomizationActions; override; end; TdxDockCol = class private FBarControl: TdxBarControl; FDockRow: TdxDockRow; FPos: TPoint; public constructor Create(ADockRow: TdxDockRow; ABarControl: TdxBarControl); procedure AssignPosition; property BarControl: TdxBarControl read FBarControl; property DockRow: TdxDockRow read FDockRow; property Pos: TPoint read FPos write FPos; end; TdxDockRow = class protected FBars: TList; FColList: TList; FDockControl: TdxDockControl; procedure AddBar(ABar: TdxBar); procedure DeleteBar(ABar: TdxBar; ADestroyEmptyDockRow: Boolean); function GetCol(Index: Integer): TdxDockCol; function GetColCount: Integer; function GetVisible: Boolean; procedure UpdateOneOnRows; public constructor Create(ADockControl: TdxDockControl); destructor Destroy; override; function AddCol(ABarControl: TdxBarControl): TdxDockCol; procedure DeleteCol(ABarControl: TdxBarControl); overload; procedure DeleteCol(AIndex: Integer); overload; property ColCount: Integer read GetColCount; property ColList: TList read FColList; property Cols[Index: Integer]: TdxDockCol read GetCol; property DockControl: TdxDockControl read FDockControl; property Visible: Boolean read GetVisible; end; TXDirection = (xdLeft, xdRight); TYDirection = (ydTop, ydBottom); { TdxBarControl } TdxBarControl = class(TCustomdxBarControl) private FBar: TdxBar; FBeforeBarGetFocusFocusedWnd: HWND; FCloseButtonState: TdxBarMarkState; FDockedHandle, FFloatingHandle: HWND; FIsResizing: Boolean; FHasSizeGrip: Boolean; FHitTest: Longint; FInternalLockCount: Integer; FMarkIAccessibilityHelper: IdxBarAccessibilityHelper; FMDIButtonWidth, FMDIButtonHeight: Integer; FMinSize, FMaxSize: Integer; FMoreButtonsHintTimer: UINT; FMoving: Boolean; FPopupBar: TdxBar; FPosSaving: Boolean; FTruncated: Boolean; FQuickPopup: TdxBarControl; NewLeft, NewTop, NewWidth, NewHeight: Integer; RX, RY: TPoint; function GetCaptionBkColor: COLORREF; function GetCaptionButtons: TdxBarCaptionButtons; function GetCaptionColor: COLORREF; function GetHorizontal: Boolean; function GetInternallyLocked: Boolean; function GetMarkIAccessibilityHelper: IdxBarAccessibilityHelper; function GetVertical: Boolean; procedure SetCloseButtonState(Value: TdxBarMarkState); procedure SetMoving(Value: Boolean); procedure ChangeStyleWinTo(AStyle: TdxBarDockingStyle; ADockControl: TdxDockControl); function GetDragPointOffset(Style: TdxBarDockingStyle): TPoint; function GetCaptionNCRect: TRect; function GetCaptionRect: TRect; procedure DrawCloseButton(DC: HDC); procedure DrawMark(DC: HDC); procedure DrawMDIButton(AButton: TdxBarMDIButton; ASelected, APressed: Boolean); function GetMDIWidth: Integer; function GetMDIHeight: Integer; function RectMDI(Button: TdxBarMDIButton): TRect; function MDIButtonsOnBar: Boolean; function MDIButtonEnabled(AButton: TdxBarMDIButton; State: Integer): Boolean; procedure StartMoreButtonsHintTimer; procedure FinishMoreButtonsHintTimer; function CanResizeSelectedLink(APoint: TPoint): Boolean; procedure WMCaptureChanged(var Message: TMessage); message WM_CAPTURECHANGED; procedure WMDestroy(var Message: TMessage); message WM_DESTROY; procedure WMGetDlgCode(var Message: TWMGetDlgCode); message WM_GETDLGCODE; procedure WMGetMinMaxInfo(var Message: TWMGetMinmaxInfo); message WM_GETMINMAXINFO; procedure WMGetObject(var Message: TMessage); message WM_GETOBJECT; procedure WMKeyDown(var Message: TWMKeyDown); message WM_KEYDOWN; procedure WMLButtonDblClk(var Message: TWMLButtonDblClk); message WM_LBUTTONDBLCLK; procedure WMLButtonUp(var Message: TWMLButtonUp); message WM_LBUTTONUP; procedure WMMouseActivate(var Message: TWMMouseActivate); message WM_MOUSEACTIVATE; procedure WMNCCalcSize(var Message: TWMNCCalcSize); message WM_NCCALCSIZE; procedure WMNCHitTest(var Message: TWMNCHitTest); message WM_NCHITTEST; procedure WMNCLButtonDown(var Message: TWMNCLButtonDown); message WM_NCLBUTTONDOWN; procedure WMNCPaint(var Message: TMessage); message WM_NCPAINT; procedure WMSetCursor(var Message: TWMSetCursor); message WM_SETCURSOR; procedure WMSize(var Message: TWMSize); message WM_SIZE; procedure WMSizing(var Message: TMessage); message WM_SIZING; procedure WMWindowPosChanged(var Message: TWMWindowPosChanged); message WM_WINDOWPOSCHANGED; procedure WMWindowPosChanging(var Message: TWMWindowPosChanging); message WM_WINDOWPOSCHANGING; procedure CMFontChanged(var Message: TMessage); message CM_FONTCHANGED; protected procedure CreateParams(var Params: TCreateParams); override; procedure CreateWnd; override; procedure Paint; override; procedure Resize; override; procedure WndProc(var Message: TMessage); override; procedure BeginInternal; procedure EndInternal; property InternallyLocked: Boolean read GetInternallyLocked; procedure LayoutChanged; override; procedure CalcControlsPositions; override; procedure CalcRowItemRects; override; procedure CalcDrawingConsts; override; procedure CalcDragOverParameters(const ACursorPos: TPoint; out ADragOverItemLink: TdxBarItemLink; out AIsBeginGroup, AIsFirstPart, AIsVerticalDirection: Boolean); override; function CanAlignControl(AControl: TdxBarItemControl): Boolean; override; function CanCallInheritedNCCalcSize: Boolean; override; // obsolete function CanCustomizing: Boolean; override; function CanHideAllItemsInSingleLine: Boolean; virtual; function CanMoving: Boolean; virtual; procedure CaptionButtonClick(AIndex: Integer); virtual; procedure CheckMarkState(const P: TPoint); function CloseButtonRect: TRect; function CloseButtonRectNC: TRect; function CheckLockUpdate: Boolean; override; procedure CustomizePrepare(APoint: TPoint; ASecondClick: Boolean); override; procedure DoBarGetFocus(ASelectedItem: TdxBarItemControl); override; procedure DoBarLostFocus; override; procedure DoBarMouseDown(Button: TMouseButton; Shift: TShiftState; const APoint: TPoint; AItemControl: TdxBarItemControl; APointInClientRect: Boolean); override; procedure DoBarMouseLeave; override; procedure DoBarMouseMove(Shift: TShiftState; const APoint: TPoint; AItemControl: TdxBarItemControl); override; procedure DoHideAll; override; procedure DoRepaintBar(ARecreateControls: Boolean); override; procedure DoSetIsActive(AValue: Boolean); override; procedure FocusItemControl(AItemControl: TdxBarItemControl); override; function GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; override; function GetAlphaBlendValue: Byte; function GetBackgroundBitmap: TBitmap; override; function GetBeginGroupSize: Integer; override; function GetCol: Integer; function GetDockCol: TdxDockCol; function GetIsMainMenu: Boolean; override; function GetMarkAccessibilityHelperClass: TdxBarAccessibilityHelperClass; virtual; function GetMarkDrawState: TdxBarMarkState; override; function GetMoreButtonsHint: string; virtual; function GetMultiLine: Boolean; virtual; function GetQuickControlClass: TdxBarControlClass; virtual; function GetRow: Integer; function GetViewInfoClass: TCustomdxBarControlViewInfoClass; override; function GetMasterForm: TCustomForm; function GetParentForm: TCustomForm; virtual; function GetSelectableObject: TPersistent; override; function AllowQuickCustomizing: Boolean; virtual; procedure HandleQuickAccessSubItemPopup(Sender: TObject); procedure InitQuickControl(AQuickControlItemLinks: TdxBarItemLinks); virtual; procedure InitQuickCustomizeItemLinks(AQuickControlItemLinks: TdxBarItemLinks); virtual; procedure InitAddRemoveSubItemPopup(AItemLinks: TdxBarItemLinks); virtual; procedure ResetToolbarClick(Sender: TObject); function GetMinWidth(AStyle: TdxBarDockingStyle): Integer; virtual; function GetMinHeight(AStyle: TdxBarDockingStyle): Integer; virtual; function GetMaxWidth(AStyle: TdxBarDockingStyle): Integer; function GetMaxHeight(AStyle: TdxBarDockingStyle): Integer; procedure GetMultiLineBarSize(AStyle: TdxBarDockingStyle; ASize: Integer; var Result: TPoint); function GetSizeAllCursorBounds: TRect; virtual; function GetSizeForWidth(AStyle: TdxBarDockingStyle; AWidth: Integer): TPoint; virtual; function GetSizeForHeight(AStyle: TdxBarDockingStyle; AHeight: Integer): TPoint; function GetSizeForPopup: TSize; virtual; function GetTrackSize(AStyle: TdxBarDockingStyle): TPoint; function HasCaption: Boolean; virtual; function HasCloseButton: Boolean; virtual; function HideOnClick: Boolean; override; function IgnoreClickAreaWhenHidePopup: TRect; virtual; procedure InvalidateMark; function IsMarkAccessible: Boolean; function IsInternal: Boolean; override; function MarkExists: Boolean; override; function MarkNCRect: TRect; function MarkRect: TRect; override; function MarkItemRect: TRect; function MarkScreenRect: TRect; procedure SetMarkState(Value: TdxBarMarkState); override; function RealMDIButtonsOnBar: Boolean; virtual; procedure SelectItemControl(AItemControl: TdxBarItemControl; AButton: TMouseButton; AShift: TShiftState); override; procedure ShowPopup(AItem: TdxBarItemControl); override; function SizeGripRect: TRect; procedure UpdateCaptionButtons(ACaptionButton: TdxBarCaptionButton); virtual; procedure UpdateItem(AControl: TdxBarItemControl); override; procedure BarManagerStyleChanged; procedure CaptionChanged; virtual; procedure DoDrawBeginGroup(const ASeparatorRect: TRect; AHorz: Boolean); virtual; procedure DoNCPaint(DC: HDC); virtual; procedure DoPaint; virtual; procedure DrawBeginGroups; procedure DrawItems; procedure DrawContentBackground; virtual; procedure DrawMarks; procedure DrawMDIButtons(AButtons: TdxBarMDIButtons; AExcludeClipRect: Boolean = False); procedure DrawSelection(ADC: HDC); procedure FillBackground(ADC: HDC; const ARect: TRect; ABrush: HBRUSH; AColor: TColor; AIsClientArea: Boolean); override; procedure FrameChanged; function GetCaption: TCaption; virtual; function GetEditFont: TFont; override; function GetFont: TFont; virtual; function GetFullItemRect(Item: TdxBarItemControl): TRect; override; function GetItemRegion(Item: TdxBarItemControl): HRGN; override; function GetToolbarBrush: HBRUSH; override; procedure GlyphChanged; virtual; function IsBackgroundBitmap: Boolean; override; function IsTransparent: Boolean; override; function LockHotTrackWhenPopup: Boolean; virtual; function NCOffset: TPoint; override; function NeedHideOnNCMouseClick: Boolean; virtual; function NotHandleMouseMove(ACheckLastMousePos: Boolean = True): Boolean; override; procedure RebuildBar; procedure RefreshShadow; procedure RepaintMDIButtons; procedure SavePos; procedure SetFont; override; procedure SetDockingStyle(Value: TdxBarDockingStyle); override; procedure SetKeySelectedItem(Value: TdxBarItemControl); override; procedure SetLayeredAttributes; override; property CaptionBkColor: COLORREF read GetCaptionBkColor; property CaptionButtons: TdxBarCaptionButtons read GetCaptionButtons; property CaptionColor: COLORREF read GetCaptionColor; property CloseButtonState: TdxBarMarkState read FCloseButtonState write SetCloseButtonState; property HitTest: Longint read FHitTest write FHitTest; property Horizontal: Boolean read GetHorizontal; property Moving: Boolean read FMoving write SetMoving; property MultiLine: Boolean read GetMultiLine; property Truncated: Boolean read FTruncated write FTruncated; property Vertical: Boolean read GetVertical; property MDIButtonWidth: Integer read FMDIButtonWidth; property MDIButtonHeight: Integer read FMDIButtonHeight; property MasterForm: TCustomForm read GetMasterForm; property ParentForm: TCustomForm read GetParentForm; property PopupBar: TdxBar read FPopupBar; public constructor CreateEx(AOwner: TComponent; ABar: TdxBar); virtual; constructor CreateForPopup(AParentBarControl: TdxBarControl; ABar: TdxBar); virtual; destructor Destroy; override; function ClientToScreen(const APoint: TPoint): TPoint; procedure CloseUp; virtual; function IsRealVertical: Boolean; override; function IsVertical: Boolean; override; function Kind: TdxBarKind; override; procedure Popup(const AOwnerRect: TRect); virtual; procedure PopupEx(const AOwnerRect: TRect; APopupDirection: TXDirection); procedure Repaint; override; procedure UpdateFont; property Bar: TdxBar read FBar write FBar; property DockControl; property MarkIAccessibilityHelper: IdxBarAccessibilityHelper read GetMarkIAccessibilityHelper; end; TdxBarControlViewInfo = class(TCustomdxBarControlViewInfo) private function GetBarControl: TdxBarControl; protected procedure CalcSeparatorInfo(AItemLink: TdxBarItemLink); virtual; function CanShowButtonGroups: Boolean; virtual; function CanShowSeparators: Boolean; virtual; procedure DoCalcSeparatorInfo(AItemLink: TdxBarItemLink; const AItemRect: TRect); virtual; function IsLastVisibleItemControl(AItemControl: TdxBarItemControl): Boolean; virtual; public procedure Calculate; override; property BarControl: TdxBarControl read GetBarControl; end; { TdxBarSubMenuControl } TdxBarButtonControl = class; TdxBarSubItemControl = class; TdxBarSubMenuControl = class(TCustomdxBarControl) private FAnimationThread: TThread; FDetachCaptionSelected: Boolean; FExpandingMenu: Boolean; FExpandMenuTimer: UINT; FLightBrush: HBRUSH; FLightPalette: HPALETTE; FMarkSize: Integer; FMenuAnimations: TdxBarMenuAnimations; FNonRecent: Boolean; FOnShowLeft, FOnShowTop: Integer; FOwnerWidth, FOwnerHeight: Integer; FScrollTimerID: UINT; FShowAnimation: Boolean; FTopIndex: Integer; FXDirection: TXDirection; FYDirection: TYDirection; FDropDownButton: TdxBarButtonControl; FSubItem: TdxBarSubItemControl; FOnCloseUp: TNotifyEvent; FOnPopup: TNotifyEvent; function GetBandSize: Integer; function GetBarSize: Integer; function GetBarRect: TRect; function GetBottomVisibleItemIndex: Integer; function GetContentRect: TRect; function GetDetachCaptionSize: Integer; function GetMaxVisibleCount: Integer; function GetParentItemControl: TdxBarItemControl; function GetSubMenuOwner: IdxBarSubMenuOwner; function GetToolbarItemsBrush: HBRUSH; function GetTopVisibleItemIndex: Integer; procedure SetDetachCaptionSelected(AValue: Boolean); procedure SetTopIndex(AValue: Integer); procedure CalcBounds(out ASize: TSize); procedure CalcSize(out ASize: TSize); function GetItemsPaneSize: TSize; procedure CreateLightBrush; procedure DestroyLightBrush; procedure PreparePalette(DC: HDC); procedure UnpreparePalette(DC: HDC); procedure ExpandMenu; function ExtendedView: Boolean; procedure InvalidateItemsRect; procedure InvalidateDetachCaption; function MouseOnArrow(AArrowDirection: TcxArrowDirection): Boolean; function MouseOnUpArrow: Boolean; function MouseOnDownArrow: Boolean; procedure SetExpandMenuTimer(Time: UINT; ExpandAfterDelay: Boolean); procedure KillExpandMenuTimer; procedure KillScrollTimer; function IsAnimationRunning: Boolean; procedure OnTerminateAnimation(Sender: TObject); procedure WMGetDlgCode(var Message: TWMGetDlgCode); message WM_GETDLGCODE; procedure WMKeyDown(var Message: TWMKeyDown); message WM_KEYDOWN; procedure WMLButtonDown(var Message: TWMLButtonDown); message WM_LBUTTONDOWN; procedure WMNCCalcSize(var Message: TWMNCCalcSize); message WM_NCCALCSIZE; procedure WMNCHitTest(var Message: TWMNCHitTest); message WM_NCHITTEST; procedure WMNCPaint(var Message: TWMNCPaint); message WM_NCPAINT; procedure WMPrint(var Message: TMessage); message WM_PRINT; procedure WMPrintClient(var Message: TMessage); message WM_PRINTCLIENT; procedure WMRButtonDown(var Message: TWMRButtonDown); message WM_RBUTTONDOWN; procedure WMRButtonUp(var Message: TWMRButtonUp); message WM_RBUTTONUP; procedure WMTimer(var Message: TWMTimer); message WM_TIMER; procedure CMFontChanged(var Message: TMessage); message CM_FONTCHANGED; protected ParentWnd: HWND; procedure AdjustHintWindowPosition(var APos: TPoint; const ABoundsRect: TRect; AHeight: Integer); override; procedure CreateParams(var Params: TCreateParams); override; procedure CreateWnd; override; procedure DestroyWindowHandle; override; procedure DestroyWnd; override; procedure DoCloseUp; dynamic; procedure DoPopup; dynamic; procedure Paint; override; procedure NCPaint(DC: HDC); procedure CalcControlsPositions; override; procedure CalcDrawingConsts; override; procedure CalcDragOverParameters(const ACursorPos: TPoint; out ADragOverItemLink: TdxBarItemLink; out AIsBeginGroup, AIsFirstPart, AIsVerticalDirection: Boolean); override; procedure CalcItemsRect; override; function CanActiveChange: Boolean; override; function CanCustomizing: Boolean; override; function CanDrawClippedItem(AItemRect: TRect): Boolean; override; function CanShowHint: Boolean; override; function CheckLockUpdate: Boolean; override; function ChildrenHaveShadows: Boolean; override; procedure CorrectVisibleItemsRectBottom; override; procedure CorrectVisibleItemsRectTop; override; procedure DoCreateControls; override; procedure DoDestroyControls; override; procedure DoBarMouseLeave; override; procedure DoBarMouseMove(Shift: TShiftState; const APoint: TPoint; AItemControl: TdxBarItemControl); override; procedure DoNCPaint(DC: HDC; const ARect: TRect); virtual; procedure DoHideAll; override; procedure DoPaintItem(AControl: TdxBarItemControl; ACanvas: TcxCanvas; const AItemRect: TRect); override; procedure DoRepaintBar(ARecreateControls: Boolean); override; procedure DoSetIsActive(AValue: Boolean); override; procedure DragOver(X, Y: Integer; var Accept: Boolean); override; function GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; override; function GetBeginGroupSize: Integer; override; function GetBehaviorOptions: TdxBarBehaviorOptions; override; function GetBottomItemControl: TdxBarItemControl; function GetDefaultItemHeight(AItem: TdxBarItemControl): Integer; override; function GetEditFont: TFont; override; function GetIsContextMenu: Boolean; virtual; function GetIsCustomizing: Boolean; override; function GetIsMainMenu: Boolean; override; function GetIsShadowVisible: Boolean; override; function GetItemControlOffset(AItemLink: TdxBarItemLink): Integer; override; function GetItemRectEx(Item: TdxBarItemControl; IsBeginGroup: Boolean): TRect; override; function GetPaintType: TdxBarPaintType; override; function GetSelectableObject: TPersistent; override; function GetTextSize: Integer; override; function GetTopItemControl: TdxBarItemControl; function GetViewInfoClass: TCustomdxBarControlViewInfoClass; override; procedure HideByEscape; function HideOnClick: Boolean; override; function IsInternal: Boolean; override; function IsMeaningParent(AWnd: HWND): Boolean; override; function IsPopup: Boolean; override; function IsVerticalDirection: Boolean; override; procedure SetFont; override; procedure SetRecentItemCount; procedure SetAccelSelectedItem(AItemControl: TdxBarItemControl; ADuplicate: Boolean); override; procedure SetControlVisible(AControl: TdxBarItemControl); override; procedure SetSelectedControl(Value: TdxBarItemControl); override; procedure SetSizeAndCheckBounds(out AChangeXDirection, AChangeYDirection: Boolean); procedure TerminateAnimation; procedure UpdateItem(AControl: TdxBarItemControl); override; procedure InitCustomizationPopup(AItemLinks: TdxBarItemLinks); override; procedure ShowPopup(AItem: TdxBarItemControl); override; function CanDetach: Boolean; function Detachable: Boolean; function DetachCaptionAreaSize: Integer; function DetachCaptionRect: TRect; function MouseOnDetachCaption: Boolean; procedure DoDetachMenu; function MarkArrowSize: Integer; function MarkExists: Boolean; override; function MarkRect: TRect; override; procedure SetMarkState(Value: TdxBarMarkState); override; function DownArrowExists: Boolean; function GetScrollTime: Integer; virtual; function UpArrowExists: Boolean; function UseScrollButtons: Boolean; procedure DoCalcSize(out ASize: TSize); virtual; procedure DoCorrectSize(var ASize: TSize); procedure DoShow; virtual; procedure DrawBar; procedure DrawContent; virtual; procedure DrawScrollArea; procedure FillBackground(DC: HDC; const ARect: TRect; ABrush: HBRUSH; AColor: TColor; AIsClientArea: Boolean); override; procedure DoFillBackgroundEx(ACanvas: TcxCanvas; const ARect: TRect; ABrush: HBRUSH; AColor: TColor; AIsClientArea: Boolean); virtual; procedure FillBackgroundEx(ACanvas: TcxCanvas; const ARect: TRect; ABrush: HBRUSH; AColor: TColor; AIsClientArea: Boolean); function GetBackgroundBitmap: TBitmap; override; function GetBorderSize: Integer; override; function GetClientOffset: TRect; virtual; function GetIndent1: Integer; function GetIndent2: Integer; function GetItemsRectOffset: TRect; virtual; function IsTransparent: Boolean; override; property BandSize: Integer read GetBandSize; property BarSize: Integer read GetBarSize; property BorderSize: Integer read GetBorderSize; property DetachCaptionSelected: Boolean read FDetachCaptionSelected write SetDetachCaptionSelected; property DetachCaptionSize: Integer read GetDetachCaptionSize; property MarkSize: Integer read FMarkSize; property BarRect: TRect read GetBarRect; property ContentRect: TRect read GetContentRect; property ToolbarItemsBrush: HBRUSH read GetToolbarItemsBrush; property BottomItemControl: TdxBarItemControl read GetBottomItemControl; property BottomVisibleItemIndex: Integer read GetBottomVisibleItemIndex; property IsContextMenu: Boolean read GetIsContextMenu; property TopIndex: Integer read FTopIndex write SetTopIndex; property TopItemControl: TdxBarItemControl read GetTopItemControl; property TopVisibleItemIndex: Integer read GetTopVisibleItemIndex; property MaxVisibleCount: Integer read GetMaxVisibleCount; property OnCloseUp: TNotifyEvent read FOnCloseUp write FOnCloseUp; property OnPopup: TNotifyEvent read FOnPopup write FOnPopup; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; procedure Hide; function Kind: TdxBarKind; override; procedure Show; property OwnerWidth: Integer read FOwnerWidth write FOwnerWidth; property OwnerHeight: Integer read FOwnerHeight write FOwnerHeight; property ParentItemControl: TdxBarItemControl read GetParentItemControl; end; TdxBarSubMenuControlViewInfo = class(TCustomdxBarControlViewInfo) private function GetBarControl: TdxBarSubMenuControl; public procedure Calculate; override; property BarControl: TdxBarSubMenuControl read GetBarControl; end; { TdxBarInternalSubMenuControl } TdxBarInternalSubMenuControl = class(TdxBarSubMenuControl, IdxBarLinksOwner) protected function GetIsCustomizing: Boolean; override; function IsInternal: Boolean; override; // IdxBarLinksOwner function CanContainItem(AItem: TdxBarItem; out AErrorText: string): Boolean; function CreateBarControl: TCustomdxBarControl; function GetInstance: TComponent; function GetItemLinks: TdxBarItemLinks; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; end; { TdxBarCustomizingPopup } TdxBarCustomizingPopup = class(TdxBarInternalSubMenuControl) public constructor Create(AOwner: TComponent); override; procedure DoShowCustomizingPopup; end; {-------------------------------------- Items --------------------------------------} TdxBarItemActionLink = class(TActionLink) protected FClient: TdxBarItem; procedure AssignClient(AClient: TObject); override; function IsCaptionLinked: Boolean; override; function IsCheckedLinked: Boolean; override; function IsEnabledLinked: Boolean; override; function IsHelpContextLinked: Boolean; override; function IsHintLinked: Boolean; override; function IsImageIndexLinked: Boolean; override; function IsShortCutLinked: Boolean; override; function IsVisibleLinked: Boolean; override; function IsOnExecuteLinked: Boolean; override; procedure SetCaption(const Value: string); override; procedure SetChecked(Value: Boolean); override; procedure SetEnabled(Value: Boolean); override; procedure SetHelpContext(Value: THelpContext); override; procedure SetHint(const Value: string); override; procedure SetImageIndex(Value: Integer); override; procedure SetShortCut(Value: TShortCut); override; procedure SetVisible(Value: Boolean); override; procedure SetOnExecute(Value: TNotifyEvent); override; end; TdxBarItemActionLinkClass = class of TdxBarItemActionLink; { TdxBarItemStylesData } TdxBarItemStyleChangeKind = (sckDrawing, sckStructure, sckNone); TdxBarItemStylesDataChangeEvent = procedure(AChangeKind: TdxBarItemStyleChangeKind) of object; TdxBarItemStylesData = class(TcxInterfacedPersistent, IcxStyleChangeListener) private FChangeEventLockCount: Integer; FChangeKind: TdxBarItemStyleChangeKind; FIsDestroying: Boolean; FOnChange: TdxBarItemStylesDataChangeEvent; FStyleCount: Integer; FStylesData: array of TdxBarItemStyleData; // IcxStyleChangeListener procedure StyleChanged(AStyle: TcxCustomStyle); procedure StyleRemoved(AStyle: TcxCustomStyle); procedure DoChange(AChangeKind: TdxBarItemStyleChangeKind); function GetStyle(AIndex: Integer): TcxStyle; function GetStyleReferenceCount(AStyle: TcxStyle): Integer; procedure InternalSetStyle(AIndex: Integer; Value: TcxStyle); procedure InternalStyleChanged(AIndex: Integer); overload; procedure InternalStyleChanged(AStyle: TcxStyle); overload; procedure InternalStyleRemoved(AStyle: TcxStyle); function IsChangeEventLocked: Boolean; procedure LockChangeEvent(ALock: Boolean); procedure SetStyle(AIndex: Integer; Value: TcxStyle); protected property IsDestroying: Boolean read FIsDestroying; property StyleCount: Integer read FStyleCount; public constructor Create(AStyleCount: Integer); reintroduce; destructor Destroy; override; property Styles[AIndex: Integer]: TcxStyle read GetStyle write SetStyle; property OnChange: TdxBarItemStylesDataChangeEvent read FOnChange write FOnChange; end; TdxBarScreenTipBandTextAlign = (stbtaLeft, stbtaRight); TdxBarScreenTipBandType = (stbHeader, stbDescription, stbFooter); { TdxBarCustomScreenTipBand } TdxBarCustomScreenTipBand = class(TPersistent) private FBandType: TdxBarScreenTipBandType; FGlyph: TBitmap; FText: string; FTextAlign: TdxBarScreenTipBandTextAlign; FOnChange: TNotifyEvent; procedure SetGlyph(Value: TBitmap); procedure SetText(const Value: string); procedure SetTextAlign(Value: TdxBarScreenTipBandTextAlign); protected procedure Changed; virtual; function GetFont: TFont; virtual; abstract; function IsVisible(const AHintText: string): Boolean; property BandType: TdxBarScreenTipBandType read FBandType write FBandType; property OnChange: TNotifyEvent read FOnChange write FOnChange; public constructor Create(ABandType: TdxBarScreenTipBandType); destructor Destroy; override; procedure Assign(Source: TPersistent); override; property Font: TFont read GetFont; published property Glyph: TBitmap read FGlyph write SetGlyph; property Text: string read FText write SetText; property TextAlign: TdxBarScreenTipBandTextAlign read FTextAlign write SetTextAlign default stbtaRight; end; { TdxBarScreenTipBand } TdxBarScreenTipBand = class(TdxBarCustomScreenTipBand) private FScreenTip: TdxBarScreenTip; protected function GetFont: TFont; override; public constructor Create(AScreenTip: TdxBarScreenTip; ABandType: TdxBarScreenTipBandType); virtual; property ScreenTip: TdxBarScreenTip read FScreenTip; end; { TdxBarScreenTipFooterBand } TdxBarScreenTipFooterBand = class(TdxBarCustomScreenTipBand) private FRepository: TdxBarScreenTipRepository; protected function GetFont: TFont; override; public constructor Create(ARepository: TdxBarScreenTipRepository); property Repository: TdxBarScreenTipRepository read FRepository; end; { TdxBarScreenTip } TdxBarScreenTip = class(TcxComponentCollectionItem) private FBands: array[TdxBarScreenTipBandType] of TdxBarScreenTipBand; FUseHintAsHeader: Boolean; FUseStandardFooter: Boolean; FWidth: Integer; function GetBand(Index: Integer): TdxBarScreenTipBand; procedure SetBand(Index: Integer; Value: TdxBarScreenTipBand); protected function GetBandForCalculation(Index: TdxBarScreenTipBandType): TdxBarCustomScreenTipBand; function GetCollection: TdxBarScreenTipCollection; virtual; function GetCollectionFromParent(AParent: TComponent): TcxComponentCollection; override; function GetDisplayName: string; override; function GetWidth: Integer; virtual; procedure SetName(const Value: TComponentName); override; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; procedure Assign(Source: TPersistent); override; property Collection: TdxBarScreenTipCollection read GetCollection; published property Header: TdxBarScreenTipBand index stbHeader read GetBand write SetBand; property Description: TdxBarScreenTipBand index stbDescription read GetBand write SetBand; property Footer: TdxBarScreenTipBand index stbFooter read GetBand write SetBand; property UseHintAsHeader: Boolean read FUseHintAsHeader write FUseHintAsHeader default False; property UseStandardFooter: Boolean read FUseStandardFooter write FUseStandardFooter default False; property Width: Integer read FWidth write FWidth default 0; end; { TdxBarScreenTipCollection } TdxBarScreenTipCollection = class(TcxComponentCollection) private FRepository: TdxBarScreenTipRepository; function GetItem(Index: Integer): TdxBarScreenTip; procedure SetItem(Index: Integer; Value: TdxBarScreenTip); protected procedure SetItemName(AItem: TcxComponentCollectionItem); override; procedure UpdateFonts; public constructor Create(AParentComponent: TComponent; AItemClass: TcxComponentCollectionItemClass); override; function Add: TdxBarScreenTip; property Repository: TdxBarScreenTipRepository read FRepository; property Items[Index: Integer]: TdxBarScreenTip read GetItem write SetItem; default; end; { TdxBarScreenTipRepository } TdxScreenTipRepositoryFonts = set of TdxBarScreenTipBandType; TdxBarScreenTipRepository = class(TComponent) private FAssignedFonts: TdxScreenTipRepositoryFonts; FFonts: array[TdxBarScreenTipBandType] of TFont; FItems: TdxBarScreenTipCollection; FShowDescription: Boolean; FStandardFooter: TdxBarScreenTipFooterBand; FSystemFont: TFont; procedure CreateFonts; procedure FontChanged(Sender: TObject); function GetFont(Index: Integer): TFont; function IsFontStored(Index: Integer): Boolean; procedure SetFont(Index: Integer; Value: TFont); procedure SetItems(AValue: TdxBarScreenTipCollection); procedure SetStandardFooter(Value: TdxBarScreenTipFooterBand); protected function CreateScreenTips: TdxBarScreenTipCollection; virtual; function GetBandFont(ABandType: TdxBarScreenTipBandType): TFont; virtual; procedure GetChildren(Proc: TGetChildProc; Root: TComponent); override; function GetSystemFont(ABandType: TdxBarScreenTipBandType): TFont; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; procedure Assign(Source: TPersistent); override; published property AssignedFonts: TdxScreenTipRepositoryFonts read FAssignedFonts write FAssignedFonts default []; property Items: TdxBarScreenTipCollection read FItems write SetItems; property DescriptionFont: TFont index stbDescription read GetFont write SetFont stored IsFontStored; property FooterFont: TFont index stbFooter read GetFont write SetFont stored IsFontStored; property HeaderFont: TFont index stbHeader read GetFont write SetFont stored IsFontStored; property StandardFooter: TdxBarScreenTipFooterBand read FStandardFooter write SetStandardFooter; property ShowDescription: Boolean read FShowDescription write FShowDescription default True; end; { TdxBarCustomHintViewInfo } TdxBarCustomHintViewInfo = class private FBarManager: TdxBarManager; FBoundsRect: TRect; protected procedure Calculate(ACanvas: TCanvas); virtual; abstract; function IsScreenTip: Boolean; virtual; procedure Paint(ACanvas: TCanvas); virtual; abstract; procedure SetWindowDrawParams(AWindow: TdxBarHintWindow); virtual; public constructor Create(ABarManager: TdxBarManager); property BarManager: TdxBarManager read FBarManager; property BoundsRect: TRect read FBoundsRect write FBoundsRect; end; { TdxBarHintViewInfo } TdxBarHintViewInfo = class(TdxBarCustomHintViewInfo) private FText: string; FPos: TPoint; function CalculateMinSize(ACanvas: TCanvas): TSize; protected procedure CorrectMinSize(var ASize: TSize); virtual; function GetTextRect: TRect; virtual; procedure DrawText(ACanvas: TCanvas); virtual; procedure SetWindowDrawParams(AWindow: TdxBarHintWindow); override; procedure SetWindowFont(AWindow: TdxBarHintWindow); virtual; property Text: string read FText write FText; property Pos: TPoint read FPos write FPos; public constructor Create(ABarManager: TdxBarManager; const AHint, AShortCut: string; const ACursorPos: TPoint); procedure Calculate(ACanvas: TCanvas); override; procedure Paint(ACanvas: TCanvas); override; end; { TdxBarLikeHintScreenTipViewInfo } TdxBarLikeHintScreenTipViewInfo = class(TdxBarHintViewInfo) private FSkinnedObject: TObject; function GetISkin: IdxSkin; protected procedure CorrectMinSize(var ASize: TSize); override; function GetTextRect: TRect; override; function IsScreenTip: Boolean; override; property ISkin: IdxSkin read GetISkin; public constructor Create(ABarManager: TdxBarManager; ASkin: TObject; const AHint, AShortCut: string; const ACursorPos: TPoint); procedure Paint(ACanvas: TCanvas); override; end; { TdxBarScreenTipBandViewInfo } TdxBarScreenTipBandViewInfo = class private FBand: TdxBarCustomScreenTipBand; FBandBounds: TRect; FGlyphBounds: TRect; FGlyphSize: TSize; FHintText: string; FShortCut: string; FTextBounds: TRect; FTextSize: TSize; FTop: Integer; FWidth: Integer; protected function GetAvailGlyphWidth: Integer; function GetHorzIndent: Integer; function GetVertIndent: Integer; function GetText: string; function HasGlyph: Boolean; function HasText: Boolean; function HeightToCurrentDpi(AValue: Integer): Integer; function WidthToCurrentDpi(AValue: Integer): Integer; function HorzPixelsPerInch: Integer; function VertPixelsPerInch: Integer; procedure Paint(ACanvas: TCanvas; ALightColor, ADarkColor: TColor); property BandBounds: TRect read FBandBounds; property GlyphBounds: TRect read FGlyphBounds; property TextBounds: TRect read FTextBounds; property Top: Integer read FTop; property Width: Integer read FWidth; public constructor Create(ABand: TdxBarCustomScreenTipBand; const AHintText, AShortCut: string); procedure Calculate(AWidth: Integer; var ATop: Integer; AHeight: Integer); function GetHeight(ACanvas: TCanvas; const AWidth: Integer): Integer; function IsVisible: Boolean; property Band: TdxBarCustomScreenTipBand read FBand; end; { TdxBarScreenTipViewInfo } TdxBarScreenTipViewInfo = class(TdxBarCustomHintViewInfo) private FSkinnedObject: TObject; FScreenTip: TdxBarScreenTip; FHintText: string; FShortCut: string; FBandViewInfos: array of TdxBarScreenTipBandViewInfo; FWidth: Integer; procedure DestroyBandViewInfos; function GetBandViewInfos(Index: Integer): TdxBarScreenTipBandViewInfo; function GetBandViewInfosCount: Integer; function GetISkin: IdxSkin; protected function CreateBandViewInfo(ABand: TdxBarCustomScreenTipBand): TdxBarScreenTipBandViewInfo; virtual; function IsScreenTip: Boolean; override; property ISkin: IdxSkin read GetISkin; public constructor Create(AScreenTip: TdxBarScreenTip; ASkin: TObject; const AHintText: string; AShortCut: string = ''); destructor Destroy; override; procedure Calculate(ACanvas: TCanvas); override; procedure Paint(ACanvas: TCanvas); override; property ScreenTip: TdxBarScreenTip read FScreenTip; property BandViewInfosCount: Integer read GetBandViewInfosCount; property BandViewInfos[Index: Integer]: TdxBarScreenTipBandViewInfo read GetBandViewInfos; end; { TdxBarHintWindow } TdxBarHintWindow = class(TCustomControl) private FIsScreenTipWindow: Boolean; FViewInfo: TdxBarCustomHintViewInfo; procedure SetIsScreenTipWindow(Value: Boolean); procedure WMNCHitTest(var Message: TWMNCHitTest); message WM_NCHITTEST; procedure WMShowWindow(var Message: TWMShowWindow); message WM_SHOWWINDOW; procedure WMSize(var Message: TWMSize); message WM_SIZE; protected procedure CorrectWindowPos(var P: TPoint); virtual; procedure CreateParams(var Params: TCreateParams); override; function GetHideHintTime: Integer; virtual; function GetShowHintTime: Integer; virtual; procedure Paint; override; procedure RecreateWindow; virtual; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; function ActivateHint(ABarManager: TdxBarManager; const AHintText, AShortCut: string): Boolean; virtual; property ShowHintTime: Integer read GetShowHintTime; property HideHintTime: Integer read GetHideHintTime; property IsScreenTipWindow: Boolean read FIsScreenTipWindow write SetIsScreenTipWindow; end; { TdxBarItem } TdxBarItem = class(TdxBarComponent) private FActionLink: TdxBarItemActionLink; FAlign: TdxBarItemAlign; FCanSelect: Boolean; FCaption: string; FCategory: Integer; FCheckDefaults: Boolean; FClickItemLink: TdxBarItemLink; FData: TObject; FDescription: string; FGlyph: TBitmap; FHelpContext: THelpContext; FHint: string; FImageIndex: Integer; FKeyTip: string; FLargeGlyph: TBitmap; FLargeImageIndex: Integer; FLinks: TList; // the list of the itemlinks FLoadedVisible: TdxBarItemVisible; FMergeKind: TdxBarItemMergeKind; FMergeOrder: Integer; FPaintStyle: TdxBarPaintStyle; FShortCut: TShortCut; FStylesData: TdxBarItemStylesData; FScreenTip: TdxBarScreenTip; FUnclickAfterDoing: Boolean; FWidth: Integer; FOnClick: TNotifyEvent; FOnCreate: TNotifyEvent; FOnDestroy: TNotifyEvent; function GetAction: TBasicAction; function GetActiveLink: TdxBarItemLink; function GetActuallyVisible: Boolean; function GetCurItemLink: TdxBarItemLink; function GetFlat: Boolean; function GetIndex: Integer; function GetIsDesigning: Boolean; function GetIsDestroying: Boolean; function GetIsLoading: Boolean; function GetLinkCount: Integer; function GetLinks(Index: Integer): TdxBarItemLink; function GetPainterClass: TdxBarPainterClass; function GetVisibleForUser: Boolean; procedure SetAction(Value: TBasicAction); procedure SetAlign(Value: TdxBarItemAlign); procedure SetCategory(Value: Integer); procedure SetDescription(Value: string); procedure SetGlyph(Value: TBitmap); procedure SetGlyphLayout(Value: TdxBarGlyphLayout); procedure SetIndex(Value: Integer); procedure SetLargeGlyph(Value: TBitmap); procedure SetMergeOrder(Value: Integer); procedure SetPaintStyle(Value: TdxBarPaintStyle); procedure SetScreenTip(Value: TdxBarScreenTip); procedure SetShowCaption(Value: Boolean); procedure SetShortCut(Value: TShortCut); procedure DestroyLinks; procedure DoActionChange(Sender: TObject); function IsEnabledStored: Boolean; function IsHelpContextStored: Boolean; function IsHintStored: Boolean; function IsImageIndexStored: Boolean; function IsShortCutStored: Boolean; function IsVisibleStored: Boolean; function IsOnClickStored: Boolean; function GetHintFromCaption: string; procedure OnGlyphChanged(Sender: TObject); procedure OnLargeGlyphChanged(Sender: TObject); protected FGlyphLayout: TdxBarGlyphLayout; FShowCaption: Boolean; procedure AssignTo(Dest: TPersistent); override; function GetEnabled: Boolean; override; function GetWidth: Integer; virtual; procedure Loaded; override; procedure Notification(AComponent: TComponent; Operation: TOperation); override; procedure ReadState(Reader: TReader); override; procedure SelectionChanged; override; procedure SetName(const NewName: TComponentName); override; procedure SetEnabled(Value: Boolean); override; procedure SetVisible(Value: TdxBarItemVisible); override; procedure SetWidth(Value: Integer); virtual; // IdxBarSelectableItem function CanDelete(ADestruction: Boolean = False): Boolean; override; procedure ExecuteCustomizationAction(ABasicAction: TdxBarCustomizationAction); override; procedure GetMasterObjects(AList: TdxObjectList); override; function GetNextSelectableItem: IdxBarSelectableItem; override; function GetSelectableParent: TPersistent; override; function GetSupportedActions: TdxBarCustomizationActions; override; procedure DeleteSelection(var AReference: IdxBarSelectableItem; ADestruction: Boolean); override; procedure Invalidate; override; function IsComplex: Boolean; override; function SelectParentComponent: Boolean; override; procedure ActionChange(Sender: TObject; CheckDefaults: Boolean); dynamic; procedure BarManagerChanged; virtual; function CanBeOnToolbar(AToolbar: TdxBar; out AErrorText: string): Boolean; virtual; function CanChangePaintStyle: Boolean; virtual; function CanClicked: Boolean; virtual; function CanMergeWith(AItem: TdxBarItem): Boolean; property CanSelect: Boolean read FCanSelect write FCanSelect default True; function CurImageIndexLinked: Boolean; procedure DrawCustomizingImage(ACanvas: TCanvas; const ARect: TRect; AState: TOwnerDrawState); virtual; procedure DrawCustomizingImageContent(ACanvas: TCanvas; const ARect: TRect; ASelected: Boolean); virtual; function GetActionLinkClass: TdxBarItemActionLinkClass; dynamic; function GetActionImageIndex: Integer; virtual; procedure SetActionImageIndex(Value: Integer); virtual; function GetControlClass(AIsVertical: Boolean): TdxBarItemControlClass; virtual; function GetHidden: Boolean; virtual; function GetItemLinks: TdxBarItemLinks; virtual; class function GetStyleCount: Integer; virtual; function GetStyleValue(AIndex: Integer): TcxStyle; function HasAccel(AItemLink: TdxBarItemLink): Boolean; virtual; function HasControls: Boolean; procedure HideControl(AControl: TdxBarItemControl); virtual; function InternalActuallyVisible: Boolean; virtual; function InternalCanMergeWith(AItem: TdxBarItem): Boolean; virtual; function IsHintFromCaption: Boolean; function IsImageIndexLinked(AImageList: TCustomImageList; AImageIndex: Integer): Boolean; function IsStyleColorSupported: Boolean; virtual; function NeedToBeHidden: Boolean; virtual; procedure ObjectNotification(AOperation: TOperation; AObject: TObject); virtual; procedure Recalculate; virtual; procedure SetImageIndex(Value: Integer); virtual; procedure SetLargeImageIndex(Value: Integer); virtual; procedure SetStyleValue(AIndex: Integer; Value: TcxStyle); procedure ShowDefaultEventHandler; procedure Update; virtual; procedure UpdateEx(AParentKinds: TdxBarKinds = [bkBarControl, bkBarQuickControl, bkSubMenu]); virtual; function UseHotImages: Boolean; virtual; function UseLargeImages: Boolean; virtual; // Change Group procedure CaptionChanged; virtual; procedure EnabledChanged; virtual; procedure GlyphChanged; virtual; procedure HotGlyphChanged; virtual; procedure InternalStyleChanged(AChangeKind: TdxBarItemStyleChangeKind); procedure LargeGlyphChanged; virtual; procedure PaintStyleChanged; virtual; procedure ShortCutChanged; virtual; procedure VisibleChanged; virtual; procedure WidthChanged; virtual; function GetCaption: string; virtual; function IsCaptionStored: Boolean; virtual; procedure SetCaption(const Value: string); virtual; procedure CheckLinks(ASource: TCustomIniFile; const ABaseSection: string); virtual; procedure LoadFromIni(ASource: TCustomIniFile; const ABaseSection: string; AStoringKind: TdxBarStoringKind); virtual; procedure LoadUsageData(ASource: TCustomIniFile; const ABaseSection: string); virtual; procedure SaveToIni(ADestination: TCustomIniFile; const ABaseSection: string; AStoringKind: TdxBarStoringKind); virtual; procedure GetTextViewParams(out AViewParams: TcxViewParams); procedure GetViewParams(AStyle: TcxStyle; out AViewParams: TcxViewParams); class function GetNewCaption: string; virtual; property ActionLink: TdxBarItemActionLink read FActionLink write FActionLink; property ActionImageIndex: Integer read GetActionImageIndex write SetActionImageIndex; property Flat: Boolean read GetFlat; property GlyphLayout: TdxBarGlyphLayout read FGlyphLayout write SetGlyphLayout; property Hidden: Boolean read GetHidden; property IsDesigning: Boolean read GetIsDesigning; property IsDestroying: Boolean read GetIsDestroying; property IsLoading: Boolean read GetIsLoading; property PainterClass: TdxBarPainterClass read GetPainterClass; property PaintStyle: TdxBarPaintStyle read FPaintStyle write SetPaintStyle default psStandard; property ShowCaption: Boolean read FShowCaption write SetShowCaption; property StylesData: TdxBarItemStylesData read FStylesData; property Width: Integer read GetWidth write SetWidth; property OnCreate: TNotifyEvent read FOnCreate write FOnCreate; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; procedure BeforeDestruction; override; procedure Click; dynamic; procedure DirectClick; dynamic; procedure DoClick; dynamic; function GetParentComponent: TComponent; override; function HasParent: Boolean; override; procedure SetParentComponent(AParent: TComponent); override; function GetCurImages: TCustomImageList; virtual; property ActuallyVisible: Boolean read GetActuallyVisible; property ClickItemLink: TdxBarItemLink read FClickItemLink; property CurItemLink: TdxBarItemLink read GetCurItemLink; property Data: TObject read FData write FData; property Glyph: TBitmap read FGlyph write SetGlyph; property ImageIndex: Integer read FImageIndex write SetImageIndex stored IsImageIndexStored default -1; property Index: Integer read GetIndex write SetIndex; property LargeGlyph: TBitmap read FLargeGlyph write SetLargeGlyph; property LargeImageIndex: Integer read FLargeImageIndex write SetLargeImageIndex default -1; property LinkCount: Integer read GetLinkCount; property Links[Index: Integer]: TdxBarItemLink read GetLinks; property ShortCut: TShortCut read FShortCut write SetShortCut stored IsShortCutStored default 0; property UnclickAfterDoing: Boolean read FUnclickAfterDoing write FUnclickAfterDoing default False; property VisibleForUser: Boolean read GetVisibleForUser; property OnClick: TNotifyEvent read FOnClick write FOnClick stored IsOnClickStored; published property Action: TBasicAction read GetAction write SetAction; property Align: TdxBarItemAlign read FAlign write SetAlign default iaLeft; property Caption: string read GetCaption write SetCaption stored IsCaptionStored; property Category: Integer read FCategory write SetCategory; property Description: string read FDescription write SetDescription; property Enabled stored IsEnabledStored default True; property HelpContext: THelpContext read FHelpContext write FHelpContext stored IsHelpContextStored default 0; property Hint: string read FHint write FHint stored IsHintStored; property KeyTip: string read FKeyTip write FKeyTip; property MergeKind: TdxBarItemMergeKind read FMergeKind write FMergeKind default mkAdd; property MergeOrder: Integer read FMergeOrder write SetMergeOrder default 0; property Style: TcxStyle index 0 read GetStyleValue write SetStyleValue; property ScreenTip: TdxBarScreenTip read FScreenTip write SetScreenTip; property Visible stored IsVisibleStored; property OnDestroy: TNotifyEvent read FOnDestroy write FOnDestroy; end; TdxBarLabel = class(TdxBarItem) public constructor Create(AOwner: TComponent); override; end; TdxBarSeparator = class(TdxBarLabel) protected function CanBeOnToolbar(AToolbar: TdxBar; out AErrorText: string): Boolean; override; class function GetNewCaption: string; override; function GetSupportedActions: TdxBarCustomizationActions; override; published property ShowCaption default True; end; TdxBarWindowItem = class(TdxBarItem) private FEmptyWindow: Boolean; FText: string; FOnChange: TNotifyEvent; FOnCurChange: TNotifyEvent; FOnEnter: TNotifyEvent; FOnExit: TNotifyEvent; FOnKeyDown: TKeyEvent; FOnKeyPress: TKeyPressEvent; FOnKeyUp: TKeyEvent; function GetCurText: string; function GetFocusedItemLink: TdxBarItemLink; procedure SetCurText(Value: string); protected function CanClicked: Boolean; override; procedure Change; dynamic; procedure CurChange; dynamic; procedure DoEnter; dynamic; procedure DoExit; dynamic; function GetControlClass(AIsVertical: Boolean): TdxBarItemControlClass; override; function GetText: string; virtual; procedure KeyDown(var Key: Word; Shift: TShiftState); dynamic; procedure KeyPress(var Key: Char); dynamic; procedure KeyUp(var Key: Word; Shift: TShiftState); dynamic; procedure SetText(Value: string); virtual; property EmptyWindow: Boolean read FEmptyWindow write FEmptyWindow; public procedure SetFocus(ACheckBarControlVisibility: Boolean = False); virtual; property CurText: string read GetCurText write SetCurText; property FocusedItemLink: TdxBarItemLink read GetFocusedItemLink; published property Text: string read GetText write SetText; property OnChange: TNotifyEvent read FOnChange write FOnChange; property OnCurChange: TNotifyEvent read FOnCurChange write FOnCurChange; property OnEnter: TNotifyEvent read FOnEnter write FOnEnter; property OnExit: TNotifyEvent read FOnExit write FOnExit; property OnKeyDown: TKeyEvent read FOnKeyDown write FOnKeyDown; property OnKeyPress: TKeyPressEvent read FOnKeyPress write FOnKeyPress; property OnKeyUp: TKeyEvent read FOnKeyUp write FOnKeyUp; end; TdxBarButtonState = (bstChecked, bstDropDown); TdxBarButtonStates = set of TdxBarButtonState; TdxBarButtonStyle = (bsDefault, bsChecked, bsDropDown, bsCheckedDropDown); TdxBarButton = class(TdxBarItem, IdxBarLinksOwner) private FAllowAllUp: Boolean; FCloseSubMenuOnClick: Boolean; FDown: Boolean; FDropDownEnabled: Boolean; FDropDownMenu: TdxBarPopupMenu; FGroupIndex: Integer; FInternalStates: TdxBarButtonStates; FLowered: Boolean; function GetButtonStyle: TdxBarButtonStyle; procedure SetAllowAllUp(Value: Boolean); procedure SetButtonStyle(Value: TdxBarButtonStyle); procedure SetDown(Value: Boolean); procedure SetDropDownEnabled(Value: Boolean); procedure SetDropDownMenu(Value: TdxBarPopupMenu); procedure SetGroupIndex(Value: Integer); procedure SetLowered(Value: Boolean); function IsDownStored: Boolean; protected function CanChangePaintStyle: Boolean; override; procedure DoDropDown(AControl: TdxBarButtonControl; X, Y: Integer; ByMouse: Boolean); dynamic; function HasAccel(AItemLink: TdxBarItemLink): Boolean; override; procedure Notification(AComponent: TComponent; Operation: TOperation); override; procedure PaintStyleChanged; override; // IdxBarLinksOwner function CanContainItem(AItem: TdxBarItem; out AErrorText: string): Boolean; function CreateBarControl: TCustomdxBarControl; function IdxBarLinksOwner.GetInstance = GetComponentInstance; function GetItemLinks: TdxBarItemLinks; override; // IdxBarSelectableItem function GetSupportedActions: TdxBarCustomizationActions; override; class function GetNewCaption: string; override; public constructor Create(AOwner: TComponent); override; procedure Click; override; published property AllowAllUp: Boolean read FAllowAllUp write SetAllowAllUp default False; property ButtonStyle: TdxBarButtonStyle read GetButtonStyle write SetButtonStyle default bsDefault; property CloseSubMenuOnClick: Boolean read FCloseSubMenuOnClick write FCloseSubMenuOnClick default True; property DropDownEnabled: Boolean read FDropDownEnabled write SetDropDownEnabled default True; property GroupIndex: Integer read FGroupIndex write SetGroupIndex default 0; // must be here property Down: Boolean read FDown write SetDown stored IsDownStored default False; property DropDownMenu: TdxBarPopupMenu read FDropDownMenu write SetDropDownMenu; property Glyph; property ImageIndex; property LargeGlyph; property LargeImageIndex; property Lowered: Boolean read FLowered write SetLowered default False; property PaintStyle; property ShortCut; property UnclickAfterDoing default True; property OnClick; end; TdxBarApplicationMenuButtonItem = class(TdxBarItem) private FOwner: TdxBarApplicationMenuButton; protected procedure Notification(AComponent: TComponent; Operation: TOperation); override; procedure SetVisible(Value: TdxBarItemVisible); override; procedure VisibleChanged; override; procedure WidthChanged; override; public constructor Create(AOwner: TdxBarApplicationMenuButton); reintroduce; virtual; procedure Assign(ASource: TPersistent); override; property Width; end; TdxCustomBarEdit = class(TdxBarWindowItem) private FGlyphLoaded: Boolean; protected procedure ReadState(Reader: TReader); override; procedure DrawCustomizingImage(ACanvas: TCanvas; const ARect: TRect; AState: TOwnerDrawState); override; procedure GetEditViewParams(out AViewParams: TcxViewParams); class function GetStyleCount: Integer; override; function HasAccel(AItemLink: TdxBarItemLink): Boolean; override; procedure SetWidth(Value: Integer); override; procedure WidthChanged; override; property StyleEdit: TcxStyle index 1 read GetStyleValue write SetStyleValue; public constructor Create(AOwner: TComponent); override; published property Glyph; property ImageIndex; property ShowCaption default False; property Width; property OnClick; end; TdxBarEdit = class(TdxCustomBarEdit) private FMaxLength: Integer; FReadOnly: Boolean; procedure SetMaxLength(Value: Integer); protected procedure DrawInterior(ABarEditControl: TdxBarEditControl; ACanvas: TCanvas; R: TRect; ItemLink: TdxBarItemLink); virtual; published property MaxLength: Integer read FMaxLength write SetMaxLength default 0; property ReadOnly: Boolean read FReadOnly write FReadOnly default False; property StyleEdit; end; TCustomdxBarCombo = class; TdxBarCheckKeyForDropDownWindowEvent = procedure (Sender: TCustomdxBarCombo; Key: Word; Shift: TShiftState; var AcceptKey: Boolean) of object; TdxBarGetDropDownWindowEvent = procedure (Sender: TCustomdxBarCombo; var Window: HWND) of object; TCustomdxBarCombo = class(TdxBarEdit) private FOnCheckKeyForDropDownWindow: TdxBarCheckKeyForDropDownWindowEvent; FOnCloseUp: TNotifyEvent; FOnDropDown: TNotifyEvent; FOnGetDropDownWindow: TdxBarGetDropDownWindowEvent; function GetDroppedDown: Boolean; function GetShowEditor: Boolean; procedure SetDroppedDown(Value: Boolean); procedure SetShowEditor(Value: Boolean); protected procedure AfterDropDown; dynamic; procedure CheckDropDownPoint(var X, Y: Integer); function CheckKeyForDropDownWindow(Key: Word; Shift: TShiftState): Boolean; virtual; procedure CloseUp; dynamic; procedure DrawCustomizingImage(ACanvas: TCanvas; const ARect: TRect; AState: TOwnerDrawState); override; procedure DropDown(X, Y: Integer); dynamic; function GetDropDownWindow: HWND; virtual; procedure InitDropDownWindow; virtual; procedure InternalInitDropDownWindow(ADropDownWindow: TWinControl); public property DropDownWindow: HWND read GetDropDownWindow; property DroppedDown: Boolean read GetDroppedDown write SetDroppedDown; published property ShowEditor: Boolean read GetShowEditor write SetShowEditor default True; property OnCheckKeyForDropDownWindow: TdxBarCheckKeyForDropDownWindowEvent read FOnCheckKeyForDropDownWindow write FOnCheckKeyForDropDownWindow; property OnCloseUp: TNotifyEvent read FOnCloseUp write FOnCloseUp; property OnDropDown: TNotifyEvent read FOnDropDown write FOnDropDown; property OnGetDropDownWindow: TdxBarGetDropDownWindowEvent read FOnGetDropDownWindow write FOnGetDropDownWindow; end; TdxBarCustomCombo = class; TdxBarDrawItemEvent = procedure(Sender: TdxBarCustomCombo; AIndex: Integer; ARect: TRect; AState: TOwnerDrawState) of object; TdxBarMeasureItemEvent = procedure(Sender: TdxBarCustomCombo; AIndex: Integer; var AHeight: Integer) of object; TdxBarCustomCombo = class(TCustomdxBarCombo) private FDropDownCount: Integer; FDropDownWidth: Integer; FInteriorIsDrawing: Boolean; FItemHeight: Integer; FItemIndex: Integer; FItems: TStrings; FListBox: TCustomListBox; FSorted: Boolean; FOnDrawItem: TdxBarDrawItemEvent; FOnMeasureItem: TdxBarMeasureItemEvent; function GetCurItemIndex: Integer; function GetItemsHeight(Index: Integer): Integer; procedure SetCurItemIndex(Value: Integer); procedure SetItemIndex(Value: Integer); procedure SetItems(Value: TStrings); procedure SetSorted(Value: Boolean); procedure CheckLocalPos; procedure ItemsChanged(Sender: TObject); procedure ListBoxDrawItem(Control: TWinControl; Index: Integer; Rect: TRect; State: TOwnerDrawState); procedure ListBoxMeasureItem(Control: TWinControl; Index: Integer; var Height: Integer); protected FCanvas: TCanvas; procedure AfterDropDown; override; function CheckKeyForDropDownWindow(Key: Word; Shift: TShiftState): Boolean; override; procedure CloseUp; override; procedure CurChange; override; procedure DrawInterior(ABarEditControl: TdxBarEditControl; ACanvas: TCanvas; R: TRect; ItemLink: TdxBarItemLink); override; procedure DrawItem(ABarEditControl: TdxBarEditControl; AIndex: Integer; ARect: TRect; AState: TOwnerDrawState); virtual; procedure DropDown(X, Y: Integer); override; function GetCanvas: TCanvas; virtual; function GetDropDownWidth: Integer; virtual; function GetDropDownWindow: HWND; override; function GetNearestItemIndex(AText: string): Integer; procedure InitDropDownWindow; override; procedure MeasureItem(AIndex: Integer; var AHeight: Integer); virtual; procedure MeasureItemWidth(AIndex: Integer; var AWidth: Integer); virtual; procedure SetText(Value: string); override; property ListBox: TCustomListBox read FListBox; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; property Canvas: TCanvas read GetCanvas; property CurItemIndex: Integer read GetCurItemIndex write SetCurItemIndex; property ItemHeight: Integer read FItemHeight write FItemHeight default 0; property Items: TStrings read FItems write SetItems; property ItemsHeight[Index: Integer]: Integer read GetItemsHeight; property Sorted: Boolean read FSorted write SetSorted default False; property ItemIndex: Integer read FItemIndex write SetItemIndex; // loading after all published property DropDownCount: Integer read FDropDownCount write FDropDownCount default 8; property DropDownWidth: Integer read FDropDownWidth write FDropDownWidth default 0; property OnDrawItem: TdxBarDrawItemEvent read FOnDrawItem write FOnDrawItem; property OnMeasureItem: TdxBarMeasureItemEvent read FOnMeasureItem write FOnMeasureItem; end; TdxBarCombo = class(TdxBarCustomCombo) published property ItemHeight; property Items; property Sorted; property ItemIndex; // loading after all end; TCustomdxBarSubItem = class(TdxBarItem, IdxBarLinksOwner, IdxBarSubMenuOwner) private FBarSize: Integer; FDetachable: Boolean; FDetachingBar: TdxBar; FIsInternal: Boolean; FItemLinks: TdxBarItemLinks; FOnCloseUp: TNotifyEvent; FOnDetaching: TNotifyEvent; FOnPaintBar: TdxBarPaintSubMenuBarEvent; FOnPopup: TNotifyEvent; function GetDetachingBarIndex: Integer; function GetItemOptions: TdxBarItemOptions; procedure SetBarSize(Value: Integer); procedure SetDetachingBar(Value: Integer); procedure SetIsInternal(Value: Boolean); procedure SetItemLinks(Value: TdxBarItemLinks); procedure SetItemOptions(Value: TdxBarItemOptions); protected procedure BarManagerChanged; override; function CanClicked: Boolean; override; procedure DoCloseUp; dynamic; procedure DoDetaching; dynamic; procedure DoPopup; dynamic; function HasDesignTimeLinks: Boolean; virtual; procedure InternalDropDown(AItemControl: TdxBarSubItemControl; AByMouse: Boolean); function IsShortCut(AShortCut: TShortCut): Boolean; procedure ObjectNotification(AOperation: TOperation; AObject: TObject); override; procedure CheckLinks(ASource: TCustomIniFile; const ABaseSection: string); override; function GetIniSection(const ABaseSection: string): string; procedure LoadFromIni(ASource: TCustomIniFile; const ABaseSection: string; AStoringKind: TdxBarStoringKind); override; procedure LoadUsageData(ASource: TCustomIniFile; const ABaseSection: string); override; procedure SaveToIni(ADestination: TCustomIniFile; const ABaseSection: string; AStoringKind: TdxBarStoringKind); override; // IdxBarLinksOwner function CanContainItem(AItem: TdxBarItem; out AErrorText: string): Boolean; function CreateBarControl: TCustomdxBarControl; virtual; function IdxBarLinksOwner.GetInstance = GetComponentInstance; function GetItemLinks: TdxBarItemLinks; override; // IdxBarSubMenuOwner function GetBarSize: Integer; procedure DoPaintBar(Canvas: TCanvas; const R: TRect); virtual; property IsInternal: Boolean read FIsInternal write SetIsInternal; property ItemOptions: TdxBarItemOptions read GetItemOptions write SetItemOptions; property OnCloseUp: TNotifyEvent read FOnCloseUp write FOnCloseUp; property OnPopup: TNotifyEvent read FOnPopup write FOnPopup; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; function GetDetachingBar: TdxBar; procedure DropDown(AByMouse: Boolean = False); property ItemLinks: TdxBarItemLinks read GetItemLinks write SetItemLinks; published property BarSize: Integer read GetBarSize write SetBarSize default 0; property Detachable: Boolean read FDetachable write FDetachable default False; property DetachingBar: Integer read GetDetachingBarIndex write SetDetachingBar default -1; property Glyph; property ImageIndex; property LargeGlyph; property LargeImageIndex; property ShowCaption default True; property OnClick; property OnDetaching: TNotifyEvent read FOnDetaching write FOnDetaching; property OnPaintBar: TdxBarPaintSubMenuBarEvent read FOnPaintBar write FOnPaintBar; end; TdxBarSubItem = class(TCustomdxBarSubItem) private FAllowCustomizing: Boolean; protected class function GetNewCaption: string; override; function HasDesignTimeLinks: Boolean; override; function InternalCanMergeWith(AItem: TdxBarItem): Boolean; override; public constructor Create(AOwner: TComponent); override; published property AllowCustomizing: Boolean read FAllowCustomizing write FAllowCustomizing default True; property ItemLinks; property ItemOptions; property OnCloseUp; property OnPopup; end; TCustomdxBarContainerItem = class(TCustomdxBarSubItem) private FInOnGetData: Boolean; FNeedClearItemList: Boolean; FOnGetData: TNotifyEvent; protected procedure AddListedItemLinks(AItemLinks: TdxBarItemLinks; AIndex: Integer; FirstCall: Boolean; CallingItemLink: TdxBarItemLink); virtual; procedure DeleteListedItemLinks(AItemLinks: TdxBarItemLinks; AIndex: Integer); virtual; procedure ClearItemList; virtual; function HideWhenRun: Boolean; virtual; function InternalActuallyVisible: Boolean; override; procedure ItemsChanged(AItemLinks: TObject); virtual; procedure NeedClearItemList; public destructor Destroy; override; published property OnGetData: TNotifyEvent read FOnGetData write FOnGetData; end; TdxBarListItem = class(TCustomdxBarContainerItem) private FItemIndex: Integer; FItemList: TList; FItems: TStrings; FShowCheck: Boolean; FShowNumbers: Boolean; function GetDataIndex: Integer; procedure SetDataIndex(Value: Integer); procedure SetItems(Value: TStrings); procedure ClickItem(Sender: TObject); protected procedure AddListedItemLinks(AItemLinks: TdxBarItemLinks; AIndex: Integer; FirstCall: Boolean; CallingItemLink: TdxBarItemLink); override; procedure ClearItemList; override; procedure DeleteListedItemLinks(AItemLinks: TdxBarItemLinks; AIndex: Integer); override; function GetDisplayHint(const AText: string): string; virtual; function GetDisplayText(const AText: string): string; virtual; function InternalActuallyVisible: Boolean; override; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; procedure DirectClick; override; property ItemList: TList read FItemList; published property DataIndex: Integer read GetDataIndex write SetDataIndex stored False; property ItemIndex: Integer read FItemIndex write FItemIndex default -1; property Items: TStrings read FItems write SetItems; property LargeGlyph; property LargeImageIndex; property ShowCheck: Boolean read FShowCheck write FShowCheck default False; property ShowNumbers: Boolean read FShowNumbers write FShowNumbers default True; end; TdxBarContainerItem = class(TCustomdxBarContainerItem) protected procedure AddListedItemLinks(AItemLinks: TdxBarItemLinks; AIndex: Integer; FirstCall: Boolean; CallingItemLink: TdxBarItemLink); override; procedure DeleteListedItemLinks(AItemLinks: TdxBarItemLinks; AIndex: Integer); override; function InternalActuallyVisible: Boolean; override; function InternalCanMergeWith(AItem: TdxBarItem): Boolean; override; function IsItemsExist: Boolean; virtual; public constructor Create(AOwner: TComponent); override; published property ItemLinks; end; TdxBarExtraPaneListItem = class(TdxBarListItem) protected procedure AddListedItemLinks(AItemLinks: TdxBarItemLinks; AIndex: Integer; FirstCall: Boolean; CallingItemLink: TdxBarItemLink); override; function GetDisplayHint(const AText: string): string; override; function GetDisplayText(const AText: string): string; override; function InternalActuallyVisible: Boolean; override; end; {-------------------------------------- Item's controls --------------------------------------} TdxBarSavedFont = record LogFont: TLogFont; Saved: Boolean; end; TdxBarItemControlDrawParams = class private FViewSize: TdxBarItemControlViewSize; FBarItemControl: TdxBarItemControl; procedure SetViewSize(Value: TdxBarItemControlViewSize); public Canvas: TcxCanvas; Caption: string; Description: string; ShortCut: string; PaintType: TdxBarPaintType; ViewStructure: TdxBarItemControlViewStructure; Enabled: Boolean; CanSelect: Boolean; DrawSelected: Boolean; DroppedDown: Boolean; IsDropDown: Boolean; HotPartIndex: Integer; IsCustomizing: Boolean; IsPressed: Boolean; SelectedByKey: Boolean; DefaultButtonSize: TSize; constructor Create(ABarItemControl: TdxBarItemControl); property BarItemControl: TdxBarItemControl read FBarItemControl; property ViewSize: TdxBarItemControlViewSize read FViewSize write SetViewSize; end; TdxBarItemControlDrawParamsClass = class of TdxBarItemControlDrawParams; TdxBarButtonLikeControlDrawParams = class(TdxBarItemControlDrawParams) public Downed: Boolean; DroppedDownFlat: Boolean; SplitDropDown: Boolean; DropDownEnabled: Boolean; IsTextSelected: Boolean; IsFlatText: Boolean; GrayScale: Boolean; IsLowered: Boolean; IsMenuItem: Boolean; ArrowWidth: Integer; ButtonGroup: TdxBarButtonGroupRealPosition; end; TdxBarApplicationMenuButtonControlDrawParams = class(TdxBarButtonLikeControlDrawParams) public ContentWidth: Integer; end; TdxBarEditLikeControlDrawParams = class(TdxBarItemControlDrawParams) private function GetBarEditControl: TdxBarEditControl; public Focused: Boolean; IsTransparent: Boolean; property BarEditControl: TdxBarEditControl read GetBarEditControl; end; TdxBarStaticLikeControlDrawParams = class(TdxBarItemControlDrawParams) private function GetBarStaticControl: TdxBarCustomStaticControl; public Alignment: TAlignment; AllowCenter: Boolean; BorderWidth: Integer; BorderStyle: TdxBarStaticBorderStyle; property BarStaticControl: TdxBarCustomStaticControl read GetBarStaticControl; end; TdxBarSeparatorControlDrawParams = class(TdxBarStaticLikeControlDrawParams) public IsTop: Boolean; end; TdxBarColorComboControlDrawParams = class(TdxBarEditLikeControlDrawParams) public IsShowCustomColorButton: Boolean; end; TdxBarSpinEditDrawParams = class(TdxBarEditLikeControlDrawParams) public ArrowSize: TSize; ActiveButtonIndex: Integer; end; TdxBarProgressControlDrawParams = class(TdxBarStaticLikeControlDrawParams) public Smooth: Boolean; Position: Integer; Min: Integer; Max: Integer; end; TdxBarInPlaceSubItemControlDrawParams = class(TdxBarButtonLikeControlDrawParams) public IsExpanded: Boolean; end; TdxBarItemControlViewInfo = class(TcxInterfacedPersistent, IdxBarItemControlViewInfo) private FAllowedViewLevels: TdxBarItemViewLevels; FBounds: TRect; FColumnRowCount: Integer; FImageBounds: TRect; FMinPossibleViewLevel: TdxBarItemRealViewLevel; FRealPositionInButtonGroup: TdxBarButtonGroupRealPosition; FRow: Integer; FViewLevel: TdxBarItemViewLevel; FViewLevelForButtonGroup: TdxBarItemRealViewLevel; FViewLevelInfos: array [TdxBarItemRealViewLevel] of TdxBarItemViewLevelInfo; // IdxBarItemControlViewInfo function GetAlign: TdxBarItemAlign; function GetAllowedViewLevels: TdxBarItemViewLevels; function GetBounds: TRect; function GetColumnRowCount: Integer; function GetPosition: TdxBarItemPosition; function GetPositionInButtonGroup: TdxBarButtonGroupPosition; function GetRealPositionInButtonGroup: TdxBarButtonGroupRealPosition; function GetRow: Integer; function GetViewLevel: TdxBarItemViewLevel; function GetViewLevelForButtonGroup: TdxBarItemRealViewLevel; function GetWidth(AViewLevel: TdxBarItemRealViewLevel): Integer; function HasSeparator: Boolean; procedure SetBounds(const Value: TRect); procedure SetColumnRowCount(Value: Integer); procedure SetRealPositionInButtonGroup(Value: TdxBarButtonGroupRealPosition); procedure SetRow(Value: Integer); procedure SetViewLevel(Value: TdxBarItemViewLevel); protected FControl: TdxBarItemControl; public constructor Create(AControl: TdxBarItemControl); reintroduce; virtual; destructor Destroy; override; procedure ResetCachedValues; property Bounds: TRect read GetBounds; property Control: TdxBarItemControl read FControl; property ImageBounds: TRect read FImageBounds write FImageBounds; property MinPossibleViewLevel: TdxBarItemRealViewLevel read FMinPossibleViewLevel; property RealPositionInButtonGroup: TdxBarButtonGroupRealPosition read FRealPositionInButtonGroup; property ViewLevel: TdxBarItemViewLevel read GetViewLevel; end; TdxBarItemControlViewInfoClass = class of TdxBarItemControlViewInfo; TdxCashedImageOptions = class private FCashed: Boolean; FGlyph: TcxBitmap; FCashedDrawMode: TcxImageDrawMode; FCashedImages: TCustomImageList; FCashedGlyph: TBitmap; public constructor Create; destructor Destroy; override; procedure Cash(const ARect: TRect; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; ADrawMode: TcxImageDrawMode; ATransparentColor: TColor; ASmoothImage, AUseLeftBottomPixelAsTransparent: Boolean); function IsCashed(ADrawMode: TcxImageDrawMode; AGlyph: TBitmap; AImages: TCustomImageList): Boolean; property Cashed: Boolean read FCashed write FCashed; property Glyph: TcxBitmap read FGlyph; end; TdxBarItemControl = class(TObject, {$IFNDEF DELPHI6} IUnknown, {$ENDIF} IdxFadingObject, IdxBarHintKeeper ) private FBkBrush: HBRUSH; FBreakingRow: Boolean; FCashedImageOptions: TdxCashedImageOptions; FChangeRecentGroup: Boolean; FIAccessibilityHelper: IdxBarAccessibilityHelper; FIsActive: Boolean; FItemLink: TdxBarItemLink; FLastInRow: Boolean; FNonRecent: Boolean; FParent: TCustomdxBarControl; FPressed: Boolean; FSelectedByMouse: Boolean; FTextSize: Integer; procedure DoCalculateParts; function FindPartAtPos(APoint: TPoint): Integer; function GetAlign: TdxBarItemAlign; function GetBarManager: TdxBarManager; function GetBkBrush: HBRUSH; function GetCanvas: TcxCanvas; function GetFlat: Boolean; function GetIAccessibilityHelper: IdxBarAccessibilityHelper; function GetIsSelected: Boolean; function GetItem: TdxBarItem; function GetItemBounds: TRect; function GetPainterClass: TdxBarPainterClass; function GetRealHeight: Integer; function GetRealWidth: Integer; function GetShowDescription: Boolean; function GetSubMenuParent: TdxBarSubMenuControl; function GetUnclickAfterDoing: Boolean; function InternalGetPossibleViewLevels: TdxBarItemViewLevels; procedure SetPressed(Value: Boolean); protected FDrawParams: TdxBarItemControlDrawParams; FHotPartIndex: Integer; FParts: array of TRect; FViewInfo: TdxBarItemControlViewInfo; // IUnknown function _AddRef: Integer; stdcall; function _Release: Integer; stdcall; function QueryInterface(const IID: TGUID; out Obj): HResult; virtual; stdcall; // IdxFadingObject function CanFade: Boolean; procedure DrawBitmap(ABitmap: TBitmap); procedure GetFadingParams(out AFadeOutImage, AFadeInImage: TBitmap; var AFadeInStageCount, AFadeInStageInterval, AFadeOutStageCount, AFadeOutStageInterval: Integer); function GetFader: TdxFader; virtual; // IdxBarHintKeeper function DoHint(var ANeedDeactivate: Boolean; out AHintText: string; out AShortCut: string): Boolean; virtual; function CreateHintViewInfo(const AHintText, AShortCut: string): TdxBarCustomHintViewInfo; virtual; function GetEnabled: Boolean; virtual; function GetHintPosition(const ACursorPos: TPoint; AHeight: Integer): TPoint; virtual; // Change Group procedure BeginGroupChanged; virtual; procedure CaptionChanged; virtual; procedure EnabledChanged; virtual; procedure GlyphChanged; virtual; procedure HotGlyphChanged; virtual; procedure LargeGlyphChanged; virtual; procedure PartsChanged; virtual; procedure PaintStyleChanged; virtual; procedure ParentVisibleChange(AIsShowing: Boolean); virtual; procedure PressedChanged; virtual; procedure RealVisibleChanging(AVisible: Boolean); virtual; procedure VisibleChanged; virtual; procedure WidthChanged; virtual; procedure ResetCachedValues(AFull: Boolean); procedure BeforeDestroyParentHandle; virtual; function CanBePartOfButtonGroup: Boolean; virtual; function CanClicked: Boolean; virtual; function CanCustomize: Boolean; virtual; function CanDeselect(ABarManager: TdxBarManager): Boolean; virtual; function CanHide: Boolean; virtual; function CanMouseSelect: Boolean; virtual; function CanSelect: Boolean; virtual; function CanShowShortCut: Boolean; function CanVisuallyPressed: Boolean; procedure CheckHotTrack(APoint: TPoint); virtual; procedure Click(AByMouse: Boolean; AKey: Char = #0); virtual; procedure ControlActivate(Immediately: Boolean); virtual; procedure ControlInactivate(Immediately: Boolean); virtual; procedure ControlClick(AByMouse: Boolean; AKey: Char = #0); virtual; procedure ControlUnclick(ByMouse: Boolean); virtual; procedure ControlGetFocus(AIsSelected: Boolean; var AProcessed: Boolean); virtual; procedure DblClick; dynamic; function DrawSelected: Boolean; virtual; function GetSelectableObject: TPersistent; function WantsDblClick: Boolean; dynamic; // User Events Group procedure KeyDown(var Key: Word; Shift: TShiftState); dynamic; procedure KeyUp(var Key: Word; Shift: TShiftState); dynamic; procedure KeyPress(var Key: Char); dynamic; procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); dynamic; procedure MouseEnter(Shift: TShiftState; X, Y: Integer); dynamic; procedure MouseLeave; dynamic; procedure MouseMove(Shift: TShiftState; X, Y: Integer); dynamic; procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); dynamic; function WantsKey(Key: Word): Boolean; virtual; function GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; virtual; function GetPossibleViewLevels: TdxBarItemViewLevels; virtual; function GetViewLevels: TdxBarItemViewLevels; function GetViewStructure: TdxBarItemControlViewStructure; virtual; function GetDefaultViewStructure: TdxBarItemControlViewStructure; virtual; function GetViewSize: TdxBarItemControlViewSize; function GetDefaultViewSize: TdxBarItemControlViewSize; virtual; function GetPaintType: TdxBarPaintType; virtual; function GetPartCount: Integer; virtual; function GetViewInfoClass: TdxBarItemControlViewInfoClass; virtual; function GrayScale: Boolean; virtual; function HasIcon(AViewSize: TdxBarItemControlViewSize; AViewStructure: TdxBarItemControlViewStructure): Boolean; function IconAssigned(AViewSize: TdxBarItemControlViewSize): Boolean; procedure FrameAndFillRect(DC: HDC; var R: TRect; Enabled, Selected, Pressed: Boolean); procedure GetArrowParams(out ABrush: HBRUSH; out AArrowColor: COLORREF); virtual; function GetCaption: string; virtual; function GetControl: TControl; virtual; function GetDrawParamsClass: TdxBarItemControlDrawParamsClass; virtual; function GetGlyph: TBitmap; virtual; function GetImageEnabled(APaintType: TdxBarPaintType): Boolean; virtual; function GetImageIndex: Integer; virtual; function GetImageList(AViewSize: TdxBarItemControlViewSize; AInToolbar: Boolean): TCustomImageList; virtual; function GetImages: TCustomImageList; virtual; function GetHint: string; virtual; function GetHotImages: TCustomImageList; virtual; function GetLargeGlyph: TBitmap; virtual; function GetLargeImageIndex: Integer; virtual; function GetLargeImages: TCustomImageList; virtual; function GetMenuItemSize: TdxBarMenuItemSize; virtual; function GetPainter: TdxBarPainter; virtual; function GetShortCut: TShortCut; virtual; function GetTextAreaOffset: Integer; virtual; // Draw Group procedure CalcDrawParams(AFull: Boolean = True); virtual; procedure CalcParts; virtual; procedure CalcDrawingConsts; virtual; procedure DoCalcDrawingConsts; virtual; procedure DoPaint(ARect: TRect; PaintType: TdxBarPaintType); virtual; procedure Paint(ARect: TRect; PaintType: TdxBarPaintType); virtual; procedure PrepareCanvasFont(ABaseFont: HFONT; AStyle: TcxStyle; out ASavedFont: TdxBarSavedFont); virtual; procedure RestoreCanvasFont(const ASavedFont: TdxBarSavedFont); virtual; function GetOwnedBarControl: TCustomdxBarControl; virtual; function GetCaptionWidth: Integer; virtual; function GetCurrentImage(AViewSize: TdxBarItemControlViewSize; ASelected: Boolean; out ACurrentGlyph: TBitmap; out ACurrentImages: TCustomImageList; out ACurrentImageIndex: Integer): Boolean; virtual; function GetGlyphSize(AViewSize: TdxBarItemControlViewSize; ASelected: Boolean = False): TSize; virtual; function GetIndents(ADrawAreaType: TdxBarItemControlPart): TRect; virtual; function GetRotationDependentHeight(ASourceSize: TSize): Integer; function GetRotationDependentWidth(ASourceSize: TSize): Integer; function GetTextExtent(const AText: string): TSize; function GetTextHeight: Integer; function GetTextSize: Integer; // TODO property function GetTextWidth(const AText: string): Integer; function GetCaptionAreaWidth: Integer; virtual; function GetControlAreaWidth: Integer; virtual; function GetGlyphAreaWidth: Integer; virtual; function GetControlCaptionOffset: Integer; virtual; function GetDefaultHeight: Integer; virtual; function GetDefaultWidth: Integer; virtual; function GetDefaultWidthHorzLayout: Integer; virtual; function GetDefaultWidthVertLayout: Integer; virtual; function GetDefaultHeightInSubMenu: Integer; virtual; function GetDefaultWidthInSubMenu: Integer; virtual; function GetMinHeight: Integer; virtual; function GetMinWidth: Integer; virtual; function GetHeight: Integer; function GetWidth: Integer; function GetWidthByViewLevel(AViewLevel: TdxBarItemRealViewLevel): Integer; function GetLargeHeight: Integer; virtual; function GetSmallHeight: Integer; virtual; function InternalGetDefaultHeight: Integer; virtual; function InternalGetDefaultWidth: Integer; virtual; // Ask Group function HasHint: Boolean; virtual; function HasShadow: Boolean; virtual; function HotPartWantMouse: Boolean; virtual; function IsBkColorAssigned: Boolean; function IsChildWindow(AWnd: HWND): Boolean; virtual; function IsDestroyOnClick: Boolean; virtual; function IsDropDown: Boolean; virtual; function IsExpandable: Boolean; virtual; function IsInvertTextColor: Boolean; virtual; function IsMenuItem: Boolean; virtual; function IsRotated: Boolean; virtual; function IsSelectionForbidden: Boolean; function MousePressed: Boolean; function NeedCaptureMouse: Boolean; virtual; function WantMouse: Boolean; procedure CheckNonRecent; procedure UncheckNonRecent; // Resize Group procedure BeginResize(APoint: TPoint); virtual; function CanResize(APoint: TPoint): Boolean; virtual; procedure EndResize(AAllowResize: Boolean); virtual; procedure Resizing(APoint: TPoint); virtual; property Align: TdxBarItemAlign read GetAlign; property BkBrush: HBRUSH read GetBkBrush; property Canvas: TcxCanvas read GetCanvas; property Caption: string read GetCaption; property Control: TControl read GetControl; property DrawParams: TdxBarItemControlDrawParams read FDrawParams; property Flat: Boolean read GetFlat; property Glyph: TBitmap read GetGlyph; property Height: Integer read GetRealHeight; property Hint: string read GetHint; property HotImages: TCustomImageList read GetHotImages; property ImageIndex: Integer read GetImageIndex; property Images: TCustomImageList read GetImages; property LargeGlyph: TBitmap read GetLargeGlyph; property LargeImageIndex: Integer read GetLargeImageIndex; property LargeImages: TCustomImageList read GetLargeImages; property LastInRow: Boolean read FLastInRow write FLastInRow; property MenuItemSize: TdxBarMenuItemSize read GetMenuItemSize; property MinHeight: Integer read GetMinHeight; property MinWidth: Integer read GetMinWidth; property NonRecent: Boolean read FNonRecent; property OwnedBarControl: TCustomdxBarControl read GetOwnedBarControl; property PossibleViewLevels: TdxBarItemViewLevels read InternalGetPossibleViewLevels; property Pressed: Boolean read FPressed write SetPressed; property SubMenuParent: TdxBarSubMenuControl read GetSubMenuParent; property ShortCut: TShortCut read GetShortCut; property ShowDescription: Boolean read GetShowDescription; property TextAreaOffset: Integer read GetTextAreaOffset; property UnclickAfterDoing: Boolean read GetUnclickAfterDoing; property ViewLevels: TdxBarItemViewLevels read GetViewLevels; property Width: Integer read GetRealWidth; public constructor Create(AItemLink: TdxBarItemLink); virtual; destructor Destroy; override; class function HasWindow: Boolean; virtual; function IsDroppedDown: Boolean; virtual; procedure Repaint; virtual; property BarManager: TdxBarManager read GetBarManager; property Enabled: Boolean read GetEnabled; property IAccessibilityHelper: IdxBarAccessibilityHelper read GetIAccessibilityHelper; property IsActive: Boolean read FIsActive; property IsSelected: Boolean read GetIsSelected; property Item: TdxBarItem read GetItem; property ItemBounds: TRect read GetItemBounds; property ItemLink: TdxBarItemLink read FItemLink; property Painter: TdxBarPainter read GetPainter; property PainterClass: TdxBarPainterClass read GetPainterClass; property Parent: TCustomdxBarControl read FParent; property ViewInfo: TdxBarItemControlViewInfo read FViewInfo; end; TdxBarCustomStaticControl = class(TdxBarItemControl) private function GetDrawParams: TdxBarStaticLikeControlDrawParams; protected function CanClicked: Boolean; override; function CanSelect: Boolean; override; procedure DrawInterior(ARect: TRect); virtual; abstract; function GetDefaultViewStructure: TdxBarItemControlViewStructure; override; function GetDrawParamsClass: TdxBarItemControlDrawParamsClass; override; procedure Paint(ARect: TRect; PaintType: TdxBarPaintType); override; property DrawParams: TdxBarStaticLikeControlDrawParams read GetDrawParams; end; TdxBarSeparatorControl = class(TdxBarCustomStaticControl) private function GetDrawParams: TdxBarSeparatorControlDrawParams; protected procedure CalcDrawParams(AFull: Boolean = True); override; function GetIndents(ADrawAreaType: TdxBarItemControlPart): TRect; override; function GetMenuItemSize: TdxBarMenuItemSize; override; function GetGlyphAreaWidth: Integer; override; function GetDefaultHeightInSubMenu: Integer; override; function GetDefaultWidthInSubMenu: Integer; override; function GetMinWidth: Integer; override; function InternalGetDefaultHeight: Integer; override; function InternalGetDefaultWidth: Integer; override; procedure PrepareCanvasFont(ABaseFont: HFONT; AStyle: TcxStyle; out ASavedFont: TdxBarSavedFont); override; procedure RestoreCanvasFont(const ASavedFont: TdxBarSavedFont); override; function GetDefaultViewStructure: TdxBarItemControlViewStructure; override; function GetDrawParamsClass: TdxBarItemControlDrawParamsClass; override; procedure Paint(ARect: TRect; PaintType: TdxBarPaintType); override; property DrawParams: TdxBarSeparatorControlDrawParams read GetDrawParams; end; TdxBarWinControl = class(TdxBarItemControl) private FDefWndProc: {$IFDEF CLR}TFNWndProc{$ELSE}Pointer{$ENDIF}; FFocused: Boolean; FFocusing: Boolean; FKeyPressedInside: Integer; FPrevDefWndProc: {$IFDEF CLR}TFNWndProc{$ELSE}Pointer{$ENDIF}; FPrevFocusedControl: HWND; FWindowRect: TRect; function DoCallKeyboardHook(wParam: WParam; lParam: LParam): Boolean; function GetItem: TdxBarWindowItem; function GetWindowRect: TRect; procedure SetWindowRect(const Value: TRect); protected function CanClicked: Boolean; override; function CanDeselect(ABarManager: TdxBarManager): Boolean; override; function CanSelect: Boolean; override; procedure ControlInactivate(Immediately: Boolean); override; procedure ControlClick(AByMouse: Boolean; AKey: Char = #0); override; procedure ControlGetFocus(AIsSelected: Boolean; var AProcessed: Boolean); override; procedure EnabledChanged; override; function GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; override; function IsChildWindow(AWnd: HWND): Boolean; override; function IsDestroyOnClick: Boolean; override; function IsWindowEnabled: Boolean; procedure KeyDown(var Key: Word; Shift: TShiftState); override; procedure KeyPress(var Key: Char); override; procedure KeyUp(var Key: Word; Shift: TShiftState); override; function ClientToParent(const APoint: TPoint): TPoint; function ParentToClient(const APoint: TPoint): TPoint; procedure CreateInnerEdit; virtual; procedure DestroyInnerEdit(AFullDestroy: Boolean = True); virtual; procedure DoEnter; procedure DoEscape; procedure DoNavigation; function DoKeyDown(var Message: TWMKey): Boolean; function DoKeyPress(var Message: TWMKey): Boolean; function DoKeyUp(var Message: TWMKey): Boolean; procedure DoKillFocus(var Message: TMessage); procedure DoMouseDown(var Message: TWMMouse; AButton: TMouseButton; AShift: TShiftState); procedure DoMouseMove(var Message: TWMMouse); procedure ActivateEdit(AByMouse: Boolean; AKey: Char = #0); virtual; function GetHandle: HWND; virtual; abstract; function GetText: string; virtual; procedure Hide(AStoreDisplayValue: Boolean); virtual; abstract; procedure KillFocus(AHandle: THandle); dynamic; procedure RestoreDisplayValue; virtual; procedure SetFocused(Value: Boolean); virtual; procedure SetText(Value: string); virtual; procedure Show; virtual; abstract; procedure StoreDisplayValue; virtual; procedure SysKeyDown(var Key: Word; Shift: TShiftState); virtual; procedure SysKeyUp(var Key: Word; Shift: TShiftState); virtual; procedure TransferMessage(AFromWindow: HWND; const Message: TMessage); procedure WndProc(var Message: TMessage); virtual; public procedure DefaultHandler(var Message); override; class function HasWindow: Boolean; override; function HandleAllocated: Boolean; property Focused: Boolean read FFocused write SetFocused; property Handle: HWND read GetHandle; property Item: TdxBarWindowItem read GetItem; property Text: string read GetText write SetText; property WindowRect: TRect read GetWindowRect write SetWindowRect; end; TdxBarButtonLikeControl = class(TdxBarItemControl) private FShowAnimation: Boolean; function GetDrawParams: TdxBarButtonLikeControlDrawParams; protected function ArrowWidth: Integer; virtual; procedure CalcDrawParams(AFull: Boolean = True); override; function CanBePartOfButtonGroup: Boolean; override; function CanActivate: Boolean; virtual; procedure ControlActivate(Immediately: Boolean); override; procedure ControlInactivate(Immediately: Boolean); override; procedure ControlGetFocus(AIsSelected: Boolean; var AProcessed: Boolean); override; procedure DropDown(AByMouse: Boolean); virtual; function GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; override; function GetDrawParamsClass: TdxBarItemControlDrawParamsClass; override; function GetSubMenuControl: TdxBarSubMenuControl; virtual; procedure KeyDown(var Key: Word; Shift: TShiftState); override; function WantsKey(Key: Word): Boolean; override; procedure FinishSubMenuTracking(ANewSelectedControl: TdxBarItemControl = nil); procedure StartSubMenuTracking(AActivation: Boolean); procedure DoCloseUp(AHadSubMenuControl: Boolean); dynamic; procedure DoDropDown(AByMouse: Boolean); dynamic; abstract; procedure Paint(ARect: TRect; PaintType: TdxBarPaintType); override; property DrawParams: TdxBarButtonLikeControlDrawParams read GetDrawParams; public destructor Destroy; override; property SubMenuControl: TdxBarSubMenuControl read GetSubMenuControl; end; TdxBarButtonControl = class(TdxBarButtonLikeControl) private FDroppedDown: Boolean; function GetButtonItem: TdxBarButton; function GetDown: Boolean; function GetDropDownEnabled: Boolean; function GetDroppedDownFlat: Boolean; function GetGroupIndex: Integer; function GetInternalStates: TdxBarButtonStates; function GetLowered: Boolean; function IsFlatTextSelected(APressed: Boolean): Boolean; function MouseOverArrow: Boolean; protected function ArrowPressed: Boolean; procedure CalcDrawParams(AFull: Boolean = True); override; procedure CalcParts; override; procedure ControlClick(AByMouse: Boolean; AKey: Char = #0); override; procedure ControlUnclick(ByMouse: Boolean); override; procedure ControlGetFocus(AIsSelected: Boolean; var AProcessed: Boolean); override; procedure DoCloseUp(AHadSubMenuControl: Boolean); override; procedure DoDropDown(AByMouse: Boolean); override; function DrawSelected: Boolean; override; procedure DropDown(AByMouse: Boolean); override; function GetSubMenuControl: TdxBarSubMenuControl; override; function GetDefaultHeight: Integer; override; function GetDefaultWidth: Integer; override; function GetSmallHeight: Integer; override; function GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; override; function GetDefaultViewStructure: TdxBarItemControlViewStructure; override; function GetOwnedBarControl: TCustomdxBarControl; override; function GetPaintStyle: TdxBarPaintStyle; virtual; function GetPartCount: Integer; override; function GetViewStructure: TdxBarItemControlViewStructure; override; function IsDestroyOnClick: Boolean; override; function IsDropDown: Boolean; override; function IsPressed: Boolean; function NeedCaptureMouse: Boolean; override; procedure PaintStyleChanged; override; procedure PreparePaintStyleOnBar(var APaintStyle: TdxBarPaintStyle); virtual; property Down: Boolean read GetDown; property DropDownEnabled: Boolean read GetDropDownEnabled; property DroppedDown: Boolean read FDroppedDown; property DroppedDownFlat: Boolean read GetDroppedDownFlat; // TODO: obsolete property GroupIndex: Integer read GetGroupIndex; property InternalStates: TdxBarButtonStates read GetInternalStates; property Lowered: Boolean read GetLowered; property PaintStyle: TdxBarPaintStyle read GetPaintStyle; public function IsDroppedDown: Boolean; override; property ButtonItem: TdxBarButton read GetButtonItem; end; TdxBarApplicationMenuButtonControl = class(TdxBarButtonLikeControl) private function GetDrawParams: TdxBarApplicationMenuButtonControlDrawParams; protected procedure CalcDrawParams(AFull: Boolean = False); override; function GetDefaultViewStructure: TdxBarItemControlViewStructure; override; function GetDrawParamsClass: TdxBarItemControlDrawParamsClass; override; function GetPaintType: TdxBarPaintType; override; function InternalGetDefaultWidth: Integer; override; procedure CaptionChanged; override; procedure GlyphChanged; override; procedure VisibleChanged; override; procedure WidthChanged; override; procedure Paint(ARect: TRect; PaintType: TdxBarPaintType); override; property DrawParams: TdxBarApplicationMenuButtonControlDrawParams read GetDrawParams; end; TdxBarCustomEditControl = class(TdxBarWinControl) private FBkBrush: TBrush; FEditTextSize: Integer; FSizingEditWidth: Integer; FRightBorderSizing: Boolean; function GetCaptionBkBrush: HBRUSH; function GetDrawParams: TdxBarEditLikeControlDrawParams; function GetEditBkBrush: HBRUSH; function GetEditFont: TFont; function GetItem: TdxCustomBarEdit; function LeftSizingRect: TRect; function RightSizingRect: TRect; protected procedure CalcParts; override; procedure CalcDrawParams(AFull: Boolean = True); override; procedure CorrectFrameRect(var ARect: TRect); virtual; procedure DoCalcDrawingConsts; override; procedure DrawFrame; virtual; procedure DrawTextField; virtual; abstract; procedure DrawEditSizingFrame(AWidth: Integer); function DrawSelected: Boolean; override; function GetDefaultViewStructure: TdxBarItemControlViewStructure; override; function GetDrawParamsClass: TdxBarItemControlDrawParamsClass; override; function GetPartCount: Integer; override; function GetPossibleViewLevels: TdxBarItemViewLevels; override; function GetCaptionAreaWidth: Integer; override; function GetControlAreaWidth: Integer; override; function GetGlyphAreaWidth: Integer; override; function GetDefaultHeight: Integer; override; function GetDefaultWidth: Integer; override; function GetEditOffset: Integer; function GetEditRect: TRect; virtual; function GetEditTextSize: Integer; // TODO property function GetIndents(ADrawAreaType: TdxBarItemControlPart): TRect; override; function GetMinEditorWidth: Integer; virtual; abstract; function GetMinWidth: Integer; override; function GetShowCaption: Boolean; virtual; procedure InitEdit; virtual; abstract; function IsEditTransparent: Boolean; virtual; procedure Paint(ARect: TRect; PaintType: TdxBarPaintType); override; procedure Show; override; procedure BeginResize(APoint: TPoint); override; function CanResize(APoint: TPoint): Boolean; override; procedure EndResize(AAllowResize: Boolean); override; procedure Resizing(APoint: TPoint); override; function HotPartWantMouse: Boolean; override; procedure RefreshBkBrush(var AHandle: HBRUSH); virtual; property CaptionBkBrush: HBRUSH read GetCaptionBkBrush; property DrawParams: TdxBarEditLikeControlDrawParams read GetDrawParams; property EditBkBrush: HBRUSH read GetEditBkBrush; property EditFont: TFont read GetEditFont; property ShowCaption: Boolean read GetShowCaption; public destructor Destroy; override; property Item: TdxCustomBarEdit read GetItem; end; TdxBarEditControl = class(TdxBarCustomEditControl) private FHandle: HWND; procedure CreateWindowHandle; procedure DestroyWindowHandle(ADestroyWindow: Boolean = True); function GetItem: TdxBarEdit; function GetMaxLength: Integer; function GetReadOnly: Boolean; protected function CanDrawEditor: Boolean; virtual; procedure ControlClick(AByMouse: Boolean; AKey: Char = #0); override; procedure CreateInnerEdit; override; procedure DestroyInnerEdit(AFullDestroy: Boolean = True); override; procedure DrawTextField; override; function GetHandle: HWND; override; function GetMinEditorWidth: Integer; override; procedure Hide(AStoreDisplayValue: Boolean); override; procedure InitEdit; override; procedure SetFocused(Value: Boolean); override; procedure SetText(Value: string); override; procedure Show; override; procedure WndProc(var Message: TMessage); override; property MaxLength: Integer read GetMaxLength; property ReadOnly: Boolean read GetReadOnly; public constructor Create(AItemLink: TdxBarItemLink); override; destructor Destroy; override; property Item: TdxBarEdit read GetItem; end; TCustomdxBarComboControl = class(TdxBarEditControl) private FOnPressDroppedDown: Boolean; FDroppedDown: Boolean; function GetDropDownWindow: HWND; function GetItem: TCustomdxBarCombo; protected procedure CalcDrawParams(AFull: Boolean = True); override; procedure CalcParts; override; function CanDrawEditor: Boolean; override; procedure ControlInactivate(Immediately: Boolean); override; procedure CorrectFrameRect(var ARect: TRect); override; procedure DrawTextField; override; procedure EnabledChanged; override; procedure GetArrowParams(out ABrush: HBRUSH; out AArrowColor: COLORREF); override; // obsolete function GetPartCount: Integer; override; function IsChildWindow(AWnd: HWND): Boolean; override; procedure SetDroppedDown(Value: Boolean); virtual; procedure SysKeyDown(var Key: Word; Shift: TShiftState); override; procedure SysKeyUp(var Key: Word; Shift: TShiftState); override; procedure WndProc(var Message: TMessage); override; property DropDownWindow: HWND read GetDropDownWindow; public destructor Destroy; override; function IsDroppedDown: Boolean; override; property DroppedDown: Boolean read FDroppedDown write SetDroppedDown; property Item: TCustomdxBarCombo read GetItem; end; TdxBarComboControl = class(TCustomdxBarComboControl) private FLocalItemIndex: Integer; function GetItem: TdxBarCustomCombo; function GetItemIndex: Integer; function GetItems: TStrings; function GetSorted: Boolean; procedure SetLocalItemIndex(Value: Integer); protected procedure RestoreDisplayValue; override; procedure SetFocused(Value: Boolean); override; procedure WndProc(var Message: TMessage); override; property ItemIndex: Integer read GetItemIndex; property Items: TStrings read GetItems; property Sorted: Boolean read GetSorted; public property Item: TdxBarCustomCombo read GetItem; property LocalItemIndex: Integer read FLocalItemIndex write SetLocalItemIndex; end; TdxBarSubItemControl = class(TdxBarButtonLikeControl) private function GetCaptionOffset: Integer; function GetItem: TCustomdxBarSubItem; function IsFlatText: Boolean; function IsTextSelected(ASelected, ADown: Boolean): Boolean; protected function GetSubMenuControl: TdxBarSubMenuControl; override; procedure CalcDrawParams(AFull: Boolean = True); override; function CanActivate: Boolean; override; function CanClicked: Boolean; override; procedure ControlActivate(Immediately: Boolean); override; procedure ControlInactivate(Immediately: Boolean); override; procedure ControlClick(AByMouse: Boolean; AKey: Char = #0); override; procedure CreateSubMenuControl; virtual; procedure DoCreateSubMenuControl; procedure DoCloseUp(AHadSubMenuControl: Boolean); override; procedure DoDropDown(AByMouse: Boolean); override; procedure DropDown(AByMouse: Boolean); override; procedure ShowSubmenuControl; function GetCaptionAreaWidth: Integer; override; function GetControlCaptionOffset: Integer; override; function GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; override; function GetOwnedBarControl: TCustomdxBarControl; override; function HasSubMenu: Boolean; virtual; function IsDestroyOnClick: Boolean; override; function IsDropDown: Boolean; override; function IsExpandable: Boolean; override; function IsMenuItem: Boolean; override; function IsPressed: Boolean; function WantsDblClick: Boolean; override; function WantsKey(Key: Word): Boolean; override; function GetPossibleViewLevels: TdxBarItemViewLevels; override; function GetDefaultViewStructure: TdxBarItemControlViewStructure; override; property CaptionOffset: Integer read GetCaptionOffset; public destructor Destroy; override; function IsDroppedDown: Boolean; override; property Item: TCustomdxBarSubItem read GetItem; end; TdxBarContainerItemControl = class(TdxBarSubItemControl) private function GetItem: TCustomdxBarContainerItem; protected procedure CreateSubMenuControl; override; function DrawSelected: Boolean; override; function GetCaption: string; override; function IsExpandable: Boolean; override; procedure Paint(ARect: TRect; PaintType: TdxBarPaintType); override; function ShowRealCaption: Boolean; public property Item: TCustomdxBarContainerItem read GetItem; end; {-------------------------------------- Item's painters --------------------------------------} TdxBarPainter = class private procedure InternalCalculateComboParts(const ADrawParams: TdxBarEditLikeControlDrawParams; var AParts: array of TRect); protected // New procedure DrawToolbarContentPart(ABarControl: TdxBarControl; ACanvas: TcxCanvas); virtual; procedure DrawToolbarNonContentPart(ABarControl: TdxBarControl; DC: HDC); virtual; function GetToolbarCaptionRect(const ARect: TRect): TRect; virtual; class function IsCompoundPainting: Boolean; virtual; // Common procedure CorrectCaptionParams(const ADrawParams: TdxBarButtonLikeControlDrawParams; var ATextBounds: TRect; const AImageBounds: TRect; out ATextAlignment: DWORD); virtual; class procedure DrawGlyphBorder(ABarItemControl: TdxBarItemControl; DC: HDC; ABrush: HBRUSH; NeedBorder: Boolean; R: TRect; PaintType: TdxBarPaintType; IsGlyphEmpty, Selected, Down, DrawDowned, ADroppedDown, IsSplit: Boolean); virtual; class procedure DrawGlyphCheckMark(ABarItemControl: TdxBarItemControl; DC: HDC; X, Y, DoubleSize: Integer); virtual; class procedure DrawGlyphEmptyImage(ABarItemControl: TdxBarItemControl; DC: HDC; R: TRect; ABrush: HBRUSH; NeedBorder: Boolean; PaintType: TdxBarPaintType; Selected, Down, DrawDowned: Boolean); virtual; class procedure DrawGlyphImage(ABarItemControl: TdxBarItemControl; DC: HDC; ABrush: HBRUSH; NeedBorder: Boolean; R: TRect; const GlyphRect: TRect; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; Selected, Down, DrawDowned, ForceUseBkBrush, GrayScale, BarControlOwner: Boolean; PaintType: TdxBarPaintType); virtual; class procedure DrawItemArrow(DC: HDC; R: TRect; ArrowType: TcxArrowDirection; Enabled, Selected, Flat: Boolean); virtual; procedure DrawLargeItemArrow(DC: HDC; R: TRect; ArrowType: TcxArrowDirection; Size: Integer; Selected, Enabled, Flat: Boolean); virtual; class procedure FrameFlatSelRect(DC: HDC; const R: TRect); virtual; function GetDefaultEnabledTextColor(ABarItemControl: TdxBarItemControl; ASelected, AFlat: Boolean): TColor; virtual; procedure GetDisabledTextColors(ABarItemControl: TdxBarItemControl; ASelected, AFlat: Boolean; var AColor1, AColor2: TColor); virtual; function GetEnabledTextColor(ABarItemControl: TdxBarItemControl; ASelected, AFlat: Boolean): TColor; virtual; procedure GetTextColors(ABarItemControl: TdxBarItemControl; AEnabled, ASelected, AFlat: Boolean; var AColor1, AColor2: TColor); virtual; class function GetFaded(ABarControl: TCustomdxBarControl): Boolean; virtual; class function IgnoreGlyphOpaque: Boolean; virtual; class function IgnoreNonRecentColor: Boolean; virtual; class function IsArrowButtonDowned(APaintStyle: TdxBarPaintType; AIsPressed: Boolean): Boolean; virtual; class function IsMenuItem(ABarItemControl: TdxBarItemControl): Boolean; virtual; // Hints class function GetBarItemContolHintPosition(ABarControl: TCustomdxBarControl; const AItemBounds: TRect; const ACursorPos: TPoint; AHeight: Integer): TPoint; virtual; function CreateHintViewInfo(ABarManager: TdxBarManager; AHintText: string; const AShortCut: string; AScreenTip: TdxBarScreenTip): TdxBarCustomHintViewInfo; virtual; // Bar class function BarIsBarSmall(ABarControl: TdxBarControl; const R: TRect): Boolean; virtual; class function BarCaptionBkColor(ABarControl: TdxBarControl; AMainFormActive: Boolean): COLORREF; virtual; class function BarCaptionColor(ABarControl: TdxBarControl): COLORREF; virtual; class function BarMarkArrowColor(ABarControl: TdxBarControl; AState: TdxBarMarkState): COLORREF; virtual; class procedure BarDrawGrip(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); virtual; // Mark procedure BarDrawMarkArrow(ABarControl: TdxBarControl; DC: HDC; MarkR: TRect); virtual; class procedure BarDrawMarkAtPos(ABarControl: TdxBarControl; DC: HDC; const ItemRect: TRect; Offset: Integer); virtual; procedure BarDrawMarkBackground(ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect; AToolbarBrush: HBRUSH); virtual; procedure BarDrawMarkElements(ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect); virtual; class procedure BarOffsetFloatingBarCaption(ABarControl: TdxBarControl; var X: Integer; var R: TRect); virtual; class function GetDrawMarkElementColor(ABarControl: TdxBarControl): Integer; virtual; // ButtonLikeControl procedure ButtonLikeControlDoDrawCaption(const ADrawParams: TdxBarButtonLikeControlDrawParams; const ATextBounds: TRect; ATextAlignment: DWORD); virtual; class function GetControlTextIndents: TRect; virtual; class function GetControlCaptionRect(const ADrawParams: TdxBarItemControlDrawParams): TRect; virtual; procedure InflateSizeForArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; var ASize: Integer); virtual; // ColorCombo procedure DrawDot(const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); virtual; procedure DrawDots(const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); virtual; function GetDotSpaceAfter(ADotWidth: Integer): Integer; virtual; function GetCustomColorButtonBounds(const ADrawParams: TdxBarColorComboControlDrawParams; ARect: TRect): TRect; virtual; // ComboControl class procedure ComboControlDrawArrow(ABarComboControl: TdxBarItemControl; DC: HDC; X, Y, Size: Integer; Color: COLORREF); virtual; class procedure ComboControlDrawOneArrow(ABarItemControl: TdxBarItemControl; DC: HDC; X, Y, Size: Integer; Color: COLORREF); virtual; // SubMenuControl procedure SubMenuControlFillScrollArrow(ACanvas: TcxCanvas; ARect: TRect; AColor: TColor); virtual; procedure SubMenuControlDrawScrollArrow(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; const AArrowRect: TRect; AColor: COLORREF; AArrowDirection: TcxArrowDirection); virtual; procedure SubMenuControlDrawScrollBand(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; AArrowDirection: TcxArrowDirection); virtual; procedure SubMenuControlDrawScrollBandBackground(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; AArrowDirection: TcxArrowDirection); virtual; procedure SubMenuControlDrawNonRecentGroupSeparator(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; AArrowDirection: TcxArrowDirection); virtual; function SubMenuControlGetScrollBandBounds(ABarSubMenuControl: TdxBarSubMenuControl; AArrowDirection: TcxArrowDirection): TRect; virtual; function SubMenuControlGetScrollBandSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; virtual; class function SubMenuControlGetScrollArrowSize(ATextSize: Integer): Integer; virtual; procedure SubMenuControlDrawMark(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect; ASelected: Boolean); virtual; procedure SubMenuControlDrawMarkBand(ABarSubMenuControl: TdxBarSubMenuControl; const AMarkRect: TRect; ASelected: Boolean); virtual; procedure SubMenuControlDrawMarkSelection(ABarSubMenuControl: TdxBarSubMenuControl; ADC: HDC; const AMarkRect: TRect); virtual; class function SubMenuControlUseScrollButtons: Boolean; virtual; // Edit class procedure EditOffsetInteriorRect(var R: TRect); virtual; // SpinEditControl procedure DrawSpinEditArrow(const ADrawParams: TdxBarSpinEditDrawParams; AArrowPos: TPoint; AButtonIndex: Integer); virtual; class procedure SpinEditControlDrawArrowByPoints(const ADrawParams: TdxBarSpinEditDrawParams; AStartPoint: TPoint; AColorIndex: Integer; AButtonIndex: Integer); // DateNavigator class procedure DateNavigatorDrawButtonCaption(DC: HDC; R: TRect; Offset: Integer; const ACaption: string; AOpaque: Boolean); virtual; public constructor Create(AData: Integer); virtual; // New procedure CalculateButtonParts(const ADrawParams: TdxBarButtonLikeControlDrawParams; var AParts: array of TRect; const AItemRect: TRect); virtual; procedure CalculateColorComboParts(const ADrawParams: TdxBarColorComboControlDrawParams; var AParts: array of TRect; const AItemRect: TRect); virtual; procedure CalculateComboParts(const ADrawParams: TdxBarEditLikeControlDrawParams; var AParts: array of TRect; const AItemRect: TRect); virtual; procedure CalculateEditParts(const ADrawParams: TdxBarEditLikeControlDrawParams; var AParts: array of TRect; const AItemRect: TRect); virtual; procedure CalculateSpinEditParts(const ADrawParams: TdxBarEditLikeControlDrawParams; var AParts: array of TRect; const AItemRect: TRect); virtual; // Common class procedure CalculateArrowPoints(const ARect: TRect; AArrowSize: Integer; AArrowDirection: TcxArrowDirection; out P: TcxArrowPoints); class function GetArrowRectByPoints(const P: TcxArrowPoints; AArrowDirection: TcxArrowDirection): TRect; class procedure SetArrowRegion(ACanvas: TcxCanvas; AArrowDirection: TcxArrowDirection; P: TcxArrowPoints; AOperation: TcxRegionOperation); // Sizes function GetToolbarContentOffsets(ABar: TdxBar; ADockingStyle: TdxBarDockingStyle; AHasSizeGrip: Boolean): TRect; virtual; function GetToolbarsOffsetForAutoAlign: Integer; virtual; function GetBorderSize: Integer; virtual; function GetIconAreaSize(ABarControl: TCustomdxBarControl): Integer; virtual; class function GetControlCaptionOffset(ABarItemControl: TdxBarItemControl): Integer; virtual; class function GetDefaultTextSize(ACanvas: TcxCanvas): Integer; virtual; class function GetPopupWindowBorderWidth: Integer; virtual; procedure GetImageParams(AItemControl: TdxBarItemControl; const ADrawRect: TRect; APaintType: TdxBarPaintType; AViewStructure: TdxBarItemControlViewStructure; AViewSize: TdxBarItemControlViewSize; ACenter, ASelected, ADowned, ADrawDowned: Boolean; var AGlyphEmpty: Boolean; out ACurrentGlyph: TBitmap; out ACurrentImages: TCustomImageList; out ACurrentImageIndex: Integer; out AImageBounds: TRect); function GetLargeImageBounds(AItemControl: TdxBarItemControl; const AImageSize: TSize; const ADrawRect: TRect; APaintType: TdxBarPaintType; AViewStructure: TdxBarItemControlViewStructure; AGlyphLayout: TdxBarGlyphLayout): TRect; virtual; class function GetSmallImageBounds(AItemControl: TdxBarItemControl; const AImageSize: TSize; const ADrawRect: TRect; APaintType: TdxBarPaintType; AViewStructure: TdxBarItemControlViewStructure; ACenter, AGlyphEmpty, AStretchGlyph, ADowned, ADrawDowned: Boolean): TRect; class procedure DrawBackground(ABarItemControl: TdxBarItemControl; DC: HDC; const R: TRect; ABrush: HBRUSH; AOpaque: Boolean); virtual; class procedure DrawBackgroundFrameRect(ABarItemControl: TdxBarItemControl; DC: HDC; R: TRect; ABrush: HBRUSH; AOpaque: Boolean); virtual; class procedure DrawDisabledShadowRect(ABarItemControl: TdxBarItemControl; DC: HDC; R: TRect); virtual; procedure DrawItemBackground(ABarItemControl: TdxBarItemControl; ACanvas: TcxCanvas; const ASourceRect: TRect; ABrush: HBRUSH); virtual; procedure DrawGlyph(ABarItemControl: TdxBarItemControl; ADC: HDC; ADrawRect: TRect; const AFullBounds: TRect; APaintType: TdxBarPaintType; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, ACenter, AForceUseBkBrush, AIsSplit: Boolean); overload; procedure DrawGlyph(ABarItemControl: TdxBarItemControl; ADC: HDC; ADrawRect: TRect; const AFullBounds: TRect; out AImageBounds: TRect; APaintType: TdxBarPaintType; AViewStructure: TdxBarItemControlViewStructure; AViewSize: TdxBarItemControlViewSize; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, ACenter, AForceUseBkBrush, AGrayScale, AIsSplit: Boolean); overload; virtual; procedure DrawGlyphAndBkgnd(ABarItemControl: TdxBarItemControl; ADC: HDC; R: TRect; const AGlyphRect: TRect; APaintType: TdxBarPaintType; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AForceUseBkBrush, AGrayScale, AIsSplit: Boolean); virtual; procedure DrawGlyphAndTextInSubMenu(const ADrawParams: TdxBarButtonLikeControlDrawParams; var R: TRect); virtual; procedure DrawItemMultilineText(const ADrawParams: TdxBarItemControlDrawParams; const AText: string; const ATextRect: TRect; AMaxLineCount: Integer); procedure DrawItemText(ABarItemControl: TdxBarItemControl; ADC: HDC; S: string; APaintRect: TRect; AAlignment: UINT; AEnabled, ASelected, ARotated, AClipped, AFlatText: Boolean; AFormat: UINT = DT_SINGLELINE); virtual; procedure DrawItemTextInSubMenu(const ADrawParams: TdxBarButtonLikeControlDrawParams; R: TRect); class procedure DrawLowered(DC: HDC; var R: TRect); virtual; class procedure FrameAndFillRect(ABarItemControl: TdxBarItemControl; DC: HDC; var R: TRect; Enabled, Selected, Pressed: Boolean); virtual; class procedure GetArrowParams(const ADrawParams: TdxBarItemControlDrawParams; out ABrush: HBRUSH; out AArrowColor: COLORREF); virtual; class procedure GetCaptionParams(out AOffsets: TRect; out AHeightCorrection: Integer); virtual; class function GlyphBkgndBrush(ABarItemControl: TdxBarItemControl; APaintType: TdxBarPaintType; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AForceUseBkBrush, AGrayScale: Boolean): HBRUSH; virtual; class function GlyphDownShift(ABarItemControl: TdxBarItemControl): Integer; virtual; class function GlyphDrawDownedShift(ABarItemControl: TdxBarItemControl; ADown: Boolean): Integer; virtual; class function IsFlatItemText: Boolean; virtual; class function IsFlatItemTextForMenu: Boolean; virtual; class function IsItemTextSelectedInverted: Boolean; virtual; class function LoweredBorderSize(ABarItemControl: TdxBarItemControl): Integer; virtual; class function TextAreaOffset(ABarItemControl: TdxBarItemControl): Integer; virtual; // BarManager class function BarFingersSize(ABar: TdxBar): Integer; class function BeforeFingersSize: Integer; virtual; class function BorderSizeX: Integer; virtual; class function BorderSizeY: Integer; virtual; class function EmptyFingersSize: Integer; virtual; class function FingersSize: Integer; virtual; class function GripperSize: Integer; virtual; class function RealButtonArrowWidth(ABarManager: TdxBarManager): Integer; virtual; class function RealLargeButtonArrowWidth(ABarManager: TdxBarManager): Integer; virtual; class function SubMenuBeginGroupIndent: Integer; virtual; // DockControl class procedure DockControlFillBackground(ADockControl: TdxDockControl; DC: HDC; ADestR, ASourceR, AWholeR: TRect; ABrush: HBRUSH; AColor: TColor); virtual; class function IsNativeBackground: Boolean; virtual; // CustomBar class function BarChildrenHaveShadows(ABarControl: TCustomdxBarControl): Boolean; virtual; class function BarControlOwnerBrush(ABarManager: TdxBarManager): HBRUSH; virtual; procedure BarDrawDockedBackground(ABarControl: TdxBarControl; DC: HDC; ADestR, ASourceR: TRect; ABrush: HBRUSH; AColor: TColor); virtual; class procedure BarDrawFloatingBackground(ABarControl: TCustomdxBarControl; DC: HDC; ADestR, ASourceR: TRect; ABrush: HBRUSH; AColor: TColor); virtual; class procedure BarDrawOwnerLink(ABarControl: TCustomdxBarControl; DC: HDC); virtual; procedure BarFillParentBackground(ABarControl: TCustomdxBarControl; DC: HDC; const ADestR, ASourceR: TRect; ABrush: HBRUSH; AColor: TColor); class function BarHasShadow(ABarControl: TCustomdxBarControl): Boolean; virtual; class function BarToolbarBrush(ABarControl: TCustomdxBarControl): HBRUSH; virtual; class function BarToolbarBrushEx(ABarControl: TdxBarControl): HBRUSH; virtual; class function BarToolbarDownedBrush(ABarControl: TCustomdxBarControl): HBRUSH; virtual; class function BarToolbarDownedSelBrush(ABarControl: TCustomdxBarControl): HBRUSH; virtual; class function BarToolbarSelBrush(ABarControl: TCustomdxBarControl): HBRUSH; virtual; class function ComboBoxArrowWidth(ABarControl: TCustomdxBarControl; cX: Integer): Integer; virtual; class function EditTextSize(ABarControl: TCustomdxBarControl; cY: Integer): Integer; virtual; class procedure GetEditTextParams(out AOffsets: TRect; out AHeightCorrection: Integer); class procedure GetEditTextVerticalOffsets(out ATop, ABottom: Integer); virtual; class procedure SetWindowRgn(AHandle: THandle; const AWindowRect: TRect; ARedraw: Boolean = False); virtual; // Bar class function BarAllowHotTrack: Boolean; virtual; class function BarAllowQuickCustomizing: Boolean; virtual; class function BarBeginGroupSideSize: Integer; virtual; class function BarBeginGroupSize: Integer; virtual; class procedure BarBorderPaintSizes(ABarControl: TdxBarControl; var R: TRect); virtual; class function BarBorderSize: Integer; virtual; class procedure BarBorderSizes(ABar: TdxBar; AStyle: TdxBarDockingStyle; var R: TRect); virtual; class function BarCaptionAreaSize: Integer; virtual; class procedure BarCaptionFillBackground(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); virtual; class function BarCaptionSize: Integer; virtual; class function BarCaptionTransparent: Boolean; virtual; class function BarCloseButtonSize: TSize; virtual; procedure BarDrawBackground(ABarControl: TdxBarControl; ADC: HDC; const ADestRect, ASourceRect: TRect; ABrush: HBRUSH; AColor: TColor); virtual; procedure BarDrawBeginGroup(ABarControl: TCustomdxBarControl; DC: HDC; ABeginGroupRect: TRect; AToolbarBrush: HBRUSH; AHorz: Boolean); virtual; class procedure BarDrawCaptionElement(ABarControl: TdxBarControl; DC: HDC; R: TRect; AState: TdxBarMarkState); virtual; class procedure BarDrawCloseButton(ABarControl: TdxBarControl; DC: HDC; R: TRect); virtual; procedure BarDrawDockedBarBorder(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); virtual; class procedure BarDrawFloatingBarBorder(ABarControl: TdxBarControl; DC: HDC; var R, CR: TRect; AToolbarBrush: HBRUSH); virtual; class procedure BarDrawFloatingBarCaption(ABarControl: TdxBarControl; DC: HDC; var R, CR: TRect; AToolbarBrush: HBRUSH); virtual; procedure BarDrawMark(ABarControl: TdxBarControl; DC: HDC; MarkR: TRect); virtual; procedure BarDrawMarks(ABarControl: TdxBarControl; ACanvas: TcxCanvas; const AItemRect: TRect; AToolbarBrush: HBRUSH); virtual; class procedure BarDrawMDIButton(ABarControl: TdxBarControl; AButton: TdxBarMDIButton; ASelected, APressed: Boolean; DC: HDC; R: TRect); virtual; class procedure BarDrawStatusBarGrip(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); virtual; class procedure BarDrawStatusBarTopBorder(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); virtual; class function BarHorSize: Integer; virtual; function BarMarkRect(ABarControl: TdxBarControl): TRect; virtual; function BarMarkItemRect(ABarControl: TdxBarControl): TRect; virtual; procedure BarMarkRectInvalidate(ABarControl: TdxBarControl); virtual; class function BarTopSize: Integer; virtual; class function BarBottomSize: Integer; virtual; class function BarUseSystemClose: Boolean; virtual; class function BarUseSystemNCBorder: Boolean; virtual; function MarkSizeX: Integer; virtual; function MarkSizeY: Integer; virtual; class procedure StatusBarFillBackground(ABarControl: TdxBarControl; DC: HDC; ADestR, ASourceR, AWholeR: TRect; ABrush: HBRUSH; AColor: TColor); virtual; class function StatusBarGripSize(ABarManager: TdxBarManager): TSize; virtual; class function StatusBarTopBorderSize(ABarManager: TdxBarManager): Integer; virtual; // QuickCustItem class function BarToolbarBrushEx2(ABarControl: TdxBarControl): HBRUSH; virtual; class procedure DrawQuickCustItemFrame(ABarItemControl: TdxBarItemControl; DC: HDC; var R, ARect: TRect; Selected: Boolean); virtual; class procedure DrawQuickCustItemFrameSelected(ABarItemControl: TdxBarItemControl; DC: HDC; WholeR, R: TRect; Selected: Boolean); virtual; class function IsQuickControlPopupOnRight: Boolean; virtual; // BarItemControl // Sizes class function GetTailAreaSize(const ADrawParams: TdxBarItemControlDrawParams): Integer; virtual; class function ItemControlGetIndents(const ADrawParams: TdxBarItemControlDrawParams; ADrawAreaType: TdxBarItemControlPart): TRect; virtual; // ButtonControl // Sizes function GetButtonBorderHeight: Integer; virtual; function GetButtonBorderWidth: Integer; virtual; function GetButtonHeight(AIconSize, ATextSize: Integer): Integer; virtual; function GetButtonWidth(AIconSize, ATextSize: Integer): Integer; virtual; function GetButtonSize(AIconSize, ATextSize: Integer): TSize; virtual; class function GetDefaultArrowSignSize: TSize; virtual; class procedure CorrectButtonControlDefaultHeight(var DefaultHeight: Integer); virtual; class procedure CorrectButtonControlDefaultWidth(var DefaultWidth: Integer); virtual; class function IsDropDownRepaintNeeded: Boolean; virtual; class procedure OffsetCaptionBounds(ADown, APressed: Boolean; var R: TRect); virtual; class procedure OffsetEllipsisBounds(APressed: Boolean; var R: TRect); virtual; // Draw procedure DrawButtonLikeControl(const ADrawParams: TdxBarButtonLikeControlDrawParams; ARect: TRect); virtual; procedure DrawButtonLikeControlCaption(const ADrawParams: TdxBarButtonLikeControlDrawParams; const ARect, AImageBounds: TRect); virtual; procedure DrawButtonControlArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; R1: TRect; ABrush: HBRUSH); virtual; procedure DrawSplitControlArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; ARect: TRect); virtual; procedure DrawAssociateControlArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; ARect: TRect); virtual; // ComboControl class function ComboControlArrowOffset: Integer; virtual; class function ComboControlButtonOffsets: TRect; virtual; procedure ComboControlDrawArrowButton(const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); virtual; class procedure ComboControlDrawSimpleButton(ABarComboControl: TdxBarItemControl; ADC: HDC; var ARect: TRect; ADroppedDown, ASelected: Boolean; ABrush: HBRUSH; APaintType: TdxBarPaintType); virtual; class procedure ComboControlGetArrowParams(const ADrawParams: TdxBarEditLikeControlDrawParams; out ABrush: HBRUSH; out AArrowColor: COLORREF); virtual; // DropDownListBox class function DropDownListBoxBorderSize: Integer; virtual; procedure DropDownListBoxDrawBorder(DC: HDC; AColor: TColor; ARect: TRect); virtual; // SubMenuControl // Conditions class function SubMenuControlIsOffsetRecentGroupNeeded: Boolean; virtual; // Sizes class function GetSubMenuItemTextIndent(const ADrawParams: TdxBarItemControlDrawParams): Integer; virtual; class function SubMenuControlArrowsOffset: Integer; virtual; class function SubMenuControlArrowWidth(ATextSize: Integer): Integer; virtual; class function SubMenuControlBeginGroupSize: Integer; virtual; class function SubMenuControlBorderSize: Integer; virtual; class function SubMenuControlNCBorderSize: Integer; virtual; class function SubMenuControlClientBorderSize: Integer; virtual; class procedure SubMenuControlCalcDrawingConsts(ACanvas: TcxCanvas; ATextSize: Integer; out AMenuArrowWidth, AMarkSize: Integer); virtual; class function SubMenuControlContentRectOffset(ABarSubMenuControl: TdxBarSubMenuControl): TRect; virtual; class function SubMenuControlDetachCaptionAreaSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; virtual; class function SubMenuControlGetBandSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; virtual; class function SubMenuControlGetControlContentIndent(ABarSubMenuControl: TdxBarSubMenuControl): Integer; virtual; class function SubMenuControlInternalBorderSize: Integer; virtual; class function SubMenuControlInternalBorderOffset: Integer; virtual; class function SubMenuControlMarkArrowSize(AMarkSize: Integer): Integer; virtual; class function SubMenuControlMarkRectOffset(ABarSubMenuControl: TdxBarSubMenuControl): Integer; virtual; class function SubMenuControlNormalItemHeight: Integer; virtual; // Positions class function GetSubMenuItemIconRect(const AItemRect: TRect; AIconAreaSize: Integer): TRect; class function SubMenuControlBeginGroupRect( ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; const AItemRect: TRect): TRect; virtual; class procedure SubMenuControlOffsetDetachCaptionRect(ABarSubMenuControl: TdxBarSubMenuControl; var R: TRect); virtual; // Draw procedure SubMenuControlDrawScrollButton(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; AArrowDirection: TcxArrowDirection); virtual; procedure SubMenuControlDrawBackground(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; ARect: TRect; ABrush: HBRUSH; AColor: TColor); virtual; procedure SubMenuControlDrawBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); virtual; class procedure SubMenuControlDrawClientBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; const R: TRect; ABrush: HBRUSH); virtual; procedure SubMenuControlDrawDetachCaption(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); virtual; procedure SubMenuControlDrawBeginGroup(ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; ACanvas: TcxCanvas; const ABeginGroupRect: TRect); virtual; class procedure SubMenuControlDrawItemFrame(ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; DC: HDC; AItemRect: TRect; AIndex: Integer); virtual; procedure SubMenuControlDrawSeparator(ACanvas: TcxCanvas; const ARect: TRect); virtual; class procedure SubMenuControlPrepareBkBrush(ABarSubMenuControl: TdxBarSubMenuControl; var ABkBrush: HBRUSH); virtual; class function SubMenuControlTextSize(ACanvas: TcxCanvas): Integer; virtual; class function SubMenuControlToolbarItemsBrush(ABarSubMenuControl: TdxBarSubMenuControl): HBRUSH; virtual; // ApplicationMenu procedure ApplicationMenuDrawBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; const ARect: TRect); virtual; procedure ApplicationMenuDrawButton(const ADrawParams: TdxBarApplicationMenuButtonControlDrawParams; var R: TRect); virtual; procedure ApplicationMenuDrawContentArea(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; const AContentRect, AItemsArea: TRect); virtual; function ApplicationMenuGetFrameSizes: TRect; virtual; // SubMenuExtraControl procedure ExtraMenuControlDrawBackground(AExtraMenuControl: TCustomdxBarControl; ACanvas: TcxCanvas; ARect: TRect; ABrush: HBRUSH; AColor: TColor); virtual; procedure ExtraMenuControlDrawBeginGroup(AExtraMenuControl: TCustomdxBarControl; ACanvas: TcxCanvas; ABeginGroupRect: TRect; AToolbarBrush: HBRUSH; AHorz: Boolean); virtual; // Edit class procedure EditDrawInterior(ABarEditControl: TdxBarEditControl; ABarEdit: TdxBarEdit; ACanvas: TCanvas; R: TRect; ItemLink: TdxBarItemLink); virtual; class function EditGetRealPaintStyle(ABarManager: TdxBarManager): TdxBarManagerStyle; virtual; function EditGetEnabledBkColor(ABarItemControl: TdxBarCustomEditControl): COLORREF; virtual; function EditGetDisabledBkColor(ABarItemControl: TdxBarCustomEditControl): COLORREF; virtual; function EditGetBkColor(const ADrawParams: TdxBarEditLikeControlDrawParams): COLORREF; virtual; function EditGetEnabledTextColor: COLORREF; virtual; function EditGetDisabledTextColor: COLORREF; virtual; function EditGetTextColor(ABarItemControl: TdxBarCustomEditControl): COLORREF; virtual; procedure EditGetColors(ABarItemControl: TdxBarCustomEditControl; var ATextColor, ABkColor: COLORREF); virtual; // EditButton procedure EditButtonDrawBackground(const ADrawParams: TdxBarEditLikeControlDrawParams; AState: Integer; ARect: TRect; ABrush: HBrush); virtual; procedure EditButtonDrawBorder(const ADrawParams: TdxBarItemControlDrawParams; AState: Integer; var ADrawRect: TRect; out AContentRect: TRect); virtual; function EditButtonAllowOffsetContent: Boolean; virtual; function EditButtonAllowCompositeFrame: Boolean; virtual; class function EditButtonAllowHotTrack(const ADrawParams: TdxBarItemControlDrawParams): Boolean; virtual; class function EditButtonIsCustomBorder: Boolean; virtual; class function EditButtonIsCustomBackground(AState: Integer): Boolean; virtual; // CustomCombo class procedure CustomComboDrawItem(ABarCustomCombo: TdxBarCustomCombo; ACanvas: TCanvas; AIndex: Integer; ARect: TRect; AState: TOwnerDrawState; AInteriorIsDrawing: Boolean); virtual; // EditControl procedure DrawEditLikeControl(const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); virtual; class function EditControlBorderOffsets: TRect; virtual; procedure EditControlDrawBorder(const ADrawParams: TdxBarEditLikeControlDrawParams; var ARect: TRect); virtual; procedure EditControlDrawCaption(const ADrawParams: TdxBarEditLikeControlDrawParams; const ARect: TRect); virtual; procedure EditControlDrawSelectionFrame(const ADrawParams: TdxBarEditLikeControlDrawParams; const ARect: TRect); virtual; procedure EditControlDrawGlyph(const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); virtual; class function EditControlCaptionBackgroundIsOpaque(const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; virtual; class function EditControlCaptionRightIndentIsOpaque(const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; virtual; procedure EditControlDrawTextField(ABarEditControl: TdxBarEditControl; DC: HDC; const ARect: TRect; AIgnoreEnabled: Boolean); virtual; class function EditControlES_Style: Integer; virtual; function EditControlGetContentRect(const ARect: TRect): TRect; class function EditControlShowIconDefault(const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; virtual; // Select EditControl indents class function EditControlGetIndents(const ADrawParams: TdxBarEditLikeControlDrawParams; ADrawAreaType: TdxBarItemControlPart): TRect; virtual; class function EditControlCaptionGetLeftIndent(const ADrawParams: TdxBarEditLikeControlDrawParams): Integer; virtual; class function EditControlCaptionIconRelativeLeftIndent(const ADrawParams: TdxBarEditLikeControlDrawParams): Integer; virtual; class function EditControlCaptionLeftIndent(const ADrawParams: TdxBarEditLikeControlDrawParams): Integer; virtual; class function EditControlCaptionRightIndent: Integer; virtual; class function EditControlSubmenuGlyphIndents(const ADrawParams: TdxBarEditLikeControlDrawParams): TRect; virtual; class function EditControlGetRightCaptionIndentBrush(ABarEditControl: TdxBarCustomEditControl): HBRUSH; virtual; class function EditControlGlyphIsDrawSelected(ABarEditControl: TdxBarCustomEditControl): Boolean; virtual; class procedure EditControlPrepareEditWnd(ABarEditControl: TdxBarEditControl; AHandle: HWND); virtual; class procedure EditControlUpdateWndText(ABarEditControl: TdxBarEditControl; AHandle: HWND; ANotEqual: Boolean); virtual; class function HasEditControlExternalFrame(APaintType: TdxBarPaintType; ASelected: Boolean): Boolean; virtual; // ColorCombo procedure ColorComboCorrectFrameRect(const ADrawParams: TdxBarColorComboControlDrawParams; var ARect: TRect); virtual; procedure ColorComboDrawCustomButton(const ADrawParams: TdxBarColorComboControlDrawParams; ARect: TRect); virtual; procedure ColorComboDrawCustomButtonAdjacentZone(const ADrawParams: TdxBarColorComboControlDrawParams; ARect: TRect); virtual; function GetCustomColorButtonIndents(const ADrawParams: TdxBarColorComboControlDrawParams): TRect; virtual; function IsCustomColorButtonVisible(const ADrawParams: TdxBarColorComboControlDrawParams): Boolean; virtual; // SysPanel class procedure SysPanelCalcSize(AHandle: HWND; var ARect: TRect; var Corner: TdxCorner; Combo: TdxBarItem; AllowResizing: Boolean); virtual; class procedure SysPanelDraw(AHandle: HWND; AllowResizing, MouseAboveCloseButton, CloseButtonIsTracking: Boolean; var CloseButtonRect, GripRect: TRect; Corner: TdxCorner); virtual; class function SysPanelSize: Integer; virtual; // DateNavigator class function IsDateNavigatorFlat: Boolean; virtual; class procedure DateNavigatorDrawButton(ABarItem: TdxBarItem; DC: HDC; R: TRect; const ACaption: string; APressed: Boolean); virtual; function DateNavigatorHeaderColor: TColor; virtual; // SpinEditControl function GetSpinEditArrowPos(const ADrawParams: TdxBarSpinEditDrawParams; ARect: TRect; AButtonIndex: Integer): TPoint; virtual; procedure SpinEditCorrectFrameRect(const ADrawParams: TdxBarItemControlDrawParams; var ARect: TRect); virtual; function GetSpinEditArrowSize(AHeight: Integer): TSize; virtual; function GetSpinEditButtonBounds(const ARect: TRect; AButton: TdxBarSpinEditButton): TRect; virtual; function GetSpinEditButtonIndents: TRect; virtual; procedure SpinEditControlDrawButton(const ADrawParams: TdxBarSpinEditDrawParams; ARect: TRect; AButtonIndex: Integer); virtual; procedure SpinEditControlDrawButtonsAdjacentZone(const ADrawParams: TdxBarSpinEditDrawParams; const ARect: TRect); virtual; // ProgressControl class function ProgressControlBarBrushColor: TColorRef; virtual; class function ProgressControlBarHeight(ABarItemControl: TdxBarItemControl): Integer; virtual; procedure ProgressControlDrawBar(const ADrawParams: TdxbarProgressControlDrawParams; BarR: TRect; ABarBrushColor: TColorRef); virtual; procedure ProgressControlDrawBackground(const ADrawParams: TdxBarItemControlDrawParams; var BarR: TRect); virtual; procedure ProgressControlFillContent(const ADrawParams: TdxBarItemControlDrawParams; const R: TRect; ABarBrush: HBRUSH); virtual; procedure ProgressControlFillDiscreteContent(const ADrawParams: TdxBarItemControlDrawParams; const R: TRect; ABarBrush: HBRUSH); virtual; class function ProgressControlIndent(const ADrawParams: TdxBarItemControlDrawParams): Integer; virtual; // ContainerControl class function ContainerControlSubMenuOffset: Integer; virtual; // InPlaceSubItemControl // Sizes class function InPlaceSubItemControlBrush: HBRUSH; virtual; class function InPlaceSubItemGetArrowWidth(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams): Integer; virtual; class function InPlaceSubItemGetTextIndent: Integer; virtual; // Conditions function InPlaceSubItemControlIsFlatItemText(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams): Boolean; virtual; function InPlaceSubItemControlIsArrowSelected(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams): Boolean; virtual; // Draw procedure InPlaceSubItemControlDrawArrow(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams; ADirection: TcxArrowDirection; ARect: TRect); virtual; procedure InPlaceSubItemControlDrawBackground(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams; ARect: TRect); virtual; procedure InPlaceSubItemControlDrawInMenu(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams; ARect: TRect); virtual; // StaticControl procedure DrawStaticBorder(const ADrawParams: TdxBarStaticLikeControlDrawParams; var ARect: TRect); virtual; procedure DrawStaticGlyphAndCaption(const ADrawParams: TdxBarStaticLikeControlDrawParams; const ARect: TRect); virtual; procedure DrawStaticLikeControl(const ADrawParams: TdxBarStaticLikeControlDrawParams; var ARect: TRect; const AIndentsRect: TRect); virtual; class function StaticBackgroundIsOpaque(const ADrawParams: TdxBarItemControlDrawParams): Boolean; virtual; // Separator class function SeparatorControlGetIndents(const ADrawParams: TdxBarSeparatorControlDrawParams; ADrawAreaType: TdxBarItemControlPart): TRect; virtual; function SubMenuGetSeparatorSize: Integer; virtual; procedure DrawSeparatorGlyphAndCaption(const ADrawParams: TdxBarSeparatorControlDrawParams; const ARect: TRect); virtual; procedure DrawSeparatorControl(const ADrawParams: TdxBarSeparatorControlDrawParams; const ARect: TRect); virtual; end; TdxBarStandardPainter = class(TdxBarPainter) protected class procedure DrawGlyphBorder(ABarItemControl: TdxBarItemControl; DC: HDC; ABrush: HBRUSH; NeedBorder: Boolean; R: TRect; PaintType: TdxBarPaintType; IsGlyphEmpty, Selected, Down, DrawDowned, ADroppedDown, IsSplit: Boolean); override; class procedure DrawGlyphCheckMark(ABarItemControl: TdxBarItemControl; DC: HDC; X, Y, DoubleSize: Integer); override; class function IgnoreGlyphOpaque: Boolean; override; // Bar class function BarIsBarSmall(ABarControl: TdxBarControl; const R: TRect): Boolean; override; class procedure BarDrawMarkAtPos(ABarControl: TdxBarControl; DC: HDC; const ItemRect: TRect; Offset: Integer); override; procedure BarDrawMarkBackground(ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect; AToolbarBrush: HBRUSH); override; public // Common // Sizes function GetBorderSize: Integer; override; class function GlyphDownShift(ABarItemControl: TdxBarItemControl): Integer; override; class function GlyphDrawDownedShift(ABarItemControl: TdxBarItemControl; ADown: Boolean): Integer; override; class function LoweredBorderSize(ABarItemControl: TdxBarItemControl): Integer; override; // Draw class procedure DrawDisabledShadowRect(ABarItemControl: TdxBarItemControl; DC: HDC; R: TRect); override; procedure DrawGlyphAndTextInSubMenu(const ADrawParams: TdxBarButtonLikeControlDrawParams; var R: TRect); override; class procedure DrawLowered(DC: HDC; var R: TRect); override; class procedure FrameAndFillRect(ABarItemControl: TdxBarItemControl; DC: HDC; var R: TRect; Enabled, Selected, Pressed: Boolean); override; class function GlyphBkgndBrush(ABarItemControl: TdxBarItemControl; APaintType: TdxBarPaintType; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AForceUseBkBrush, AGrayScale: Boolean): HBRUSH; override; // BarManager class function BeforeFingersSize: Integer; override; class function FingersSize: Integer; override; class function SubMenuBeginGroupIndent: Integer; override; // Bar class procedure BarDrawCloseButton(ABarControl: TdxBarControl; DC: HDC; R: TRect); override; procedure BarDrawDockedBarBorder(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); override; class procedure BarDrawFloatingBarBorder(ABarControl: TdxBarControl; DC: HDC; var R, CR: TRect; AToolbarBrush: HBRUSH); override; class procedure BarDrawMDIButton(ABarControl: TdxBarControl; AButton: TdxBarMDIButton; ASelected, APressed: Boolean; DC: HDC; R: TRect); override; class function BarHorSize: Integer; override; function BarMarkItemRect(ABarControl: TdxBarControl): TRect; override; class function BarTopSize: Integer; override; class function BarBottomSize: Integer; override; class function BarUseSystemClose: Boolean; override; class function BarUseSystemNCBorder: Boolean; override; // ButtonControl procedure DrawButtonControlArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; R1: TRect; ABrush: HBRUSH); override; class procedure OffsetCaptionBounds(ADown, APressed: Boolean; var R: TRect); override; class procedure OffsetEllipsisBounds(APressed: Boolean; var R: TRect); override; // ComboControl class procedure ComboControlDrawArrow(ABarComboControl: TdxBarItemControl; DC: HDC; X, Y, Size: Integer; Color: COLORREF); override; class procedure ComboControlDrawSimpleButton(ABarComboControl: TdxBarItemControl; ADC: HDC; var ARect: TRect; ADroppedDown, ASelected: Boolean; ABrush: HBRUSH; APaintType: TdxBarPaintType); override; // DropDownListBox class function DropDownListBoxBorderSize: Integer; override; procedure DropDownListBoxDrawBorder(DC: HDC; AColor: TColor; ARect: TRect); override; // SubMenuControl class procedure SubMenuControlDrawItemFrame(ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; DC: HDC; AItemRect: TRect; AIndex: Integer); override; class function SubMenuControlIsOffsetRecentGroupNeeded: Boolean; override; class function SubMenuControlContentRectOffset(ABarSubMenuControl: TdxBarSubMenuControl): TRect; override; class function SubMenuControlMarkRectOffset(ABarSubMenuControl: TdxBarSubMenuControl): Integer; override; // EditControl class procedure EditControlPrepareEditWnd(ABarEditControl: TdxBarEditControl; AHandle: HWND); override; end; TdxBarEnhancedPainter = class(TdxBarStandardPainter) protected // Bar class procedure BarDrawMarkAtPos(ABarControl: TdxBarControl; DC: HDC; const ItemRect: TRect; Offset: Integer); override; procedure BarDrawMarkBackground(ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect; AToolbarBrush: HBRUSH); override; public // BarManager class function BeforeFingersSize: Integer; override; class function FingersSize: Integer; override; class function SubMenuBeginGroupIndent: Integer; override; // Bar class function BarAllowQuickCustomizing: Boolean; override; procedure BarDrawDockedBarBorder(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); override; function BarMarkItemRect(ABarControl: TdxBarControl): TRect; override; end; TdxBarFlatPainter = class(TdxBarPainter) protected // Common class procedure DrawGlyphBorder(ABarItemControl: TdxBarItemControl; ADC: HDC; ABrush: HBRUSH; ANeedBorder: Boolean; R: TRect; APaintType: TdxBarPaintType; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AIsSplit: Boolean); override; class procedure DrawGlyphCheckMark(ABarItemControl: TdxBarItemControl; DC: HDC; X, Y, DoubleSize: Integer); override; class procedure DrawGlyphImage(ABarItemControl: TdxBarItemControl; DC: HDC; ABrush: HBRUSH; NeedBorder: Boolean; R: TRect; const GlyphRect: TRect; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; Selected, Down, DrawDowned, ForceUseBkBrush, GrayScale, BarControlOwner: Boolean; PaintType: TdxBarPaintType); override; class procedure DrawFrameRect(ABarItemControl: TdxBarItemControl; ADC: HDC; const ARect: TRect; ABrush: HBRUSH; APaintType: TdxBarPaintType; ASelected, ADowned: Boolean); virtual; class procedure FrameFlatSelRect(DC: HDC; const R: TRect); override; class function GetToolbarBrush(ABarItemControl: TdxBarItemControl): HBRUSH; virtual; // Bar class function BarCaptionBkColor(ABarControl: TdxBarControl; AMainFormActive: Boolean): COLORREF; override; class function BarMarkArrowColor(ABarControl: TdxBarControl; AState: TdxBarMarkState): COLORREF; override; procedure BarDrawMarkBackground(ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect; AToolbarBrush: HBRUSH); override; class procedure BarOffsetFloatingBarCaption(ABarControl: TdxBarControl; var X: Integer; var R: TRect); override; class function GetDrawMarkElementColor(ABarControl: TdxBarControl): Integer; override; // SubMenuControl procedure SubMenuControlDrawNonRecentGroupSeparator(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; AArrowDirection: TcxArrowDirection); override; procedure SubMenuControlDrawMarkSelection(ABarSubMenuControl: TdxBarSubMenuControl; ADC: HDC; const AMarkRect: TRect); override; // Edit class procedure EditOffsetInteriorRect(var R: TRect); override; // SpinEditControl procedure DrawSpinEditArrow(const ADrawParams: TdxBarSpinEditDrawParams; AArrowPos: TPoint; AButtonIndex: Integer); override; public // New procedure CalculateSpinEditParts(const ADrawParams: TdxBarEditLikeControlDrawParams; var AParts: array of TRect; const AItemRect: TRect); override; // Common // Sizes function GetBorderSize: Integer; override; class function GetControlCaptionOffset(ABarItemControl: TdxBarItemControl): Integer; override; // Draw procedure DrawGlyphAndTextInSubMenu(const ADrawParams: TdxBarButtonLikeControlDrawParams; var R: TRect); override; class procedure DrawLowered(DC: HDC; var R: TRect); override; procedure DrawStaticBorder(const ADrawParams: TdxBarStaticLikeControlDrawParams; var ARect: TRect); override; class procedure FrameAndFillRect(ABarItemControl: TdxBarItemControl; DC: HDC; var R: TRect; Enabled, Selected, Pressed: Boolean); override; class procedure GetArrowParams(const ADrawParams: TdxBarItemControlDrawParams; out ABrush: HBRUSH; out AArrowColor: COLORREF); override; class procedure GetCaptionParams(out AOffsets: TRect; out AHeightCorrection: Integer); override; class function GetSubMenuItemTextIndent(const ADrawParams: TdxBarItemControlDrawParams): Integer; override; class function GlyphBkgndBrush(ABarItemControl: TdxBarItemControl; APaintType: TdxBarPaintType; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AForceUseBkBrush, AGrayScale: Boolean): HBRUSH; override; class function IsFlatItemText: Boolean; override; class function LoweredBorderSize(ABarItemControl: TdxBarItemControl): Integer; override; class function StaticBorderBrush(ABarItemControl: TdxBarItemControl; ABorderStyle: TdxBarStaticBorderStyle): HBRUSH; virtual; class function TextAreaOffset(ABarItemControl: TdxBarItemControl): Integer; override; // BarManager class function BeforeFingersSize: Integer; override; class function FingersSize: Integer; override; class function RealButtonArrowWidth(ABarManager: TdxBarManager): Integer; override; class function RealLargeButtonArrowWidth(ABarManager: TdxBarManager): Integer; override; class function SubMenuBeginGroupIndent: Integer; override; // CustomBar class function BarChildrenHaveShadows(ABarControl: TCustomdxBarControl): Boolean; override; class procedure BarDrawBarControlOwner(ACustomBarControl: TCustomdxBarControl; DC: HDC; R: TRect; ABarControl: TCustomdxBarControl); virtual; class procedure BarDrawBarControlOwnerBorder(ACustomBarControl: TCustomdxBarControl; DC: HDC; R: TRect; ABarItemControl: TdxBarItemControl; ABarControl: TCustomdxBarControl); virtual; class procedure BarDrawBarControlOwnerFrame(ACustomBarControl: TCustomdxBarControl; DC: HDC; R: TRect); virtual; class procedure BarDrawBarControlOwnerLink(ACustomBarControl: TCustomdxBarControl; DC: HDC; R, ALinkR: TRect; ABarItemControl: TdxBarItemControl); virtual; class function BarHasShadow(ABarControl: TCustomdxBarControl): Boolean; override; class function BarToolbarBrush(ABarControl: TCustomdxBarControl): HBRUSH; override; class function BarToolbarBrushEx(ABarControl: TdxBarControl): HBRUSH; override; class function BarToolbarDownedBrush(ABarControl: TCustomdxBarControl): HBRUSH; override; class function BarToolbarDownedSelBrush(ABarControl: TCustomdxBarControl): HBRUSH; override; class function BarToolbarSelBrush(ABarControl: TCustomdxBarControl): HBRUSH; override; class procedure GetEditTextVerticalOffsets(out ATop, ABottom: Integer); override; // Bar class function BarAllowHotTrack: Boolean; override; class function BarAllowQuickCustomizing: Boolean; override; class function BarBeginGroupSideSize: Integer; override; class function BarBeginGroupSize: Integer; override; procedure BarDrawBeginGroup(ABarControl: TCustomdxBarControl; DC: HDC; ABeginGroupRect: TRect; AToolbarBrush: HBRUSH; AHorz: Boolean); override; class procedure BarDrawCloseButton(ABarControl: TdxBarControl; DC: HDC; R: TRect); override; procedure BarDrawDockedBarBorder(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); override; class procedure BarDrawFloatingBarBorder(ABarControl: TdxBarControl; DC: HDC; var R, CR: TRect; AToolbarBrush: HBRUSH); override; procedure BarDrawMark(ABarControl: TdxBarControl; DC: HDC; MarkR: TRect); override; class procedure BarDrawMDIButton(ABarControl: TdxBarControl; AButton: TdxBarMDIButton; ASelected, APressed: Boolean; DC: HDC; R: TRect); override; function BarMarkItemRect(ABarControl: TdxBarControl): TRect; override; // QuickCustItem class function BarToolbarBrushEx2(ABarControl: TdxBarControl): HBRUSH; override; class procedure DrawQuickCustItemFrame(ABarItemControl: TdxBarItemControl; DC: HDC; var R, ARect: TRect; Selected: Boolean); override; class procedure DrawQuickCustItemFrameSelected(ABarItemControl: TdxBarItemControl; DC: HDC; WholeR, R: TRect; Selected: Boolean); override; class function IsQuickControlPopupOnRight: Boolean; override; // ButtonControl class procedure CorrectButtonControlDefaultHeight(var DefaultHeight: Integer); override; class procedure CorrectButtonControlDefaultWidth(var DefaultWidth: Integer); override; procedure DrawButtonControlArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; R1: TRect; ABrush: HBRUSH); override; class function IsDropDownRepaintNeeded: Boolean; override; // ComboControl class procedure ComboControlDrawSimpleButton(ABarComboControl: TdxBarItemControl; ADC: HDC; var ARect: TRect; ADroppedDown, ASelected: Boolean; ABrush: HBRUSH; APaintType: TdxBarPaintType); override; class procedure ComboControlGetArrowParams(const ADrawParams: TdxBarEditLikeControlDrawParams; out ABrush: HBRUSH; out AArrowColor: COLORREF); override; // DropDownListBox class function DropDownListBoxBorderSize: Integer; override; // SubMenuControl class function SubMenuControlArrowsOffset: Integer; override; class function SubMenuControlBeginGroupRect( ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; const AItemRect: TRect): TRect; override; class function SubMenuControlBeginGroupSize: Integer; override; class function SubMenuControlClientBorderSize: Integer; override; class procedure SubMenuControlCalcDrawingConsts(ACanvas: TcxCanvas; ATextSize: Integer; out AMenuArrowWidth, AMarkSize: Integer); override; class function SubMenuControlDetachCaptionAreaSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; override; procedure SubMenuControlDrawBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); override; class procedure SubMenuControlDrawClientBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; const R: TRect; ABrush: HBRUSH); override; procedure SubMenuControlDrawDetachCaption(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); override; procedure SubMenuControlDrawBeginGroup(ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; ACanvas: TcxCanvas; const ABeginGroupRect: TRect); override; procedure SubMenuControlDrawSeparator(ACanvas: TcxCanvas; const ARect: TRect); override; class function SubMenuControlGetSeparatorColor: TColor; virtual; class function SubMenuControlMarkArrowSize(AMarkSize: Integer): Integer; override; class function SubMenuControlNormalItemHeight: Integer; override; class procedure SubMenuControlOffsetDetachCaptionRect(ABarSubMenuControl: TdxBarSubMenuControl; var R: TRect); override; class procedure SubMenuControlPrepareBkBrush(ABarSubMenuControl: TdxBarSubMenuControl; var ABkBrush: HBRUSH); override; class function SubMenuControlTextSize(ACanvas: TcxCanvas): Integer; override; class function SubMenuControlToolbarItemsBrush(ABarSubMenuControl: TdxBarSubMenuControl): HBRUSH; override; // CustomCombo class procedure CustomComboDrawItem(ABarCustomCombo: TdxBarCustomCombo; ACanvas: TCanvas; AIndex: Integer; ARect: TRect; AState: TOwnerDrawState; AInteriorIsDrawing: Boolean); override; // EditControl class function EditControlBorderOffsets: TRect; override; procedure EditControlDrawBorder(const ADrawParams: TdxBarEditLikeControlDrawParams; var ARect: TRect); override; procedure EditControlDrawSelectionFrame(const ADrawParams: TdxBarEditLikeControlDrawParams; const ARect: TRect); override; class function EditControlCaptionRightIndentIsOpaque(const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; override; procedure EditControlDrawTextField(ABarEditControl: TdxBarEditControl; DC: HDC; const ARect: TRect; AIgnoreEnabled: Boolean); override; class function EditControlES_Style: Integer; override; // Select EditControl indents class function EditControlCaptionIconRelativeLeftIndent(const ADrawParams: TdxBarEditLikeControlDrawParams): Integer; override; class function EditControlCaptionLeftIndent(const ADrawParams: TdxBarEditLikeControlDrawParams): Integer; override; class function EditControlCaptionRightIndent: Integer; override; class function EditControlSubmenuGlyphIndents(const ADrawParams: TdxBarEditLikeControlDrawParams): TRect; override; class function EditControlGetRightCaptionIndentBrush(ABarEditControl: TdxBarCustomEditControl): HBRUSH; override; class function EditControlGlyphIsDrawSelected(ABarEditControl: TdxBarCustomEditControl): Boolean; override; class procedure EditControlPrepareEditWnd(ABarEditControl: TdxBarEditControl; AHandle: HWND); override; class procedure EditControlUpdateWndText(ABarEditControl: TdxBarEditControl; AHandle: HWND; ANotEqual: Boolean); override; class function HasEditControlExternalFrame(APaintType: TdxBarPaintType; ASelected: Boolean): Boolean; override; // SysPanel class procedure SysPanelDraw(AHandle: HWND; AllowResizing, MouseAboveCloseButton, CloseButtonIsTracking: Boolean; var CloseButtonRect, GripRect: TRect; Corner: TdxCorner); override; // DateNavigator class function IsDateNavigatorFlat: Boolean; override; class procedure DateNavigatorDrawButton(ABarItem: TdxBarItem; DC: HDC; R: TRect; const ACaption: string; APressed: Boolean); override; // SpinEditControl procedure SpinEditControlDrawButton(const ADrawParams: TdxBarSpinEditDrawParams; ARect: TRect; AButtonIndex: Integer); override; // ContainerControl class function ContainerControlSubMenuOffset: Integer; override; // InPlaceSubItemControl function InPlaceSubItemControlIsFlatItemText(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams): Boolean; override; function InPlaceSubItemControlIsArrowSelected(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams): Boolean; override; end; TdxBarOffice11Painter = class(TdxBarFlatPainter) protected // Common class procedure DrawGlyphBorder(ABarItemControl: TdxBarItemControl; DC: HDC; ABrush: HBRUSH; NeedBorder: Boolean; R: TRect; PaintType: TdxBarPaintType; IsGlyphEmpty, Selected, Down, DrawDowned, ADroppedDown, IsSplit: Boolean); override; class procedure DrawGlyphImage(ABarItemControl: TdxBarItemControl; DC: HDC; ABrush: HBRUSH; NeedBorder: Boolean; R: TRect; const GlyphRect: TRect; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; Selected, Down, DrawDowned, ForceUseBkBrush, GrayScale, BarControlOwner: Boolean; PaintType: TdxBarPaintType); override; class procedure DrawItemArrow(DC: HDC; R: TRect; ArrowType: TcxArrowDirection; Enabled, Selected, Flat: Boolean); override; procedure DrawLargeItemArrow(DC: HDC; R: TRect; ArrowType: TcxArrowDirection; Size: Integer; Selected, Enabled, Flat: Boolean); override; class procedure DrawFrameRect(ABarItemControl: TdxBarItemControl; ADC: HDC; const ARect: TRect; ABrush: HBRUSH; APaintType: TdxBarPaintType; ASelected, ADowned: Boolean); override; class procedure FrameFlatSelRect(DC: HDC; const R: TRect); override; class function GetBarGradientRect(ABarControl: TCustomdxBarControl): TRect; class procedure GetDockColors(ADockControl: TdxDockControl; var AColor1, AColor2: TColor); class procedure GetMarkColors(ABarControl: TdxBarControl; var AMarkColor1, AMarkColor2, AColor6, AColor9: TColor); class procedure GetSelectedColors(ABarItemControl: TdxBarItemControl; ADown, ASelected: Boolean; var AColor1, AColor2: TColor); class function GetToolbarBrush(ABarItemControl: TdxBarItemControl): HBRUSH; override; function GetDefaultEnabledTextColor(ABarItemControl: TdxBarItemControl; ASelected, AFlat: Boolean): TColor; override; procedure GetDisabledTextColors(ABarItemControl: TdxBarItemControl; ASelected, AFlat: Boolean; var AColor1, AColor2: TColor); override; class function GetFaded(ABarControl: TCustomdxBarControl): Boolean; override; class function IgnoreNonRecentColor: Boolean; override; class function IsMenuGradient(ABarItemControl: TdxBarItemControl): Boolean; class function IsSimpleMark(ABarControl: TdxBarControl): Boolean; // Bar class function BarCaptionBkColor(ABarControl: TdxBarControl; AMainFormActive: Boolean): COLORREF; override; class function BarCaptionColor(ABarControl: TdxBarControl): COLORREF; override; class function BarMarkArrowColor(ABarControl: TdxBarControl; AState: TdxBarMarkState): COLORREF; override; class procedure BarDrawFingerElements(ABarControl: TCustomdxBarControl; DC: HDC; ARect: TRect; AHorizontal: Boolean); virtual; procedure BarDrawMarkBackground(ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect; AToolbarBrush: HBRUSH); override; procedure BarDrawMarkElements(ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect); override; // SubMenuControl procedure SubMenuControlDrawMark(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect; ASelected: Boolean); override; function SubMenuControlGetMarkRect(const ADrawRect: TRect): TRect; // ComboControl class procedure ComboControlDrawOneArrow(ABarItemControl: TdxBarItemControl; DC: HDC; X, Y, Size: Integer; Color: COLORREF); override; public // Common procedure DrawGlyphAndTextInSubMenu(const ADrawParams: TdxBarButtonLikeControlDrawParams; var R: TRect); override; class procedure FrameAndFillRect(ABarItemControl: TdxBarItemControl; DC: HDC; var R: TRect; Enabled, Selected, Pressed: Boolean); override; class procedure GetArrowParams(const ADrawParams: TdxBarItemControlDrawParams; out ABrush: HBRUSH; out AArrowColor: COLORREF); override; class function IsItemTextSelectedInverted: Boolean; override; class function StaticBorderBrush(ABarItemControl: TdxBarItemControl; ABorderStyle: TdxBarStaticBorderStyle): HBRUSH; override; // BarManager class function BeforeFingersSize: Integer; override; class function BorderSizeX: Integer; override; class function BorderSizeY: Integer; override; class function EmptyFingersSize: Integer; override; // DockControl class procedure DockControlFillBackground(ADockControl: TdxDockControl; DC: HDC; ADestR, ASourceR, AWholeR: TRect; ABrush: HBRUSH; AColor: TColor); override; class function IsNativeBackground: Boolean; override; // CustomBar class function BarControlOwnerBrush(ABarManager: TdxBarManager): HBRUSH; override; class procedure BarDrawBarControlOwnerFrame(ACustomBarControl: TCustomdxBarControl; DC: HDC; R: TRect); override; class procedure BarDrawBarControlOwnerLink(ACustomBarControl: TCustomdxBarControl; DC: HDC; R, ALinkR: TRect; ABarItemControl: TdxBarItemControl); override; procedure BarDrawDockedBackground(ABarControl: TdxBarControl; DC: HDC; ADestR, ASourceR: TRect; ABrush: HBRUSH; AColor: TColor); override; class procedure BarDrawFloatingBackground(ABarControl: TCustomdxBarControl; DC: HDC; ADestR, ASourceR: TRect; ABrush: HBRUSH; AColor: TColor); override; class procedure BarDrawOwnerLink(ABarControl: TCustomdxBarControl; DC: HDC); override; class function BarHasShadow(ABarControl: TCustomdxBarControl): Boolean; override; class function BarToolbarBrush(ABarControl: TCustomdxBarControl): HBRUSH; override; class function BarToolbarBrushEx(ABarControl: TdxBarControl): HBRUSH; override; class function BarToolbarDownedBrush(ABarControl: TCustomdxBarControl): HBRUSH; override; class function BarToolbarDownedSelBrush(ABarControl: TCustomdxBarControl): HBRUSH; override; class function BarToolbarSelBrush(ABarControl: TCustomdxBarControl): HBRUSH; override; class function ComboBoxArrowWidth(ABarControl: TCustomdxBarControl; cX: Integer): Integer; override; // Bar class function BarBeforeFingersIndent: Integer; virtual; class procedure BarBorderPaintSizes(ABarControl: TdxBarControl; var R: TRect); override; class procedure BarBorderSizes(ABar: TdxBar; AStyle: TdxBarDockingStyle; var R: TRect); override; procedure BarDrawBeginGroup(ABarControl: TCustomdxBarControl; DC: HDC; ABeginGroupRect: TRect; AToolbarBrush: HBRUSH; AHorz: Boolean); override; class procedure BarDrawCaptionElement(ABarControl: TdxBarControl; DC: HDC; R: TRect; AState: TdxBarMarkState); override; procedure BarDrawDockedBarBorder(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); override; class procedure BarDrawFloatingBarBorder(ABarControl: TdxBarControl; DC: HDC; var R, CR: TRect; AToolbarBrush: HBRUSH); override; class procedure BarDrawFloatingBarCaption(ABarControl: TdxBarControl; DC: HDC; var R, CR: TRect; AToolbarBrush: HBRUSH); override; class procedure BarDrawStatusBarGrip(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); override; class procedure BarDrawStatusBarTopBorder(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); override; function BarMarkRect(ABarControl: TdxBarControl): TRect; override; procedure BarMarkRectInvalidate(ABarControl: TdxBarControl); override; class procedure StatusBarFillBackground(ABarControl: TdxBarControl; DC: HDC; ADestR, ASourceR, AWholeR: TRect; ABrush: HBRUSH; AColor: TColor); override; class function StatusBarGripSize(ABarManager: TdxBarManager): TSize; override; class function StatusBarTopBorderSize(ABarManager: TdxBarManager): Integer; override; // SubMenuControl class function IsSingleMenuBorder(ABarSubMenuControl: TdxBarSubMenuControl): Boolean; class procedure SubMenuControlCalcDrawingConsts(ACanvas: TcxCanvas; ATextSize: Integer; out AMenuArrowWidth, AMarkSize: Integer); override; procedure SubMenuControlDrawBackground(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; ARect: TRect; ABrush: HBRUSH; AColor: TColor); override; class procedure SubMenuControlDrawClientBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; const R: TRect; ABrush: HBRUSH); override; class function SubMenuControlDetachCaptionAreaSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; override; procedure SubMenuControlDrawBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); override; procedure SubMenuControlDrawDetachCaption(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); override; class function SubMenuControlGetSeparatorColor: TColor; override; class procedure SubMenuControlOffsetDetachCaptionRect(ABarSubMenuControl: TdxBarSubMenuControl; var R: TRect); override; class function SubMenuControlToolbarItemsBrush(ABarSubMenuControl: TdxBarSubMenuControl): HBRUSH; override; // DropDownListBox procedure DropDownListBoxDrawBorder(DC: HDC; AColor: TColor; ARect: TRect); override; // QuickCustItem class function BarToolbarBrushEx2(ABarControl: TdxBarControl): HBRUSH; override; class procedure DrawQuickCustItemFrameSelected(ABarItemControl: TdxBarItemControl; DC: HDC; WholeR, R: TRect; Selected: Boolean); override; // EditButton procedure EditButtonDrawBackground(const ADrawParams: TdxBarEditLikeControlDrawParams; AState: Integer; ARect: TRect; ABrush: HBrush); override; class function EditButtonIsCustomBackground(AState: Integer): Boolean; override; // EditControl class function EditControlBorderOffsets: TRect; override; procedure EditControlDrawBorder(const ADrawParams: TdxBarEditLikeControlDrawParams; var ARect: TRect); override; class function EditControlCaptionBackgroundIsOpaque(const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; override; // Select EditControl indents class function EditControlCaptionLeftIndent(const ADrawParams: TdxBarEditLikeControlDrawParams): Integer; override; class function EditControlSubmenuGlyphIndents(const ADrawParams: TdxBarEditLikeControlDrawParams): TRect; override; class function EditControlCaptionRightIndentIsOpaque(const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; override; class function EditControlShowIconDefault(const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; override; // ComboControl class procedure ComboControlDrawSimpleButton(ABarComboControl: TdxBarItemControl; ADC: HDC; var ARect: TRect; ADroppedDown, ASelected: Boolean; ABrush: HBRUSH; APaintType: TdxBarPaintType); override; class procedure ComboControlGetArrowParams(const ADrawParams: TdxBarEditLikeControlDrawParams; out ABrush: HBRUSH; out AArrowColor: COLORREF); override; // ProgressControl class function ProgressControlIndent(const ADrawParams: TdxBarItemControlDrawParams): Integer; override; // DateNavigator class procedure DateNavigatorDrawButton(ABarItem: TdxBarItem; DC: HDC; R: TRect; const ACaption: string; APressed: Boolean); override; function DateNavigatorHeaderColor: TColor; override; // InPlaceSubItemControl class function InPlaceSubItemControlBrush: HBRUSH; override; // Edit function EditGetDisabledBkColor(ABarItemControl: TdxBarCustomEditControl): COLORREF; override; function EditGetEnabledTextColor: COLORREF; override; function EditGetDisabledTextColor: COLORREF; override; // Separator procedure DrawSeparatorGlyphAndCaption(const ADrawParams: TdxBarSeparatorControlDrawParams; const ARect: TRect); override; end; TdxBarXPPainter = class(TdxBarPainter) private procedure BarBeginGroupSizeInit; procedure BarCloseButtonSizeInit; procedure ButtonBorderHeightInit; procedure ComboBoxArrowWidthInit; procedure EditControlBorderOffsetsInit; procedure GripperSizeInit; procedure InitParams; procedure ProgressControlBarHeightInit; procedure StatusBarGripSizeInit; procedure SubMenuControlBeginGroupSizeInit; protected // Common class procedure DrawGlyphBorder(ABarItemControl: TdxBarItemControl; DC: HDC; ABrush: HBRUSH; NeedBorder: Boolean; R: TRect; PaintType: TdxBarPaintType; IsGlyphEmpty, Selected, Down, DrawDowned, ADroppedDown, IsSplit: Boolean); override; class procedure DrawGlyphCheckMark(ABarItemControl: TdxBarItemControl; DC: HDC; X, Y, DoubleSize: Integer); override; class procedure DrawGlyphImage(ABarItemControl: TdxBarItemControl; DC: HDC; ABrush: HBRUSH; NeedBorder: Boolean; R: TRect; const GlyphRect: TRect; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; Selected, Down, DrawDowned, ForceUseBkBrush, GrayScale, BarControlOwner: Boolean; PaintType: TdxBarPaintType); override; class function GetFaded(ABarControl: TCustomdxBarControl): Boolean; override; class function IsArrowButtonDowned(APaintStyle: TdxBarPaintType; AIsPressed: Boolean): Boolean; override; class function IsMenuItem(ABarItemControl: TdxBarItemControl): Boolean; override; // Bar class procedure BarDrawGrip(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); override; procedure BarDrawMarkBackground(ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect; AToolbarBrush: HBRUSH); override; class procedure BarOffsetFloatingBarCaption(ABarControl: TdxBarControl; var X: Integer; var R: TRect); override; // ColorCombo procedure DrawDot(const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); override; function GetDotSpaceAfter(ADotWidth: Integer): Integer; override; // Edit class procedure EditOffsetInteriorRect(var R: TRect); override; public constructor Create(AData: Integer); override; // Common procedure DrawGlyphAndTextInSubMenu(const ADrawParams: TdxBarButtonLikeControlDrawParams; var R: TRect); override; class procedure DrawLowered(DC: HDC; var R: TRect); override; class procedure GetCaptionParams(out AOffsets: TRect; out AHeightCorrection: Integer); override; class function GlyphBkgndBrush(ABarItemControl: TdxBarItemControl; APaintType: TdxBarPaintType; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AForceUseBkBrush, AGrayScale: Boolean): HBRUSH; override; class function GlyphDownShift(ABarItemControl: TdxBarItemControl): Integer; override; class function GlyphDrawDownedShift(ABarItemControl: TdxBarItemControl; ADown: Boolean): Integer; override; // BarManager class function BeforeFingersSize: Integer; override; class function FingersSize: Integer; override; class function GripperSize: Integer; override; class function RealButtonArrowWidth(ABarManager: TdxBarManager): Integer; override; class function RealLargeButtonArrowWidth(ABarManager: TdxBarManager): Integer; override; // DockControl class procedure DockControlFillBackground(ADockControl: TdxDockControl; DC: HDC; ADestR, ASourceR, AWholeR: TRect; ABrush: HBRUSH; AColor: TColor); override; class function IsNativeBackground: Boolean; override; // CustomBar // class function BarChildrenHaveShadows(ABarControl: TCustomdxBarControl): Boolean; override; class function BarHasShadow(ABarControl: TCustomdxBarControl): Boolean; override; class function BarToolbarBrush(ABarControl: TCustomdxBarControl): HBRUSH; override; class function BarToolbarBrushEx(ABarControl: TdxBarControl): HBRUSH; override; class function BarToolbarDownedBrush(ABarControl: TCustomdxBarControl): HBRUSH; override; class function BarToolbarDownedSelBrush(ABarControl: TCustomdxBarControl): HBRUSH; override; class function BarToolbarSelBrush(ABarControl: TCustomdxBarControl): HBRUSH; override; class function ComboBoxArrowWidth(ABarControl: TCustomdxBarControl; cX: Integer): Integer; override; class procedure GetEditTextVerticalOffsets(out ATop, ABottom: Integer); override; // Bar class function BarAllowHotTrack: Boolean; override; class function BarAllowQuickCustomizing: Boolean; override; class function BarBeginGroupSideSize: Integer; override; class function BarBeginGroupSize: Integer; override; class function BarBorderSize: Integer; override; class procedure BarCaptionFillBackground(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); override; // class function BarCaptionSize: Integer; override; class function BarCaptionTransparent: Boolean; override; class function BarCloseButtonSize: TSize; override; procedure BarDrawBeginGroup(ABarControl: TCustomdxBarControl; DC: HDC; ABeginGroupRect: TRect; AToolbarBrush: HBRUSH; AHorz: Boolean); override; class procedure BarDrawCloseButton(ABarControl: TdxBarControl; DC: HDC; R: TRect); override; procedure BarDrawDockedBarBorder(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); override; class procedure BarDrawFloatingBarBorder(ABarControl: TdxBarControl; DC: HDC; var R, CR: TRect; AToolbarBrush: HBRUSH); override; class procedure BarDrawMDIButton(ABarControl: TdxBarControl; AButton: TdxBarMDIButton; ASelected, APressed: Boolean; DC: HDC; R: TRect); override; function BarMarkItemRect(ABarControl: TdxBarControl): TRect; override; class procedure StatusBarFillBackground(ABarControl: TdxBarControl; DC: HDC; ADestR, ASourceR, AWholeR: TRect; ABrush: HBRUSH; AColor: TColor); override; class function StatusBarGripSize(ABarManager: TdxBarManager): TSize; override; // QuickCustItem class function IsQuickControlPopupOnRight: Boolean; override; // ButtonControl function GetButtonBorderHeight: Integer; override; function GetButtonBorderWidth: Integer; override; class procedure CorrectButtonControlDefaultHeight(var DefaultHeight: Integer); override; procedure DrawButtonControlArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; R1: TRect; ABrush: HBRUSH); override; class procedure OffsetCaptionBounds(ADown, APressed: Boolean; var R: TRect); override; class procedure OffsetEllipsisBounds(APressed: Boolean; var R: TRect); override; // EditControl class function EditControlBorderOffsets: TRect; override; procedure EditControlDrawBorder(const ADrawParams: TdxBarEditLikeControlDrawParams; var ARect: TRect); override; class function EditControlCaptionRightIndentIsOpaque(const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; override; procedure EditControlDrawTextField(ABarEditControl: TdxBarEditControl; DC: HDC; const ARect: TRect; AIgnoreEnabled: Boolean); override; class function EditControlES_Style: Integer; override; // Select EditControl indents class function EditControlCaptionLeftIndent(const ADrawParams: TdxBarEditLikeControlDrawParams): Integer; override; class function EditControlCaptionRightIndent: Integer; override; class function EditControlSubmenuGlyphIndents(const ADrawParams: TdxBarEditLikeControlDrawParams): TRect; override; class function EditControlGetRightCaptionIndentBrush(ABarEditControl: TdxBarCustomEditControl): HBRUSH; override; class procedure EditControlPrepareEditWnd(ABarEditControl: TdxBarEditControl; AHandle: HWND); override; class procedure EditControlUpdateWndText(ABarEditControl: TdxBarEditControl; AHandle: HWND; ANotEqual: Boolean); override; // CustomCombo class procedure CustomComboDrawItem(ABarCustomCombo: TdxBarCustomCombo; ACanvas: TCanvas; AIndex: Integer; ARect: TRect; AState: TOwnerDrawState; AInteriorIsDrawing: Boolean); override; // ComboControl class function ComboControlArrowOffset: Integer; override; procedure ComboControlDrawArrowButton(const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); override; // SubMenuControl class function SubMenuControlArrowsOffset: Integer; override; class function SubMenuControlBeginGroupRect( ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; const AItemRect: TRect): TRect; override; class function SubMenuControlBeginGroupSize: Integer; override; class function SubMenuControlClientBorderSize: Integer; override; class function SubMenuControlDetachCaptionAreaSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; override; procedure SubMenuControlDrawBeginGroup(ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; ACanvas: TcxCanvas; const ABeginGroupRect: TRect); override; procedure SubMenuControlDrawSeparator(ACanvas: TcxCanvas; const ARect: TRect); override; procedure SubMenuControlDrawBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); override; class procedure SubMenuControlDrawClientBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; const R: TRect; ABrush: HBRUSH); override; class procedure SubMenuControlOffsetDetachCaptionRect(ABarSubMenuControl: TdxBarSubMenuControl; var R: TRect); override; class procedure SubMenuControlPrepareBkBrush(ABarSubMenuControl: TdxBarSubMenuControl; var ABkBrush: HBRUSH); override; class function SubMenuControlToolbarItemsBrush(ABarSubMenuControl: TdxBarSubMenuControl): HBRUSH; override; // DropDownListBox class function DropDownListBoxBorderSize: Integer; override; // ColorCombo procedure ColorComboDrawCustomButton(const ADrawParams: TdxBarColorComboControlDrawParams; ARect: TRect); override; procedure ColorComboDrawCustomButtonAdjacentZone(const ADrawParams: TdxBarColorComboControlDrawParams; ARect: TRect); override; function GetCustomColorButtonIndents(const ADrawParams: TdxBarColorComboControlDrawParams): TRect; override; // DateNavigator class function IsDateNavigatorFlat: Boolean; override; class procedure DateNavigatorDrawButton(ABarItem: TdxBarItem; DC: HDC; R: TRect; const ACaption: string; APressed: Boolean); override; // SysPanel class procedure SysPanelDraw(AHandle: HWND; AllowResizing, MouseAboveCloseButton, CloseButtonIsTracking: Boolean; var CloseButtonRect, GripRect: TRect; Corner: TdxCorner); override; class function SysPanelSize: Integer; override; // SpinEditControl procedure SpinEditControlDrawButton(const ADrawParams: TdxBarSpinEditDrawParams; ARect: TRect; AButtonIndex: Integer); override; function GetSpinEditButtonIndents: TRect; override; // ProgressControl class function ProgressControlBarBrushColor: TColorRef; override; class function ProgressControlBarHeight(ABarItemControl: TdxBarItemControl): Integer; override; procedure ProgressControlDrawBar(const ADrawParams: TdxbarProgressControlDrawParams; BarR: TRect; ABarBrushColor: TColorRef); override; // Edit function EditGetEnabledBkColor(ABarItemControl: TdxBarCustomEditControl): COLORREF; override; function EditGetDisabledBkColor(ABarItemControl: TdxBarCustomEditControl): COLORREF; override; function EditGetEnabledTextColor: COLORREF; override; function EditGetDisabledTextColor: COLORREF; override; // Separator function SubMenuGetSeparatorSize: Integer; override; end; TdxBarSkinnedPainter = class(TdxBarOffice11Painter) private FSkinnedObject: TObject; function GetSkin: IdxSkin; procedure DrawButtonBackground(const ADrawParams: TdxBarButtonLikeControlDrawParams); function GetArrowRect(const ADrawParams: TdxBarButtonLikeControlDrawParams; const ARect: TRect): TRect; class function GetTextInsteadArrow(const ADrawParams: TdxBarItemControlDrawParams): string; class function GetMaxLineCount: Integer; procedure InternalDrawBeginGroup(DC: HDC; const ABeginGroupRect: TRect; AHorz: Boolean; AColor1, AColor2: TColor); procedure InternalDrawEditButton(const ADrawParams: TdxBarEditLikeControlDrawParams; APartIndex: Integer; ARect: TRect); protected procedure CorrectCaptionParams(const ADrawParams: TdxBarButtonLikeControlDrawParams; var ATextBounds: TRect; const AImageBounds: TRect; out ATextAlignment: DWORD); override; // Common procedure BarDrawMarkElements(ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect); override; procedure DrawToolbarContentPart(ABarControl: TdxBarControl; ACanvas: TcxCanvas); override; procedure DrawToolbarNonContentPart(ABarControl: TdxBarControl; DC: HDC); override; class function GetControlTextIndents: TRect; override; class function GetControlCaptionRect(const ADrawParams: TdxBarItemControlDrawParams): TRect; override; function GetDefaultEnabledTextColor(ABarItemControl: TdxBarItemControl; ASelected, AFlat: Boolean): TColor; override; function GetEnabledTextColor(ABarItemControl: TdxBarItemControl; ASelected, AFlat: Boolean): TColor; override; procedure GetDisabledTextColors(ABarItemControl: TdxBarItemControl; ASelected, AFlat: Boolean; var AColor1, AColor2: TColor); override; function GetToolbarCaptionRect(const ARect: TRect): TRect; override; procedure InflateSizeForArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; var ASize: Integer); override; class function IsCompoundPainting: Boolean; override; class function GetButtonPartState(const ADrawParams: TdxBarButtonLikeControlDrawParams; AControlPart: Integer): Integer; class function GetEditPartState(const ADrawParams: TdxBarEditLikeControlDrawParams; AControlPart: Integer): Integer; class function GetSpinEditPartState(const ADrawParams: TdxBarSpinEditDrawParams; AControlPart: Integer): Integer; class function GetPartState(const ADrawParams: TdxBarItemControlDrawParams; AControlPart: Integer; AForbiddenParts: TdxByteSet = []): Integer; function GetBarControlState(ABarControl: TdxBarControl): Integer; //Hints class function GetBarItemContolHintPosition(ABarControl: TCustomdxBarControl; const AItemBounds: TRect; const ACursorPos: TPoint; AHeight: Integer): TPoint; override; function CreateHintViewInfo(ABarManager: TdxBarManager; AHintText: string; const AShortCut: string; AScreenTip: TdxBarScreenTip): TdxBarCustomHintViewInfo; override; // ButtonLikeControl procedure ButtonLikeControlDoDrawCaption(const ADrawParams: TdxBarButtonLikeControlDrawParams; const ATextBounds: TRect; ATextAlignment: DWORD); override; procedure ButtonLikeControlDrawMenuArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; ADirection: TcxArrowDirection; ARect: TRect); // SpinEditControl procedure DrawSpinEditArrow(const ADrawParams: TdxBarSpinEditDrawParams; AArrowPos: TPoint; AButtonIndex: Integer); override; // SubMenuControl procedure SubMenuControlDrawMark(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect; ASelected: Boolean); override; procedure SubMenuControlDrawMarkSelection(ABarSubMenuControl: TdxBarSubMenuControl; ADC: HDC; const AMarkRect: TRect); override; procedure SubMenuControlFillScrollArrow(ACanvas: TcxCanvas; ARect: TRect; AColor: TColor); override; function SubMenuControlGetScrollBandSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; override; class function SubMenuControlGetScrollArrowSize(ATextSize: Integer): Integer; override; class function SubMenuControlUseScrollButtons: Boolean; override; property Skin: IdxSkin read GetSkin; public constructor Create(AData: Integer); override; procedure CalculateButtonParts(const ADrawParams: TdxBarButtonLikeControlDrawParams; var AParts: array of TRect; const AItemRect: TRect); override; procedure CalculateSpinEditParts(const ADrawParams: TdxBarEditLikeControlDrawParams; var AParts: array of TRect; const AItemRect: TRect); override; procedure DrawArrow(ADC: HDC; ARect: TRect; AArrowState: Integer); // Common // Sizes function GetBorderSize: Integer; override; function GetIconAreaSize(ABarControl: TCustomdxBarControl): Integer; override; class function GetDefaultTextSize(ACanvas: TcxCanvas): Integer; override; function GetLargeImageBounds(AItemControl: TdxBarItemControl; const AImageSize: TSize; const ADrawRect: TRect; APaintType: TdxBarPaintType; AViewStructure: TdxBarItemControlViewStructure; AGlyphLayout: TdxBarGlyphLayout): TRect; override; // Draw class procedure DrawBackground(ABarItemControl: TdxBarItemControl; DC: HDC; const R: TRect; ABrush: HBRUSH; AOpaque: Boolean); override; procedure DrawItemBackgroundInSubMenu(const ADrawParams: TdxBarButtonLikeControlDrawParams; var R: TRect); procedure DrawGlyphAndBkgnd(ABarItemControl: TdxBarItemControl; ADC: HDC; R: TRect; const AGlyphRect: TRect; APaintType: TdxBarPaintType; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AForceUseBkBrush, AGrayScale, AIsSplit: Boolean); override; procedure DrawGlyphAndTextInSubMenu(const ADrawParams: TdxBarButtonLikeControlDrawParams; var R: TRect); override; class function GetSubMenuItemTextIndent(const ADrawParams: TdxBarItemControlDrawParams): Integer; override; function GetToolbarContentOffsets(ABar: TdxBar; ADockingStyle: TdxBarDockingStyle; AHasSizeGrip: Boolean): TRect; override; function GetToolbarsOffsetForAutoAlign: Integer; override; class function RealButtonArrowWidth(ABarManager: TdxBarManager): Integer; override; class function LoweredBorderSize(ABarItemControl: TdxBarItemControl): Integer; override; // CustomBar procedure BarDrawBackground(ABarControl: TdxBarControl; ADC: HDC; const ADestRect, ASourceRect: TRect; ABrush: HBRUSH; AColor: TColor); override; procedure BarDrawDockedBackground(ABarControl: TdxBarControl; DC: HDC; ADestR, ASourceR: TRect; ABrush: HBRUSH; AColor: TColor); override; class function ComboBoxArrowWidth(ABarControl: TCustomdxBarControl; cX: Integer): Integer; override; class procedure SetWindowRgn(AHandle: THandle; const AWindowRect: TRect; ARedraw: Boolean = False); override; // Bar procedure BarDrawBeginGroup(ABarControl: TCustomdxBarControl; DC: HDC; ABeginGroupRect: TRect; AToolbarBrush: HBRUSH; AHorz: Boolean); override; // BarItemControl // Sizes class function GetTailAreaSize(const ADrawParams: TdxBarItemControlDrawParams): Integer; override; // ButtonControl // Sizes class function GetDefaultArrowSignSize: TSize; override; function GetButtonBorderHeight: Integer; override; function GetButtonBorderWidth: Integer; override; function GetButtonHeight(AIconSize, ATextSize: Integer): Integer; override; function GetButtonWidth(AIconSize, ATextSize: Integer): Integer; override; class procedure CorrectButtonControlDefaultHeight(var DefaultHeight: Integer); override; // Draw procedure DrawButtonLikeControl(const ADrawParams: TdxBarButtonLikeControlDrawParams; ARect: TRect); override; procedure DrawButtonControlArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; R1: TRect; ABrush: HBRUSH); override; procedure DrawSplitControlArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; ARect: TRect); override; procedure DrawAssociateControlArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; ARect: TRect); override; // DropDownListBox procedure DropDownListBoxDrawBorder(DC: HDC; AColor: TColor; ARect: TRect); override; // SubMenuControl // Sizes class function SubMenuControlArrowWidth(ATextSize: Integer): Integer; override; class function SubMenuControlBeginGroupSize: Integer; override; class function SubMenuControlDetachCaptionAreaSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; override; class function SubMenuControlGetBandSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; override; class function SubMenuControlNormalItemHeight: Integer; override; class function SubMenuControlTextIndent: Integer; class function SubMenuControlInternalBorderSize: Integer; override; class function SubMenuControlInternalBorderOffset: Integer; override; class function SubMenuControlTextSize(ACanvas: TcxCanvas): Integer; override; // Draw procedure SubMenuControlDrawScrollBandBackground(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; AArrowDirection: TcxArrowDirection); override; procedure SubMenuControlDrawScrollButton(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; AArrowDirection: TcxArrowDirection); override; procedure SubMenuControlDrawBackground(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; ARect: TRect; ABrush: HBRUSH; AColor: TColor); override; procedure SubMenuControlDrawBeginGroup(ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; ACanvas: TcxCanvas; const ABeginGroupRect: TRect); override; procedure SubMenuControlDrawSeparator(ACanvas: TcxCanvas; const ARect: TRect); override; procedure SubMenuControlDrawBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); override; class procedure SubMenuControlDrawClientBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; const R: TRect; ABrush: HBRUSH); override; procedure SubMenuControlDrawDetachCaption(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); override; procedure SubMenuControlDrawItemBackground(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; AItemRect: TRect); // ApplicationMenu // Sizes function ApplicationMenuGetFrameSizes: TRect; override; // Draw procedure ApplicationMenuDrawBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; const ARect: TRect); override; procedure ApplicationMenuDrawButton(const ADrawParams: TdxBarApplicationMenuButtonControlDrawParams; var R: TRect); override; procedure ApplicationMenuDrawContentArea(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; const AContentRect, AItemsArea: TRect); override; // ExtraMenuControl procedure ExtraMenuControlDrawBackground(AExtraMenuControl: TCustomdxBarControl; ACanvas: TcxCanvas; ARect: TRect; ABrush: HBRUSH; AColor: TColor); override; procedure ExtraMenuControlDrawBeginGroup(AExtraMenuControl: TCustomdxBarControl; ACanvas: TcxCanvas; ABeginGroupRect: TRect; AToolbarBrush: HBRUSH; AHorz: Boolean); override; procedure ExtraMenuControlDrawItemBackground(AExtraMenuControl: TCustomdxBarControl; ACanvas: TcxCanvas; AItemRect: TRect); // EditButton function EditButtonAllowOffsetContent: Boolean; override; procedure EditButtonDrawBackground(const ADrawParams: TdxBarEditLikeControlDrawParams; AState: Integer; ARect: TRect; ABrush: HBrush); override; procedure EditButtonDrawBorder(const ADrawParams: TdxBarItemControlDrawParams; AState: Integer; var ADrawRect: TRect; out AContentRect: TRect); override; function EditButtonAllowCompositeFrame: Boolean; override; class function EditButtonAllowHotTrack(const ADrawParams: TdxBarItemControlDrawParams): Boolean; override; class function EditButtonIsCustomBorder: Boolean; override; class function EditButtonIsCustomBackground(AState: Integer): Boolean; override; // EditControl class function EditControlCaptionBackgroundIsOpaque(const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; override; class function EditControlCaptionRightIndentIsOpaque(const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; override; procedure EditControlDrawBorder(const ADrawParams: TdxBarEditLikeControlDrawParams; var ARect: TRect); override; procedure EditControlDrawSelectionFrame(const ADrawParams: TdxBarEditLikeControlDrawParams; const ARect: TRect); override; class function EditGetRealPaintStyle(ABarManager: TdxBarManager): TdxBarManagerStyle; override; function EditGetBkColor(const ADrawParams: TdxBarEditLikeControlDrawParams): COLORREF; override; procedure EditControlDrawGlyph(const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); override; class function EditControlShowIconDefault(const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; override; // ComboControl class function ComboControlArrowOffset: Integer; override; class function ComboControlButtonOffsets: TRect; override; procedure ComboControlDrawArrowButton(const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); override; // ColorCombo procedure ColorComboCorrectFrameRect(const ADrawParams: TdxBarColorComboControlDrawParams; var ARect: TRect); override; procedure ColorComboDrawCustomButton(const ADrawParams: TdxBarColorComboControlDrawParams; ARect: TRect); override; procedure ColorComboDrawCustomButtonAdjacentZone(const ADrawParams: TdxBarColorComboControlDrawParams; ARect: TRect); override; function GetCustomColorButtonIndents(const ADrawParams: TdxBarColorComboControlDrawParams): TRect; override; // DateNavigator function DateNavigatorHeaderColor: TColor; override; // InPlaceSubItemControl //Sizes class function InPlaceSubItemGetArrowWidth(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams): Integer; override; //Draw procedure InPlaceSubItemControlDrawArrow(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams; ADirection: TcxArrowDirection; ARect: TRect); override; procedure InPlaceSubItemControlDrawBackground(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams; ARect: TRect); override; // ProgressControl procedure ProgressControlDrawBackground(const ADrawParams: TdxBarItemControlDrawParams; var R: TRect); override; procedure ProgressControlFillContent(const ADrawParams: TdxBarItemControlDrawParams; const R: TRect; ABarBrush: HBRUSH); override; procedure ProgressControlFillDiscreteContent(const ADrawParams: TdxBarItemControlDrawParams; const R: TRect; ABarBrush: HBRUSH); override; // SpinEditControl function GetSpinEditArrowPos(const ADrawParams: TdxBarSpinEditDrawParams; ARect: TRect; AButtonIndex: Integer): TPoint; override; procedure SpinEditCorrectFrameRect(const ADrawParams: TdxBarItemControlDrawParams; var ARect: TRect); override; function GetSpinEditArrowSize(AHeight: Integer): TSize; override; function GetSpinEditButtonBounds(const ARect: TRect; AButton: TdxBarSpinEditButton): TRect; override; procedure SpinEditControlDrawButton(const ADrawParams: TdxBarSpinEditDrawParams; ARect: TRect; AButtonIndex: Integer); override; procedure SpinEditControlDrawButtonsAdjacentZone(const ADrawParams: TdxBarSpinEditDrawParams; const ARect: TRect); override; procedure SpinEditControlDrawButtonsExternalFrame(const ADrawParams: TdxBarSpinEditDrawParams; ARect: TRect); function GetSpinEditButtonIndents: TRect; override; // Static procedure DrawStaticBorder(const ADrawParams: TdxBarStaticLikeControlDrawParams; var ARect: TRect); override; class function StaticBackgroundIsOpaque(const ADrawParams: TdxBarItemControlDrawParams): Boolean; override; // Separator procedure DrawSeparatorGlyphAndCaption(const ADrawParams: TdxBarSeparatorControlDrawParams; const ARect: TRect); override; property SkinnedObject: TObject read FSkinnedObject; end; TRegItemRecord = class public FItemClass: TdxBarItemClass; FItemControlClass: TdxBarItemControlClass; FVisible: Boolean; constructor Create(AItemClass: TdxBarItemClass; AItemControlClass: TdxBarItemControlClass; AVisible: Boolean); end; TdxBarItemList = class(TList) private function GetItem(Index: Integer): TRegItemRecord; function GetItemClass(Index: Integer): TdxBarItemClass; function GetVisibleItemCount: Integer; function GetVisibleItemClass(Index: Integer): TdxBarItemClass; protected procedure Register(AItemClass: TdxBarItemClass; AItemControlClass: TdxBarItemControlClass; AVisible: Boolean); procedure Unregister(AItemClass: TdxBarItemClass); overload; procedure Unregister(Index: Integer); overload; public destructor Destroy; override; property Items[Index: Integer]: TRegItemRecord read GetItem; default; property ItemClass[Index: Integer]: TdxBarItemClass read GetItemClass; property VisibleItemCount: Integer read GetVisibleItemCount; property VisibleItemClass[Index: Integer]: TdxBarItemClass read GetVisibleItemClass; end; TdxBarManagerFormKind = (fkMain, fkMainOrMDIChild, fkAny); { TdxCustomQuickCustItemControl } TdxCustomQuickCustItemControl = class(TdxBarButtonControl) protected function GetDefaultWidth: Integer; override; function IsDowned: Boolean; virtual; abstract; procedure Paint(ARect: TRect; PaintType: TdxBarPaintType); override; end; { TdxBarQuickCustItem and TdxBarQuickCustItemControl } TdxBarQuickCustItem = class(TdxBarButton) public procedure DoClick; override; end; TdxBarQuickCustItemControl = class(TdxCustomQuickCustItemControl) private function GetLinkedItemLink: TdxBarItemLink; protected procedure ControlUnclick(ByMouse: Boolean); override; function GetCaption: string; override; function GetGlyph: TBitmap; override; function GetImageIndex: Integer; override; function GetImageList(AViewSize: TdxBarItemControlViewSize; AInToolbar: Boolean): TCustomImageList; override; function GetLargeGlyph: TBitmap; override; function GetLargeImageIndex: Integer; override; function IsDowned: Boolean; override; function GetHint: string; override; function GetShortCut: TShortCut; override; function IsDestroyOnClick: Boolean; override; property LinkedItemLink: TdxBarItemLink read GetLinkedItemLink; end; { TdxBarQuickControl } TdxBarQuickControl = class(TdxBarControl) private FHidingTimer: TcxTimer; function GetParentBar: TdxBarControl; procedure QuickControlTimer(Sender: TObject); procedure SetParentBar(Value: TdxBarControl); procedure WMNCHitTest(var Message: TWMNCHitTest); message WM_NCHITTEST; procedure WMNCPaint(var Message: TMessage); message WM_NCPAINT; procedure WMRButtonDown(var Message: TWMRButtonDown); message WM_RBUTTONDOWN; protected function GetParentForm: TCustomForm; override; function GetSizeForPopup: TSize; override; function GetToolbarBrush: HBRUSH; override; function HasCaption: Boolean; override; function IsLinkedToOwner: Boolean; override; function IsPopup: Boolean; override; function LockHotTrackWhenPopup: Boolean; override; function NeedShowGlyphAndCheckForItem: Boolean; override; function GetOwnerControl: TWinControl; override; property ParentBar: TdxBarControl read GetParentBar write SetParentBar; public constructor CreateForPopup(AParentBarControl: TdxBarControl; ABar: TdxBar); override; destructor Destroy; override; function Kind: TdxBarKind; override; procedure Popup(const AOwnerRect: TRect); override; procedure StartHidingTimer; end; TdxBarKeyTipsShowingState = record ActiveContainer: IdxBarAccessibilityHelper; KeyTipsData: TdxObjectList; TypingString: string; end; { TdxBarNavigationController } TdxBarNavigationController = class private FKeyTipsShowingState: TdxBarKeyTipsShowingState; FKeyTipsWaitingRootObject: IdxBarAccessibilityHelper; FKeyTipsWaitingTimer: TcxTimer; FNavigationMode: Boolean; FSelectedObject: IdxBarAccessibilityHelper; FSelectedObjectParent: IdxBarAccessibilityHelper; procedure DestroyKeyTipsWaitingTimer; function GetActiveBarControl: TCustomdxBarControl; function GetKeyTipsHandlingMode: Boolean; function GetSelectedObject: IdxBarAccessibilityHelper; function GetSelectedObjectParent: IdxBarAccessibilityHelper; procedure HandleKeyTipKey(AKey: Word); function IsKeyTipsKey(AKey: Word; out AIsKeyAcceptable: Boolean; out AKeyTipData: TdxBarKeyTipData): Boolean; overload; function IsNavigationControllerKey(AKey: Word): Boolean; procedure KeyTipsEscapeHandler; procedure KeyTipsWaitingTimerHandler(Sender: TObject); procedure StopKeyTipsHandlingMode; protected procedure ResetNavigationMode; public destructor Destroy; override; procedure BeginKeyTipsWaiting(ARootObject: IdxBarAccessibilityHelper); procedure ChangeSelectedObject(ASetFocus: Boolean; ANewSelectedObject: IdxBarAccessibilityHelper; APrevSelectedObject: IdxBarAccessibilityHelper = nil); procedure EndKeyTipsWaiting(AShowKeyTipWindows: Boolean); procedure HandleKey(AKey: Word; ASelectedObjectParent: IdxBarAccessibilityHelper = nil; ASelectedObject: IdxBarAccessibilityHelper = nil); function IsKeyTipsKey(AKey: Word): Boolean; overload; function IsKeyTipsWaiting: Boolean; function IsNavigationKey(AKey: Word): Boolean; function NeedsKey(AKey: Word): Boolean; procedure SelectDefaultObject(ARootObject: IdxBarAccessibilityHelper); procedure SetKeyTipsShowingState( AActiveKeyTipContainer: IdxBarAccessibilityHelper; const AKeyTipsTypingString: string); procedure StopKeyboardHandling; procedure UnassignObject(AObject: IdxBarAccessibilityHelper); procedure UnselectAssignedSelectedObject; property ActiveKeyTipContainer: IdxBarAccessibilityHelper read FKeyTipsShowingState.ActiveContainer; // TODO Remove this property property AssignedSelectedObject: IdxBarAccessibilityHelper read FSelectedObject; property AssignedSelectedObjectParent: IdxBarAccessibilityHelper read FSelectedObjectParent; property KeyTipsHandlingMode: Boolean read GetKeyTipsHandlingMode; property NavigationMode: Boolean read FNavigationMode; property SelectedObject: IdxBarAccessibilityHelper read GetSelectedObject write FSelectedObject; property SelectedObjectParent: IdxBarAccessibilityHelper read GetSelectedObjectParent write FSelectedObjectParent; end; procedure AccessibilityHelperOwnerObjectDestroyed( var AIHelper: IdxBarAccessibilityHelper); function GetAccessibilityHelper(AObject: TObject): IdxBarAccessibilityHelper; function GetKeyTipContainerParent( AContainer: IdxBarAccessibilityHelper): IdxBarAccessibilityHelper; function GetNextAccessibleObject(ASelectedObject: TdxBarAccessibilityHelper; AObjects: TList; ADirection: TcxAccessibilityNavigationDirection; ACycleHorizontally: Boolean): TdxBarAccessibilityHelper; function GetRootAccessibleObject(AParentWnd: HWND): IdxBarAccessibilityHelper; function BarDesignController: TdxBarDesignController; function BarCanvas: TdxBarCanvas; function BarNavigationController: TdxBarNavigationController; function RegdxItemList: TdxBarItemList; procedure dxBarRegisterItem(AItemClass: TdxBarItemClass; AItemControlClass: TdxBarItemControlClass; AVisible: Boolean); procedure dxBarUnregisterItem(AItemClass: TdxBarItemClass); procedure dxBarDesignerModified(ABarManager: TdxBarManager); function dxBarCreateScreenTipViewInfo(ABarManager: TdxBarManager; AHintText: string; const AShortCut: string; AScreenTip: TdxBarScreenTip; ASkin: TObject): TdxBarCustomHintViewInfo; function ActiveBarControl: TCustomdxBarControl; function BarGetMouseWheelReceiver: TdxBarMouseWheelEventReceiver; function VisibleTodxBarVisible(Value: Boolean): TdxBarItemVisible; function GetBarManagerByComponent(AComponent: TComponent): TdxBarManager; function GetBarManagerByForm(AForm: TCustomForm): TdxBarManager; function GetBarManagerForComponent(AComponent: TComponent): TdxBarManager; function GetParentBarForBar(Value: TCustomdxBarControl): TCustomdxBarControl; function GetAccelPos(var AText: string; AModifyString: Boolean = False): Integer; function GetWorkArea(const P: TPoint): TRect; function GetTextOf(const S: string): string; procedure DrawItemArrow(DC: HDC; R: TRect; ArrowType: TcxArrowDirection; Enabled, Selected, Flat: Boolean); overload; procedure DrawItemArrow(ADC: HDC; R: TRect; ADownArrow, AEnabled, ASelected, AFlat: Boolean); overload; procedure DrawLargeItemArrow(DC: HDC; R: TRect; ArrowType: TcxArrowDirection; Size: Integer; Selected, Enabled, Flat: Boolean); overload; procedure DrawLargeItemArrow(ADC: HDC; R: TRect; ADownArrow: Boolean; ASize: Integer; ASelected, AEnabled, AFlat: Boolean); overload; procedure FrameFlatSelRect(DC: HDC; const R: TRect); procedure DrawVerticalGradient(Canvas: TCanvas; const ARect: TRect; FromR, ToR, FromG, ToG, FromB, ToB: Byte); procedure TransparentDraw(DrawDC: HDC; R: TRect; AGlyph: TBitmap; AEnabled: Boolean = True); overload; procedure TransparentDraw(DrawDC: HDC; Brush: HBRUSH; FullRect, R: TRect; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; AImageListBkColor: TColor; AEnabled, AGrayScale, AFlat, ASelected, ADown, APressed, AShadow, AFaded: Boolean; ASmoothImage: Boolean = False; AUseLeftBottomPixelAsTransparent: Boolean = True); overload; procedure TransparentDraw(ABarItemControl: TdxBarItemControl; DrawDC: HDC; Brush: HBRUSH; FullRect, R: TRect; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; AImageListBkColor: TColor; AEnabled, AGrayScale, AFlat, ASelected, ADown, APressed, AShadow, AFaded: Boolean; ASmoothImage: Boolean = False; AUseLeftBottomPixelAsTransparent: Boolean = True); overload; function CloneFont(Source: HFONT): HFONT; procedure FillRectByBitmap(DC: HDC; ADestR, ASourceR: TRect; ABitmap: TBitmap); procedure RestoreClipRgn(DC: HDC; var AClipRgn: HRGN; var AClipRgnExists: Boolean); procedure SaveClipRgn(DC: HDC; var AClipRgn: HRGN; var AClipRgnExists: Boolean); procedure AfterDrawBackground(ADC: HDC; APrevWindowOrg: TPoint); function BeforeDrawBackground(ASourceControl, ADestinationControl: TWinControl; ADC: HDC; var ARect: TRect; out APrevWindowOrg: TPoint): TPoint; procedure ProcessMouseMessages; procedure ProcessPaintMessages; function LeftButtonPressed: Boolean; function RightButtonPressed: Boolean; function IsAncestorComponentDifferencesDetection(AComponent: TComponent): Boolean; function IsApplicationActive: Boolean; function IsFormActive(AForm: TCustomForm): Boolean; function GetParentPopupWindow(AControl: TWinControl; ACheckParentBars: Boolean): TcxCustomPopupWindow; procedure dxFreeAndNil(var AObject); function dxKillTimer(AWindowHandle: HWND; var ATimerID: DWORD): Boolean; function dxBarMessageBox(AText: string; AFlags: Integer): Integer; procedure dxBarFrameRect(ADC: HDC; ARect: TRect; AColor: Integer); procedure dxBarFocusRect(ADC: HDC; ARect: TRect); procedure dxSetZOrder(AHandle: THandle; AWndAfter: DWORD = HWND_TOPMOST; AActivate: Boolean = False; AFlags: DWORD = 0); function HasAsParent(Wnd: HWND; ParentWnd: HWND): Boolean; function HasPopupWindowAbove(ABarControl: TCustomdxBarControl; AIgnoreSelectedControl: Boolean): Boolean; function IsSelectableItem(AObject: TObject): Boolean; function GetSelectableItem(AObject: TObject): IdxBarSelectableItem; procedure CleanSelectableItems(AItems: TdxObjectList); function GetMaxViewLevel(AViewLevels: TdxBarItemViewLevels): TdxBarItemRealViewLevel; function GetMinViewLevel(AViewLevels: TdxBarItemViewLevels): TdxBarItemRealViewLevel; function GetNextViewLevel(AViewLevels: TdxBarItemViewLevels; AViewLevel: TdxBarItemRealViewLevel): TdxBarItemRealViewLevel; function WidthToCurrentDpi(AValue: Integer; ANormalDpi: Integer = 96): Integer; procedure BarDrawSizeGrip(DC: HDC; R: TRect); procedure SetLayeredWndAttributes(AHandle: HWND; AAlphaBlendValue: Integer); type TdxBarGetRootAccessibleObjectFunc = function(AParentWnd: HWND): IdxBarAccessibilityHelper; TdxNotifyEvent = procedure(Sender: TObject); var FOnRegisterBarManager: TdxNotifyEvent; FOnUnregisterBarManager: TdxNotifyEvent; dxBarHintKeeper: IdxBarHintKeeper; dxBarHintWindowClass: TdxBarHintWindowClass = TdxBarHintWindow; dxBarManagerList: TdxBarManagerList; PatternBrush: HBRUSH; dxBarMakeInactiveImagesDingy: Boolean = True; dxBarPlaySound: Boolean = True; FHintWindow: TdxBarHintWindow; dxBarGetRootAccessibleObject: TdxBarGetRootAccessibleObjectFunc; const crdxBarDrag = 1041; crdxBarDragCopy = 1042; crdxBarDragNoDrop = 1043; crdxBarEditSizing = 1044; dxBarManagerTempCategoryIndex = -1000; dxBarCustomizingPopupPaintStyleGroupIndex = -1000; dxBarNonrecentlyUsedItemsColorDelta: Integer = 20; dxBarFlatToolbarsColorDelta: Integer = 20; dxBarWaitForSubMenuTime: Integer = 400; // TdxBarItemControl icpNone = -1; icpNonClient = 100; icpControl = 0; // TdxBarEditControlPart ecpEdit = 0; ecpIcon = 1; ecpText = 2; ecpHeaderParts = [ecpIcon, ecpText, icpNonClient]; // TdxBarComboControlPart ccpDropButton = 3; // TdxBarColorComboControl clcpCustomColorButton = 4; // TdxBarButtonControlPart bcpButton = 0; bcpDropButton = 1; //TdxBarSpinEditControl secButtonUp = 3; secButtonDown = 4; //ScreenTips dxBarScreenTipFontColor: TColor = $4C4C4C; implementation {$R dxBar.res} uses CommCtrl, MMSystem, Registry, Math, {$IFDEF CLR} System.Text, System.Runtime.InteropServices, Types,{$ENDIF} dxBarCustForm, dxBarPopupMenuEd, dxBarStrs, dxBarCommon, dxUxTheme, dxThemeConsts, dxOffice11, dxBarNameEd, cxGeometry, dxBarSkinConsts, dxBarAccessibility; const {$IFNDEF DELPHI6} WS_EX_LAYERED = $00080000; AC_SRC_ALPHA = $01; LWA_ALPHA = $00000002; {$ENDIF} dxBarButtonBorderWidth = 7; dxBarButtonBorderHeight = 6; dxBarFingerSize = 3; dxBarHorSize = 4; dxBarTopSize = 2; dxBarBottomSize = 1; dxBarFlatBorderSize = 3; DefautGlyphSize = 16; InsertZone = 10; MarkSizeArrowY = 4; MarkSizeArrowX = 2 * MarkSizeArrowY - 1; MakeBeginGroupDragSize = 4; MinToolbarSize = 2 + 19 + 2; FloatToolbarMarkIndent = 1; MenuSeparatorSize = 2; HintOffset = 20; MinEditWidth = 20; EditSizingZoneSize = 7; MinDockSize = 3; DetachAreaDelta = 15; dxBarWaitForShowHintTime = 1000; dxBarWaitForHideHintTime = 10000; dxBarHiddedHintLifeTime = 400; dxBarScrollMenuTime = 80; dxBarSmoothScrollMenuTime = dxBarScrollMenuTime + 120; dxBarSlowExpandMenuTime = 4000; dxBarWaitForKeyTipsTime = 500; dxBarExtraPaneHeader = 'Recent Documents'; dxBarExtraPaneWidthRatio = 2.5; MDIButtonStyles: array[TdxBarMDIButton] of Integer = (DFCS_CAPTIONMIN, DFCS_CAPTIONRESTORE, DFCS_CAPTIONCLOSE); ListItemSeparator = '-'; DefaultViewParams: TcxViewParams = ( Bitmap: nil; Color: clDefault; Font: nil; TextColor: clDefault ); type PBoolean = ^Boolean; TStringArray = array of string; TControlAccess = class(TControl); TCustomFormAccess = class(TCustomForm); TReaderAccess = class(TReader); TdxBarXPPainterParams = record BarBeginGroupSize: Integer; BarCloseButtonSize: TSize; ButtonBorderHeight: Integer; ComboBoxArrowWidth: Integer; EditControlBorderOffsets: TRect; GripperSize: Integer; ProgressControlBarHeight: Integer; SubMenuControlBeginGroupSize: Integer; StatusBarGripSize: TSize; end; var FdxBarIsFinalized: Boolean; IsWin95, IsWin95Or98, IsWin98Or2000: Boolean; FApplicationActive: Boolean = True; FApplicationDeactivation: Boolean; FMergingWith: TdxBar; FUser32DLL: HMODULE; FdxBarXPPainterParams: TdxBarXPPainterParams; {$IFDEF CLR} UpdateLayeredWindow: function(Handle: THandle; hdcDest: HDC; const pptDst: TPoint; const _psize: TSize; hdcSrc: HDC; const pptSrc: TPoint; crKey: COLORREF; const pblend: TBLENDFUNCTION; dwFlags: DWORD): Boolean; {$ELSE} UpdateLayeredWindow: function(Handle: THandle; hdcDest: HDC; pptDst: PPoint; _psize: PSize; hdcSrc: HDC; pptSrc: PPoint; crKey: COLORREF; pblend: PBLENDFUNCTION; dwFlags: DWORD): Boolean; stdcall; {$ENDIF} FBarCanvas: TdxBarCanvas; FBarControls: TList; FBarDesignController: TdxBarDesignController; FBarNavigationController: TdxBarNavigationController; FRegdxItemList: TdxBarItemList; FActiveBarControl: TCustomdxBarControl; FIsMDIButtonPressed, FIsMouseOverMDIButton: Boolean; FPressedMDIButton, FSelectedMDIButton: TdxBarMDIButton; ResettingToolbar: Boolean; ShowFullMenus: Boolean; BitsPerPixel: Integer; { blending } type TAnimateWindowProc = function(hWnd: HWND; dwTime: DWORD; dwFlags: DWORD): BOOL; stdcall; TSetLayeredWindowAttributes = function (Hwnd: THandle; crKey: COLORREF; bAlpha: Byte; dwFlags: DWORD): Boolean; stdcall; var AnimateWindowProc: TAnimateWindowProc = nil; SetLayeredWindowAttributes: TSetLayeredWindowAttributes = nil; function GetBarManagerByHandle(AWnd: HWND): TdxBarManager; forward; procedure AccessibilityHelperOwnerObjectDestroyed( var AIHelper: IdxBarAccessibilityHelper); begin if AIHelper <> nil then AIHelper.OwnerObjectDestroyed; AIHelper := nil; end; function GetAccessibilityHelper(AObject: TObject): IdxBarAccessibilityHelper; begin Supports(AObject, IdxBarAccessibilityHelper, Result); end; function GetKeyTipContainerParent( AContainer: IdxBarAccessibilityHelper): IdxBarAccessibilityHelper; var AParentObject: TdxBarAccessibilityHelper; begin Result := nil; AParentObject := AContainer.GetBarHelper; if AParentObject.ParentForKeyTip = nil then Exit; repeat AParentObject := AParentObject.ParentForKeyTip; until AParentObject.IsKeyTipContainer or (AParentObject.ParentForKeyTip = nil); Result := AParentObject; end; function GetNextAccessibleObject(ASelectedObject: TdxBarAccessibilityHelper; AObjects: TList; ADirection: TcxAccessibilityNavigationDirection; ACycleHorizontally: Boolean): TdxBarAccessibilityHelper; procedure CalcRectCenter(const R: TRect; out X, Y: Extended); begin X := R.Left + (R.Right - R.Left) / 2; Y := R.Top + (R.Bottom - R.Top) / 2; end; procedure CalcDistance(const R1, R2: TRect; out AAngle, ADistance: Extended); var AAngle1, AAngle2, X1, X2, Y1, Y2: Extended; begin CalcRectCenter(R1, X1, Y1); CalcRectCenter(R2, X2, Y2); AAngle1 := RadToDeg(ArcTan2(Y2 - Y1, X2 - X1)); if AAngle1 < 0 then AAngle1 := AAngle1 + 360; case ADirection of andLeft: AAngle1 := AAngle1 - 180; andUp: AAngle1 := AAngle1 - 270; andDown: AAngle1 := AAngle1 - 90; end; if AAngle1 < 0 then AAngle2 := AAngle1 + 360 else AAngle2 := AAngle1 - 360; if AAngle1 < 0 then AAngle1 := -AAngle1; if AAngle2 < 0 then AAngle2 := -AAngle2; AAngle := Min(AAngle1, AAngle2); case ADirection of andLeft: ADistance := R1.Left - R2.Right; andUp: ADistance := R1.Top - R2.Bottom; andRight: ADistance := R2.Left - R1.Right; andDown: ADistance := R2.Top - R1.Bottom; end; end; var AAngle, ADistance, AMinAngle, AMinDistance: Extended; ANearestObject: TdxBarAccessibilityHelper; I: Integer; R, R1, R2: TRect; begin if ADirection in [andPrev, andNext] then begin Result := nil; // TODO Exit; end; AMinAngle := 0; AMinDistance := 0; ANearestObject := nil; R1 := ASelectedObject.GetScreenBounds(cxAccessibleObjectSelfID); for I := 0 to AObjects.Count - 1 do begin R := TdxBarAccessibilityHelper(AObjects[I]).GetScreenBounds(cxAccessibleObjectSelfID); CalcDistance(R1, R, AAngle, ADistance); if (ADistance >= 0) and ((ANearestObject = nil) or (ADistance < AMinDistance) or (ADistance = AMinDistance) and (AAngle < AMinAngle)) then begin ANearestObject := TdxBarAccessibilityHelper(AObjects[I]); AMinAngle := AAngle; AMinDistance := ADistance; end; end; if (ANearestObject = nil) and (ADirection in [andLeft, andRight]) and ACycleHorizontally then begin R2 := R1; case ADirection of andLeft: begin OffsetRect(R2, -R2.Left - cxRectWidth(R2), 0); OffsetRect(R2, MaxInt div 2, 0); end; andRight: begin OffsetRect(R2, -R2.Left, 0); OffsetRect(R2, -MaxInt div 2, 0); end; end; for I := 0 to AObjects.Count - 1 do begin R := TdxBarAccessibilityHelper(AObjects[I]).GetScreenBounds(cxAccessibleObjectSelfID); CalcDistance(R2, R, AAngle, ADistance); if (ADistance >= 0) and ((ANearestObject = nil) or (ADistance < AMinDistance) or (ADistance = AMinDistance) and (AAngle < AMinAngle)) then begin ANearestObject := TdxBarAccessibilityHelper(AObjects[I]); AMinAngle := AAngle; AMinDistance := ADistance; end; end; end; if ANearestObject <> nil then Result := ANearestObject else Result := nil; end; function GetRootAccessibleObject(AParentWnd: HWND): IdxBarAccessibilityHelper; var ABarManager: TdxBarManager; begin Result := nil; if Assigned(dxBarGetRootAccessibleObject) then Result := dxBarGetRootAccessibleObject(AParentWnd); if Result = nil then begin ABarManager := GetBarManagerByHandle(AParentWnd); if (ABarManager <> nil) and (ABarManager.MainMenuControl <> nil) then Result := ABarManager.MainMenuControl.IAccessibilityHelper; end; end; procedure HandleKeyTipsEscape(AActiveKeyTipContainer: IdxBarAccessibilityHelper); begin AActiveKeyTipContainer.GetBarHelper.KeyTipsEscapeHandler; end; function GetLinksOwner(AObject: TObject): IdxBarLinksOwner; begin Supports(AObject, IdxBarLinksOwner, Result); end; procedure dxSetZOrder(AHandle: THandle; AWndAfter: DWORD; AActivate: Boolean; AFlags: DWORD); const AActivateMap: array[Boolean] of Byte = (SWP_NOACTIVATE, 0); begin SetWindowPos(AHandle, AWndAfter, 0, 0, 0, 0, SWP_NOMOVE or SWP_NOSIZE or AActivateMap[AActivate]); end; function FormStyle(AForm: TCustomForm): TFormStyle; begin Result := TCustomFormAccess(AForm).FormStyle; end; function GetChildWindowVCLParent(AWnd: HWND): TWinControl; begin Result := nil; while (Result = nil) and (AWnd <> 0) and IsChildClassWindow(AWnd) do begin AWnd := GetParent(AWnd); Result := FindControl(AWnd); end; end; function IsMDIChild(AForm: TCustomForm): Boolean; begin Result := (AForm <> nil) and not (csDesigning in AForm.ComponentState) and (FormStyle(AForm) = fsMDIChild); end; function IsMDIForm(AForm: TCustomForm): Boolean; begin Result := (AForm <> nil) and not (csDesigning in AForm.ComponentState) and (FormStyle(AForm) = fsMDIForm); end; function IsFormActive(AForm: TCustomForm): Boolean; function IsWindowActive(AWindowHandle: HWND): Boolean; begin Result := AWindowHandle = GetActiveWindow; end; function IsMDIChildActive(AForm: TCustomForm): Boolean; begin Result := IsMDIChild(AForm) and IsWindowActive(Application.MainForm.Handle) and (Application.MainForm.ActiveMDIChild = AForm); end; function IsParentActive(AForm: TCustomForm): Boolean; begin Result := not IsMDIChild(AForm) and IsWindowActive(FindFirstNonChildParentWindow(AForm.Handle)); end; begin Result := (AForm <> nil) and AForm.HandleAllocated and (IsWindowActive(AForm.Handle) or IsMDIChildActive(AForm) or IsParentActive(AForm)); end; function IsAncestorComponentDifferencesDetection(AComponent: TComponent): Boolean; begin Result := (AComponent.ComponentState * [csLoading, csReading, csAncestor] = [csLoading, csAncestor]); end; function IsTextCharKeyDown(AKey: Word): Boolean; var ARes: UINT; begin ARes := MapVirtualKey(AKey, 2); Result := ((ARes and $FFFF0000) = 0) and IsTextChar(Char(ARes)); end; function IsParentFocused(AParent: THandle): Boolean; begin Result := (AParent <> 0) and ((AParent = GetFocus) or IsChildClassWindow(AParent) and IsParentFocused(GetParent(AParent))); end; function IsWindowEnabled(AWindowHandle: HWND): Boolean; begin Result := Windows.IsWindowEnabled(AWindowHandle); if IsChildClassWindow(AWindowHandle) then Result := Result and dxBar.IsWindowEnabled(GetParent(AWindowHandle)) end; function BarNavigationController: TdxBarNavigationController; begin Result := FBarNavigationController; end; procedure SendCancelMode; var AActiveControl: TWinControl; begin AActiveControl := FindControl(GetActiveWindow); if AActiveControl is TCustomForm then TCustomForm(AActiveControl).SendCancelMode(nil); end; procedure SetActiveWindow(AWindowHandle: HWND); begin Windows.SetActiveWindow(FindFirstNonChildParentWindow(AWindowHandle)); end; // null reference routines procedure CallNotify(ANotifyEvent: TNotifyEvent; ASender: TObject); begin if Assigned(ANotifyEvent) then ANotifyEvent(ASender); end; procedure RepaintItemControl(AItemControl: TdxBarItemControl); overload; begin if AItemControl <> nil then AItemControl.Repaint; end; procedure RepaintItemControl(AItemLink: TdxBarItemLink); overload; begin if AItemLink <> nil then RepaintItemControl(AItemLink.Control); end; function GetControlByLink(AItemLink: TdxBarItemLink): TdxBarItemControl; begin if AItemLink <> nil then Result := AItemLink.Control else Result := nil; end; function GetLinkByControl(AItemControl: TdxBarItemControl): TdxBarItemLink; begin if AItemControl <> nil then Result := AItemControl.ItemLink else Result := nil; end; function GetItemByControl(AItemControl: TdxBarItemControl): TdxBarItem; begin if AItemControl <> nil then Result := AItemControl.Item else Result := nil; end; function GetItemByLink(AItemLink: TdxBarItemLink): TdxBarItem; begin if AItemLink <> nil then Result := AItemLink.Item else Result := nil; end; function GetObjectByObjectLink(AObjectLink: TcxObjectLink): TObject; begin if AObjectLink <> nil then Result := AObjectLink.Ref else Result := nil; end; function GetOwnedLinks(AObject: TObject): TdxBarItemLinks; begin if GetLinksOwner(AObject) <> nil then Result := GetLinksOwner(AObject).GetItemLinks else Result := nil; end; function GetActiveForm: TCustomForm; var AControl: TWinControl; begin Result := nil; AControl := FindControl(GetActiveWindow); if (AControl is TCustomForm) and IsWindowEnabled(AControl.Handle) then begin Result := TCustomForm(AControl); if IsMDIForm(Result) and (TCustomFormAccess(Result).ActiveMDIChild <> nil) then Result := TCustomFormAccess(Result).ActiveMDIChild; end; end; function GetInstance(ASelectedItem: IdxBarSelectableItem): TPersistent; begin if ASelectedItem <> nil then Result := ASelectedItem.GetInstance else Result := nil; end; function GetSubItemButtonByButtonCaption(ASubItem: TdxBarSubItem; const ACaption: string): TdxBarButton; var I: Integer; begin Result := nil; for I := 0 to ASubItem.ItemLinks.Count - 1 do if TdxBarButton(ASubItem.ItemLinks[I].Item).Caption = ACaption then Result := TdxBarButton(ASubItem.ItemLinks[I].Item); end; function IsMouseDownMessage(AMsg: Cardinal): Boolean; begin Result := (AMsg = WM_LBUTTONDOWN) or (AMsg = WM_LBUTTONDBLCLK) or (AMsg = WM_RBUTTONDOWN) or (AMsg = WM_RBUTTONDBLCLK) or (AMsg = WM_MBUTTONDOWN) or (AMsg = WM_MBUTTONDBLCLK) or (AMsg = WM_NCLBUTTONDOWN) or (AMsg = WM_NCLBUTTONDBLCLK) or (AMsg = WM_NCRBUTTONDOWN) or (AMsg = WM_NCRBUTTONDBLCLK) or (AMsg = WM_NCMBUTTONDOWN) or (AMsg = WM_NCMBUTTONDBLCLK); end; procedure KillBeep(AWnd: HWND); begin KillMessages(AWnd, WM_CHAR, WM_CHAR); end; // Temp methods function GetBarManagerByComponent(AComponent: TComponent): TdxBarManager; var I: Integer; begin Result := nil; if AComponent is TdxBarManager then Result := TdxBarManager(AComponent) else begin if (AComponent is TCustomForm) and (TCustomForm(AComponent).Parent = nil) then begin if Assigned(cxControls.cxGetParentFormForDocking) then AComponent := cxControls.cxGetParentFormForDocking(TCustomForm(AComponent)); end; if (AComponent <> nil) and (dxBarManagerList <> nil) then for I := 0 to dxBarManagerList.Count - 1 do if dxBarManagerList[I].Owner = AComponent then begin Result := dxBarManagerList[I]; Break; end; end; end; function GetBarManagerByForm(AForm: TCustomForm): TdxBarManager; begin Result := GetBarManagerByComponent(AForm); end; function GetWinControlOwner(AComponent: TComponent): TWinControl; begin while (AComponent <> nil) and not (AComponent is TWinControl) do AComponent := AComponent.Owner; Result := TWinControl(AComponent) end; function GetBarManagerForComponent(AComponent: TComponent): TdxBarManager; var AControl: TWinControl; begin Result := nil; AControl := GetWinControlOwner(AComponent); if (AControl <> nil) and AControl.HandleAllocated then repeat Result := GetBarManagerByComponent(AControl); AControl := GetChildWindowVCLParent(AControl.Handle); until (Result <> nil) or (AControl = nil); end; function GetControlForm(AControl: TWinControl; AFormKind: TdxBarManagerFormKind): TCustomForm; function CheckForm(AForm: TCustomForm): Boolean; begin Result := (AForm <> nil) and ((AFormKind = fkAny) or (AFormKind = fkMainOrMDIChild) and IsMDIChild(AForm)); end; var AWnd: HWND; ACurrentForm: TCustomForm; begin Result := nil; if not CanAllocateHandle(AControl) then Exit; AWnd := AControl.Handle; while AWnd <> 0 do begin if FindControl(AWnd) is TCustomForm then begin ACurrentForm := TCustomForm(FindControl(AWnd)); Result := ACurrentForm; end else ACurrentForm := nil; if not IsChildClassWindow(AWnd) or CheckForm(ACurrentForm) then Break; AWnd := GetParent(AWnd); end; end; function GetComponentForm(AComponent: TComponent): TCustomForm; var AControl: TWinControl; begin AControl := GetWinControlOwner(AComponent); if AControl <> nil then Result := GetControlForm(AControl, fkAny) else Result := nil; end; function GetBarManagerForm(ABarManager: TdxBarManager; AFormKind: TdxBarManagerFormKind): TCustomForm; begin Result := GetControlForm(ABarManager.Owner, AFormKind); end; function IsBarManagerOwner(ABarManager: TdxBarManager; AOwnerHandle: HWND): Boolean; var AWnd: HWND; begin Result := False; if ABarManager.Owner.HandleAllocated then begin AWnd := ABarManager.Owner.Handle; while (AWnd <> AOwnerHandle) and IsChildClassWindow(AWnd) do AWnd := GetParent(AWnd); Result := AWnd = AOwnerHandle; end; end; function GetWinControl(AControl: TControl): TWinControl; begin if AControl is TWinControl then Result := TWinControl(AControl) else Result := AControl.Parent; end; function IsChildControl(AParentControl: TWinControl; AChildWnd: THandle): Boolean; overload; begin Result := AParentControl.HandleAllocated and IsChildEx(AParentControl.Handle, AChildWnd); end; function IsChildControl(AParentControl: TWinControl; AChildControl: TControl): Boolean; overload; var AParent: TWinControl; AChildWinControl: TWinControl; begin AChildWinControl := GetWinControl(AChildControl); if AParentControl.HandleAllocated and AChildWinControl.HandleAllocated then Result := IsChildEx(AParentControl.Handle, AChildWinControl.Handle) else begin AParent := AChildWinControl; while (AParent <> nil) and (AParent <> AParentControl) do AParent := AParent.Parent; Result := AParent = AParentControl; end; end; function IsControlUnderBarManager(ABarManager: TdxBarManager; AControl: TControl): Boolean; begin Result := IsChildControl(ABarManager.Owner, AControl); end; function GetParentPopupWindow(AControl: TWinControl; ACheckParentBars: Boolean): TcxCustomPopupWindow; function InternalGetParent(AWnd: HWND): HWND; var AControl: TWinControl; begin Result := 0; if IsChildClassWindow(AWnd) then Result := GetParent(AWnd) else if ACheckParentBars then begin AControl := FindControl(AWnd); if (AControl is TCustomdxBarControl) and (TCustomdxBarControl(AControl).ParentBar <> nil) then Result := TCustomdxBarControl(AControl).ParentBar.Handle; end; end; var AParentWnd, AWnd: HWND; begin Result := nil; if not AControl.HandleAllocated or (csDestroying in AControl.ComponentState) then Exit; AWnd := AControl.Handle; repeat AParentWnd := InternalGetParent(AWnd); if AParentWnd = 0 then Break; AWnd := AParentWnd; until False; if (AWnd <> AControl.Handle) and (FindControl(AWnd) is TcxCustomPopupWindow) then Result := TcxCustomPopupWindow(FindControl(AWnd)); end; // Temp methods function EnumToStringArray(ATypeInfo: PTypeInfo): TStringArray; var ATypeData: PTypeData; AList: TStringList; I: Integer; begin ATypeData := GetTypeData(ATypeInfo); AList := TStringList.Create; try for I := ATypeData.MinValue to ATypeData.MaxValue do AList.Add(GetEnumName(ATypeInfo, I)); // AList.Sort; SetLength(Result, AList.Count); for I := 0 to High(Result) do Result[I] := AList[I]; finally AList.Free; end; end; function SetToStringArray(ATypeInfo: PTypeInfo): TStringArray; begin Result := EnumToStringArray(GetTypeData(ATypeInfo).CompType^); end; procedure SetLayeredWndAttributes(AHandle: HWND; AAlphaBlendValue: Integer); var AStyle: Integer; begin if Assigned(SetLayeredWindowAttributes) then begin AStyle := GetWindowLong(AHandle, GWL_EXSTYLE); if AAlphaBlendValue < 255 then begin if (AStyle and WS_EX_LAYERED) = 0 then SetWindowLong(AHandle, GWL_EXSTYLE, AStyle or WS_EX_LAYERED); SetLayeredWindowAttributes(AHandle, 0, AAlphaBlendValue, LWA_ALPHA); end else if (AStyle and WS_EX_LAYERED) <> 0 then begin SetWindowLong(AHandle, GWL_EXSTYLE, AStyle and not WS_EX_LAYERED); RedrawWindow(AHandle, nil, 0, RDW_ERASE or RDW_INVALIDATE or RDW_FRAME or RDW_ALLCHILDREN); end; end; end; procedure DeleteGDIObject(var AGDIObject); begin if HGDIOBJ(AGDIObject) <> 0 then begin DeleteObject(HGDIOBJ(AGDIObject)); HGDIOBJ(AGDIObject) := 0; end; end; procedure ReverseGDIObject(ADC: HDC; APrevGDIObject: HGDIOBJ); begin DeleteObject(SelectObject(ADC, APrevGDIObject)); end; procedure PolygonByColor(ADC: HDC; var APoints: array of TPoint; APenColor, ABrushColor: COLORREF); var APrevBrush, APrevPen: HGDIOBJ; begin APrevPen := SelectObject(ADC, CreatePen(PS_SOLID, 1, APenColor)); APrevBrush := SelectObject(ADC, CreateSolidBrush(ABrushColor)); Polygon(ADC, APoints, Length(APoints)); ReverseGDIObject(ADC, APrevBrush); ReverseGDIObject(ADC, APrevPen); end; procedure RoundRectByColor(ADC: HDC; const R: TRect; AWidth, AHeight: Integer; APenColor, ABrushColor: TColor); var APrevBrush, APrevPen: HGDIOBJ; ALogBrush: LOGBRUSH; begin ZeroMemory(@ALogBrush, SizeOf(ALogBrush)); if ABrushColor = clNone then ALogBrush.lbStyle := BS_NULL else ALogBrush.lbColor := ColorToRGB(ABrushColor); APrevBrush := SelectObject(ADC, CreateBrushIndirect(ALogBrush)); APrevPen := SelectObject(ADC, CreatePen(PS_SOLID, 1, ColorToRGB(APenColor))); RoundRect(ADC, R.Left, R.Top, R.Right, R.Bottom, AWidth, AHeight); ReverseGDIObject(ADC, APrevBrush); ReverseGDIObject(ADC, APrevPen); end; procedure ExcludeFrameRegion(ACanvas: TcxCanvas; AFrameRect, AContentRect: TRect); var ARegion: TcxRegion; begin ARegion := TcxRegion.Create(AFrameRect); ARegion.Combine(TcxRegion.Create(AContentRect), roSubtract); ACanvas.SetClipRegion(ARegion, roSubtract); end; procedure DestroyWindowHandle(var AWindowHandle: HWND; ADestroyWindow: Boolean = True); begin if AWindowHandle <> 0 then begin if ADestroyWindow then Windows.DestroyWindow(AWindowHandle); AWindowHandle := 0; end; end; function dxKillTimer(AWindowHandle: HWND; var ATimerID: DWORD): Boolean; begin Result := (ATimerID <> 0) and KillTimer(AWindowHandle, ATimerID); if Result then ATimerID := 0; end; function IsAnotherApplicatonWindow(AWnd: HWND): Boolean; var AProcessId: Cardinal; begin GetWindowThreadProcessId(AWnd, @AProcessId); Result := (AWnd = 0) or (AProcessId <> GetCurrentProcessId); end; function IsPopupMenuShowed: Boolean; var I, J: Integer; begin Result := False; for I := 0 to dxBarManagerList.Count - 1 do if not dxBarManagerList[I].IsDestroying then for J := 0 to dxBarManagerList[I].FPopupMenus.Count - 1 do if TdxBarPopupMenu(dxBarManagerList[I].FPopupMenus[J]).FPopupMenuVisible then begin Result := True; Break; end; end; function GetSectionDelimiter(AStoringKind: TdxBarStoringKind): string; begin case AStoringKind of skIni: Result := '.'; else Result := '\'; end; end; { global methods } function BarDesignController: TdxBarDesignController; begin if (FBarDesignController = nil) and not FdxBarIsFinalized then FBarDesignController := TdxBarDesignController.Create; Result := FBarDesignController; end; function BarCanvas: TdxBarCanvas; begin if (FBarCanvas = nil) and not FdxBarIsFinalized then FBarCanvas := TdxBarCanvas.Create; Result := FBarCanvas; end; function RegdxItemList: TdxBarItemList; begin if (FRegdxItemList = nil) and not FdxBarIsFinalized then FRegdxItemList := TdxBarItemList.Create; Result := FRegdxItemList; end; procedure dxBarRegisterItem(AItemClass: TdxBarItemClass; AItemControlClass: TdxBarItemControlClass; AVisible: Boolean); begin RegdxItemList.Register(AItemClass, AItemControlClass, AVisible); end; procedure dxBarUnregisterItem(AItemClass: TdxBarItemClass); begin RegdxItemList.Unregister(AItemClass); end; procedure AddBarControl(ABarControl: TCustomdxBarControl); begin FBarControls.Add(ABarControl); end; procedure RemoveBarControl(ABarControl: TCustomdxBarControl); begin FBarControls.Remove(ABarControl); end; function BarControlExists(ABarControl: TCustomdxBarControl): Boolean; begin Result := (ABarControl <> nil) and (FBarControls.IndexOf(ABarControl) <> -1); end; procedure dxBarDesignerModified(ABarManager: TdxBarManager); begin if ABarManager <> nil then ABarManager.DesignerModified; end; function dxBarCreateScreenTipViewInfo(ABarManager: TdxBarManager; AHintText: string; const AShortCut: string; AScreenTip: TdxBarScreenTip; ASkin: TObject): TdxBarCustomHintViewInfo; begin if (AScreenTip <> nil) and AScreenTip.Collection.Repository.ShowDescription then Result := TdxBarScreenTipViewInfo.Create(AScreenTip, ASkin, AHintText, AShortCut) else begin if (AScreenTip <> nil) and not AScreenTip.UseHintAsHeader and (AScreenTip.Header.Text <> '') then AHintText := AScreenTip.Header.Text; Result := TdxBarLikeHintScreenTipViewInfo.Create(ABarManager, ASkin, AHintText, AShortCut, GetMouseCursorPos); end; end; function dxBarCreateBitmap(AOnChangeProc: TNotifyEvent): TBitmap; begin Result := TBitmap.Create; Result.OnChange := AOnChangeProc; end; function ActiveBarControl: TCustomdxBarControl; begin Result := FActiveBarControl; end; function ActiveBarManager: TdxBarManager; begin if ActiveBarControl <> nil then Result := ActiveBarControl.BarManager else Result := nil; end; function IsActiveBarControlAccessible: Boolean; begin Result := (ActiveBarControl <> nil) and ActiveBarControl.HandleAllocated and IsWindowEnabled(ActiveBarControl.Handle); end; function VisibleTodxBarVisible(Value: Boolean): TdxBarItemVisible; begin if Value then Result := ivAlways else Result := ivNever; end; function GetBarManagerByHandle(AWnd: HWND): TdxBarManager; begin Result := GetBarManagerByComponent(FindControl(AWnd)) end; function GetParentBarOrSubMenuForBar(Value: TCustomdxBarControl): TCustomdxBarControl; begin Result := Value; while (Result <> nil) and not Result.IsDestroying do if (Result.ParentBar = nil) or Result.IsInternal and not Result.ParentBar.IsInternal then Break else Result := Result.ParentBar; end; function GetParentBarForBar(Value: TCustomdxBarControl): TCustomdxBarControl; begin Result := GetParentBarOrSubMenuForBar(Value); if Result is TdxBarSubMenuControl then Result := nil; end; function GetAccelPos(var AText: string; AModifyString: Boolean = False): Integer; var I: Integer; begin Result := 0; I := 1; while I < Length(AText) do begin if AText[I] = '&' then begin if AModifyString then Delete(AText, I, 1) else Inc(I); if AText[I] <> '&' then Result := I; end; Inc(I); end; end; function GetParentBarOrSubMenuForControl(Value: TdxBarItemControl): TCustomdxBarControl; begin if Value = nil then Result := nil else Result := GetParentBarOrSubMenuForBar(Value.Parent); end; function GetParentBarForControl(Value: TdxBarItemControl): TCustomdxBarControl; begin Result := GetParentBarOrSubMenuForControl(Value); if Result is TdxBarSubMenuControl then Result := nil; end; function FindVCLControl(Wnd: HWND): TWinControl; begin repeat Result := FindControl(Wnd); Wnd := GetParent(Wnd); until (Result <> nil) or (Wnd = 0); end; function HasAsParent(Wnd: HWND; ParentWnd: HWND): Boolean; begin Result := IsOwner(ParentWnd, Wnd); end; function HasPopupWindowAbove(ABarControl: TCustomdxBarControl; AIgnoreSelectedControl: Boolean): Boolean; function GetItemControlScreenBounds(AItemControl: TdxBarItemControl): TRect; begin Result := AItemControl.ViewInfo.Bounds; Result.TopLeft := AItemControl.Parent.ClientToScreen(Result.TopLeft); Result.BottomRight := AItemControl.Parent.ClientToScreen(Result.BottomRight); end; var AActiveBarControl: TCustomdxBarControl; begin AActiveBarControl := ActiveBarControl; if (AActiveBarControl = nil) and (BarDesignController.QuickControl <> nil) then AActiveBarControl := BarDesignController.QuickControl; Result := False; if AActiveBarControl = nil then Exit; Result := (AActiveBarControl.SelectedControl <> nil) and AActiveBarControl.SelectedControl.IsDroppedDown and (not AIgnoreSelectedControl or not PtInRect(GetItemControlScreenBounds(AActiveBarControl.SelectedControl), GetMouseCursorPos)) or (AActiveBarControl <> ABarControl) and (AActiveBarControl.ParentBar <> nil); end; function WindowFromPointEx(P: TPoint): HWND; function FindOne(Wnd: HWND; P: TPoint): HWND; begin Result := ChildWindowFromPointEx(Wnd, P, CWP_SKIPINVISIBLE); if Result = 0 then Result := Wnd else if Result <> Wnd then begin MapWindowPoints(Wnd, Result, P, 1); Result := FindOne(Result, P); end; end; begin Result := WindowFromPoint(P); if Result <> 0 then begin ScreenToClient(Result, P); Result := FindOne(Result, P); end; end; function GetShortCutToHint(AShortCut: TShortCut): string; begin Result := ShortCutToText(AShortCut); if Result <> '' then Result := ' (' + Result + ')'; end; function GetTextOf(const S: string): string; var I: Integer; begin Result := S; I := 1; while I < Length(Result) do begin if Result[I] = '&' then Delete(Result, I, 1); Inc(I); end; end; procedure DrawItemArrow(DC: HDC; R: TRect; ArrowType: TcxArrowDirection; Enabled, Selected, Flat: Boolean); begin DrawItemArrow(DC, R, ArrowType = adDown, Enabled, Selected, Flat); end; procedure DrawItemArrow(ADC: HDC; R: TRect; ADownArrow, AEnabled, ASelected, AFlat: Boolean); var ASize: Integer; begin if not ADownArrow then ASize := R.Bottom - R.Top - 6 else // adDown ASize := R.Right - R.Left - 8; ASize := (ASize - 1) div 2 + Byte(ASize mod 2 <> 0); if ASize < 3 then ASize := 3; DrawLargeItemArrow(ADC, R, ADownArrow, ASize, ASelected, AEnabled, AFlat); end; procedure DrawLargeItemArrow(DC: HDC; R: TRect; ArrowType: TcxArrowDirection; Size: Integer; Selected, Enabled, Flat: Boolean); begin DrawLargeItemArrow(DC, R, ArrowType = adDown, Size, Selected, Enabled, Flat); end; procedure DrawLargeItemArrow(ADC: HDC; R: TRect; ADownArrow: Boolean; ASize: Integer; ASelected, AEnabled, AFlat: Boolean); var X, Y: Integer; procedure DrawEnabled(AColor: COLORREF); var P: array[1..3] of TPoint; begin with R do if ADownArrow then begin X := (Left + Right - (2 * ASize - 1)) div 2; Y := (Top + Bottom - ASize) div 2; P[1] := Point(X, Y); P[2] := Point(X + 2 * ASize - 2, Y); end else begin X := (Left + Right - ASize) div 2; Y := (Top + Bottom - (2 * ASize - 1)) div 2; P[1] := Point(X, Y); P[2] := Point(X, Y + 2 * ASize - 2); end; P[3] := Point(X + ASize - 1, Y + ASize - 1); PolygonByColor(ADC, P, AColor, AColor); end; procedure DrawDisabled; var Pen: HPEN; begin Pen := SelectObject(ADC, CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNHIGHLIGHT))); if ADownArrow then begin MoveToEx(ADC, X + ASize, Y + ASize - 1, nil); LineTo(ADC, X + 2 * ASize - 1, Y); MoveToEx(ADC, X + ASize, Y + ASize, nil); LineTo(ADC, X + 2 * ASize, Y); end else begin MoveToEx(ADC, X + ASize - 1, Y + ASize, nil); LineTo(ADC, X, Y + 2 * ASize - 1); MoveToEx(ADC, X + ASize, Y + ASize, nil); LineTo(ADC, X, Y + 2 * ASize); end; ReverseGDIObject(ADC, Pen); end; var AColorIndex: Integer; begin if AEnabled then if ASelected then begin if IsHighContrastWhite then AColorIndex := COLOR_BTNFACE // White else AColorIndex := COLOR_HIGHLIGHTTEXT; end else AColorIndex := COLOR_BTNTEXT else AColorIndex := COLOR_BTNSHADOW; DrawEnabled(GetSysColor(AColorIndex)); if not AEnabled and not AFlat then DrawDisabled; end; procedure FrameFlatSelRect(DC: HDC; const R: TRect); begin FrameRect(DC, R, GetSysColorBrush(COLOR_HIGHLIGHT)); end; { items global functions } function GetWorkArea(const P: TPoint): TRect; begin Result := GetDesktopWorkArea(P); end; procedure CheckEditWidth(var AWidth: Integer; AMinWidth: Integer); begin if AWidth < AMinWidth then AWidth := AMinWidth; end; procedure RefreshDeviceConsts; var DC: Integer; begin DC := GetDC(0); try BitsPerPixel := GetDeviceCaps(DC, BITSPIXEL); finally ReleaseDC(0, DC); end; end; procedure CreatePatternBrush; var Pattern: TBitmap; X, Y: Integer; begin if FdxBarIsFinalized then Exit; Pattern := TBitmap.Create; with Pattern, Canvas do begin Width := 8; Height := 8; Brush.Color := GetSysColor(COLOR_BTNHIGHLIGHT); FillRect(Rect(0, 0, Width, Height)); for Y := 0 to 7 do for X := 0 to 7 do if (Y mod 2) = (X mod 2) then Pixels[X, Y] := GetSysColor(COLOR_BTNFACE); end; DeleteGDIObject(PatternBrush); PatternBrush := Windows.CreatePatternBrush(Pattern.Handle); Pattern.Free; end; procedure DrawVerticalGradient(Canvas: TCanvas; const ARect: TRect; FromR, ToR, FromG, ToG, FromB, ToB: Byte); begin FillGradientRect(Canvas.Handle, ARect, RGB(FromR, FromG, FromB), RGB(ToR, ToG, ToB), False); end; procedure DrawDisablingHatch(ADC: HDC; const ARect: TRect); begin cxDrawHatch(ADC, ARect, clBlack, clBtnFace, 2, 20, 170); end; procedure TransparentDraw(DrawDC: HDC; R: TRect; AGlyph: TBitmap; AEnabled: Boolean = True); const DrawModes: array [Boolean] of TcxImageDrawMode = (idmDisabled, idmNormal); begin cxDrawImage(DrawDC, R, R, AGlyph, nil, -1, DrawModes[AEnabled]); end; procedure TransparentDraw(DrawDC: HDC; Brush: HBRUSH; FullRect, R: TRect; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; AImageListBkColor: TColor; AEnabled, AGrayScale, AFlat, ASelected, ADown, APressed, AShadow, AFaded: Boolean; ASmoothImage: Boolean = False; AUseLeftBottomPixelAsTransparent: Boolean = True); begin TransparentDraw(nil, DrawDC, Brush, FullRect, R, AGlyph, AImages, AImageIndex, AImageListBkColor, AEnabled, AGrayScale, AFlat, ASelected, ADown, APressed, AShadow, AFaded, ASmoothImage, AUseLeftBottomPixelAsTransparent); end; procedure TransparentDraw(ABarItemControl: TdxBarItemControl; DrawDC: HDC; Brush: HBRUSH; FullRect, R: TRect; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; AImageListBkColor: TColor; AEnabled, AGrayScale, AFlat, ASelected, ADown, APressed, AShadow, AFaded: Boolean; ASmoothImage: Boolean = False; AUseLeftBottomPixelAsTransparent: Boolean = True); function GetDrawMode: TcxImageDrawMode; begin Result := idmNormal; if AEnabled or AFaded then begin if not AEnabled then Result := idmFaded else if AGrayScale then Result := idmGrayScale else if AFlat then begin if not ASelected and not ADown and dxBarMakeInactiveImagesDingy and (BitsPerPixel > 8) then Result := idmDingy else if AShadow and ASelected and not APressed {and not ADown} then Result := idmShadowed; end; end else Result := idmDisabled; end; var ADrawMode: TcxImageDrawMode; begin if IsGlyphAssigned(AGlyph) then AImageListBkColor := clNone; ADrawMode := GetDrawMode; if (ABarItemControl <> nil) and (ADrawMode <> idmShadowed) then begin if not ABarItemControl.FCashedImageOptions.IsCashed(ADrawMode, AGlyph, AImages) then ABarItemControl.FCashedImageOptions.Cash(R, AGlyph, AImages, AImageIndex, ADrawMode, AImageListBkColor, ASmoothImage, AUseLeftBottomPixelAsTransparent); AGlyph := ABarItemControl.FCashedImageOptions.Glyph; ADrawMode := idmNormal; end; cxDrawImage(DrawDC, R, FullRect, AGlyph, AImages, AImageIndex, ADrawMode, ASmoothImage, Brush, AImageListBkColor, AUseLeftBottomPixelAsTransparent); end; procedure ProcessMouseMessages; var Msg: TMsg; begin while PeekMessage(Msg, 0, WM_MOUSEFIRST, WM_MOUSELAST, PM_NOREMOVE) do begin case Integer(GetMessage(Msg, 0, WM_MOUSEFIRST, WM_MOUSELAST)) of -1: Break; 0: begin PostQuitMessage(Msg.wParam); Break; end; end; DispatchMessage(Msg); end; end; procedure ProcessPaintMessages; var Msg: TMsg; begin while PeekMessage(Msg, 0, WM_PAINT, WM_PAINT, PM_NOREMOVE) do begin case Integer(GetMessage(Msg, 0, WM_PAINT, WM_PAINT)) of -1: Break; 0: begin PostQuitMessage(Msg.wParam); Break; end; end; DispatchMessage(Msg); end; end; type TPlaySoundType = (psMenuPopup, psMenuCommand, psStopPlay); procedure PlaySound(APlaySoundType: TPlaySoundType); const PlaySounds: array[TPlaySoundType] of PChar = ('MenuPopup', 'MenuCommand', nil); begin if dxBarPlaySound then MMSystem.PlaySound(PlaySounds[APlaySoundType], 0, SND_ALIAS or SND_ASYNC or SND_NODEFAULT {or SND_NOSTOP }or SND_NOWAIT); end; procedure InitMMSystem; begin PlaySound(psStopPlay); end; function CreateToolbarCaptionFontHandle(AFont: TFont; AUseSystemFont: Boolean): HFont; var ANonClientMetrics: TNonClientMetrics; begin ANonClientMetrics.cbSize := SizeOf(ANonClientMetrics); SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, @ANonClientMetrics, 0); if not AUseSystemFont then with ANonClientMetrics.lfSmCaptionFont, AFont do begin if lfHeight > -11 then lfHeight := -11; Move(Name[1], lfFaceName, Length(Name)); lfFaceName[Length(Name)] := #0; end; Result := CreateFontIndirect(ANonClientMetrics.lfSmCaptionFont); end; procedure CreateEditFontHandle(AFont: TFont; var AEditFont: TFont; AScaled: Boolean); var ASystemLogFont, ALogFont: TLogFont; begin if AScaled then begin {$IFDEF CLR} SystemParametersInfo(SPI_GETICONTITLELOGFONT, Marshal.SizeOf(TypeOf(ALogFont)), ASystemLogFont, 0); {$ELSE} SystemParametersInfo(SPI_GETICONTITLELOGFONT, SizeOf(ASystemLogFont), @ASystemLogFont, 0); {$ENDIF} cxGetFontData(AFont.Handle, ALogFont); ALogFont.lfHeight := ASystemLogFont.lfHeight; with ALogFont do if lfHeight > -11 then lfHeight := -11; AEditFont.Handle := CreateFontIndirect(ALogFont); end else AEditFont.Handle := CloneFont(AFont.Handle); end; function CloneFont(Source: HFONT): HFONT; var LogFont: TLogFont; begin cxGetFontData(Source, LogFont); Result := CreateFontIndirect(LogFont); end; procedure RestoreClipRgn(DC: HDC; var AClipRgn: HRGN; var AClipRgnExists: Boolean); begin if AClipRgnExists then SelectClipRgn(DC, AClipRgn) else SelectClipRgn(DC, 0); DeleteObject(AClipRgn); end; procedure SaveClipRgn(DC: HDC; var AClipRgn: HRGN; var AClipRgnExists: Boolean); begin AClipRgn := CreateRectRgn(0, 0, 0, 0); AClipRgnExists := GetClipRgn(DC, AClipRgn) = 1; end; procedure AddClipRect(DC: HDC; const R: TRect); var ARgn: HRGN; begin with R do ARgn := CreateRectRgn(Left, Top, Right, Bottom); ExtSelectClipRgn(DC, ARgn, RGN_OR); DeleteObject(ARgn); end; procedure ExcludeRect(var MainRgn: HRGN; const R: TRect); var TempRgn: HRGN; begin TempRgn := CreateRectRgnIndirect(R); CombineRgn(MainRgn, MainRgn, TempRgn, RGN_DIFF); DeleteObject(TempRgn); end; function GetRealColor(AColor: COLORREF): COLORREF; var DC: HDC; begin DC := GetDC(0); Result := GetNearestColor(DC, AColor); ReleaseDC(0, DC); end; procedure FillBackgroundRect(DC: HDC; ADestR, ASourceR: TRect; ABrush: HBRUSH; AColor: TColor; ABitmap: TBitmap); var ABrushExist: Boolean; begin if (ABitmap <> nil) and not ABitmap.Empty then FillRectByBitmap(DC, ADestR, ASourceR, ABitmap) else begin ABrushExist := ABrush <> 0; if not ABrushExist then ABrush := CreateSolidBrush(ColorToRGB(AColor)); FillRect(DC, ADestR, ABrush); if not ABrushExist then DeleteObject(ABrush); end; end; procedure FillRectByBitmap(DC: HDC; ADestR, ASourceR: TRect; ABitmap: TBitmap); var W, H, RW, RH: Integer; I, J, XStart, XEnd, YStart, YEnd, X, Y: Integer; AClipRgn: HRGN; AClipRgnExists: Boolean; begin W := ABitmap.Width; H := ABitmap.Height; RW := ASourceR.Right - ASourceR.Left; RH := ASourceR.Bottom - ASourceR.Top; if (W = 0) or (H = 0) or (RW = 0) or (RH = 0) then Exit; XStart := ASourceR.Left div W; XEnd := (ASourceR.Right - 1) div W; YStart := ASourceR.Top div H; YEnd := (ASourceR.Bottom - 1) div H; SaveClipRgn(DC, AClipRgn, AClipRgnExists); with ADestR do IntersectClipRect(DC, Left, Top, Right, Bottom); for J := YStart to YEnd do for I := XStart to XEnd do begin Y := J * H - (ASourceR.Top - ADestR.Top); X := I * W - (ASourceR.Left - ADestR.Left); BitBlt(DC, X, Y, W, H, ABitmap.Canvas.Handle, 0, 0, SRCCOPY); end; RestoreClipRgn(DC, AClipRgn, AClipRgnExists); end; procedure AfterDrawBackground(ADC: HDC; APrevWindowOrg: TPoint); begin SetWindowOrgEx(ADC, APrevWindowOrg.X, APrevWindowOrg.Y, nil); end; function BeforeDrawBackground(ASourceControl, ADestinationControl: TWinControl; ADC: HDC; var ARect: TRect; out APrevWindowOrg: TPoint): TPoint; begin Result := cxNullPoint; if (ASourceControl <> nil) and ASourceControl.HandleAllocated and (ADestinationControl <> nil) and ADestinationControl.HandleAllocated then MapWindowPoints(ASourceControl.Handle, ADestinationControl.Handle, Result, 1); OffsetWindowOrgEx(ADC, Result.X, Result.Y, APrevWindowOrg); ARect := cxRectOffset(ARect, Result); end; { test of mouse keys pressing } function IsMouseButtonPressed(AButton, ASwapButton: Integer): Boolean; begin if GetSystemMetrics(SM_SWAPBUTTON) = 0 then Result := GetAsyncKeyState(AButton) < 0 else Result := GetAsyncKeyState(ASwapButton) < 0; end; function LeftButtonPressed: Boolean; begin Result := IsMouseButtonPressed(VK_LBUTTON, VK_RBUTTON); end; function RightButtonPressed: Boolean; begin Result := IsMouseButtonPressed(VK_RBUTTON, VK_LBUTTON); end; function IsApplicationActive: Boolean; begin Result := FApplicationActive and not FApplicationDeactivation and (GetActiveWindow <> 0); end; procedure dxFreeAndNil(var AObject); begin TObject(AObject).Free; Pointer(AObject) := nil; end; procedure dxFreeAndNilObjectLink(var ALink: TcxObjectLink); var ATempLink: TcxObjectLink; begin if ALink <> nil then begin ATempLink := ALink; ALink := nil; cxRemoveObjectLink(ATempLink); end; end; function dxBarMessageBox(AText: string; AFlags: Integer): Integer; begin Result := Application.MessageBox({$IFNDEF CLR}PChar{$ENDIF}(AText), {$IFNDEF CLR}PChar{$ENDIF}(Application.Title), AFlags); end; procedure dxBarFrameRect(ADC: HDC; ARect: TRect; AColor: Integer); begin FrameRect(ADC, ARect, GetSysColorBrush(AColor)); InflateRect(ARect, -1, -1); FrameRect(ADC, ARect, GetSysColorBrush(AColor)); end; procedure dxBarFocusRect(ADC: HDC; ARect: TRect); procedure InternalSetPixel(X, Y: Integer); begin if (X + Y) mod 2 = 0 then SetPixel(ADC, X, Y, ColorToRGB(clBtnText)); end; procedure InternalDrawFocusRect; var I: Integer; begin for I := ARect.Left to ARect.Right - 1 do begin InternalSetPixel(I, ARect.Top); InternalSetPixel(I, ARect.Bottom - 1); end; for I := ARect.Top to ARect.Bottom - 1 do begin InternalSetPixel(ARect.Left, I); InternalSetPixel(ARect.Right - 1, I); end; end; begin InternalDrawFocusRect; InflateRect(ARect, -1, -1); InternalDrawFocusRect; end; function IsSelectableItem(AObject: TObject): Boolean; begin Result := Supports(AObject, IdxBarSelectableItem); end; function GetSelectableItem(AObject: TObject): IdxBarSelectableItem; begin Supports(AObject, IdxBarSelectableItem, Result); end; procedure CleanSelectableItems(AItems: TdxObjectList); var I: Integer; begin for I := AItems.Count - 1 downto 0 do if not IsSelectableItem(AItems[I]) then AItems.Delete(I); end; function GetMaxViewLevel(AViewLevels: TdxBarItemViewLevels): TdxBarItemRealViewLevel; begin for Result := Low(TdxBarItemRealViewLevel) to High(TdxBarItemRealViewLevel) do if Result in AViewLevels then Break; end; function GetMinViewLevel(AViewLevels: TdxBarItemViewLevels): TdxBarItemRealViewLevel; begin for Result := High(TdxBarItemRealViewLevel) downto Low(TdxBarItemRealViewLevel) do if Result in AViewLevels then Break; end; function GetNextViewLevel(AViewLevels: TdxBarItemViewLevels; AViewLevel: TdxBarItemRealViewLevel): TdxBarItemRealViewLevel; begin for Result := Succ(AViewLevel) to High(TdxBarItemRealViewLevel) do if Result in AViewLevels then Break; end; function WidthToCurrentDpi(AValue: Integer; ANormalDpi: Integer = 96): Integer; begin Result := Round(AValue * Screen.PixelsPerInch / ANormalDpi); end; procedure BarDrawSizeGrip(DC: HDC; R: TRect); const ROP_DSPDxax = $00E20746; var APrevBitmap, ATempBitmap, AMaskBitmap: HBITMAP; TempDC, MDC, MaskDC: HDC; W, H: Integer; APrevBkColor: COLORREF; begin W := R.Right - R.Left; H := R.Bottom - R.Top; TempDC := CreateCompatibleDC(DC); ATempBitmap := SelectObject(TempDC, CreateCompatibleBitmap(DC, W, H)); try BitBlt(TempDC, 0, 0, W, H, DC, R.Left, R.Top, SRCCOPY); // 1 MDC := CreateCompatibleDC(DC); APrevBitmap := SelectObject(MDC, CreateCompatibleBitmap(DC, W, H)); DrawFrameControl(MDC, Rect(0, 0, W, H), DFC_SCROLL, DFCS_SCROLLSIZEGRIP); // 2 MaskDC := CreateCompatibleDC(DC); AMaskBitmap := SelectObject(MaskDC, CreateBitmap(W, H, 1, 1, nil)); try APrevBkColor := SetBkColor(MDC, ColorToRGB(clBtnFace)); //! BitBlt(MaskDC, 0, 0, W, H, MDC, 0, 0, SRCCOPY); SetBkColor(MDC, APrevBkColor); BitBlt(TempDC, 0, 0, W, H, MaskDC, 0, 0, MERGEPAINT); BitBlt(MDC, 0, 0, W, H, MaskDC, 0, 0, SRCPAINT); BitBlt(TempDC, 0, 0, W, H, MDC, 0, 0, SRCAND); finally DeleteObject(SelectObject(MaskDC, AMaskBitmap)); DeleteDC(MaskDC); end; DeleteObject(SelectObject(MDC, APrevBitmap)); DeleteDC(MDC); BitBlt(DC, R.Left, R.Top, W, H, TempDC, 0, 0, SRCCOPY); finally DeleteObject(SelectObject(TempDC, ATempBitmap)); DeleteDC(TempDC); end; end; { XP routines } function ThemeEditState(ABarEditControl: TdxBarWinControl(*TdxBarEditControl*)): Integer; // TODO ReadOnly begin if not ABarEditControl.Enabled then Result := ETS_DISABLED else // if ABarEditControl.ReadOnly then // Result := ETS_READONLY // else Result := ETS_NORMAL; end; function ThemeEditColor(ATheme: TdxTheme; AEditState: Integer): COLORREF; begin Result := GetSysColor(COLOR_WINDOW); if AEditState = ETS_DISABLED then begin if FAILED(GetThemeColor(ATheme, EP_EDITTEXT, AEditState, TMT_FILLCOLOR, Result)) then Result := GetSysColor(COLOR_WINDOW); end; end; function ThemeEditTextColor(ATheme: TdxTheme; AEditState: Integer): COLORREF; begin if FAILED(GetThemeColor(ATheme, EP_EDITTEXT, AEditState, TMT_TEXTCOLOR, Result)) then begin if AEditState = ETS_DISABLED then Result := GetSysColor(COLOR_GRAYTEXT) else Result := GetSysColor(COLOR_WINDOWTEXT); end; end; function ThemeToolbarColor: COLORREF; var ATheme: TdxTheme; begin ATheme := OpenTheme(totToolbar); if FAILED(GetThemeColor(ATheme, 0, 0, TMT_FILLCOLOR, Result)) then Result := COLOR_BTNFACE; end; function ThemeCloseButtonSize: TSize; var ATheme: TdxTheme; begin ATheme := OpenTheme(totWindow); GetThemePartSize(ATheme, 0, WP_SMALLCLOSEBUTTON, CBS_NORMAL, TS_TRUE, Result); end; procedure ThemeDrawCloseButton(DC: HDC; var R: TRect; ASelected, APressed: Boolean; ACorner: TdxCorner); const ButtonStates: array [TdxBarMarkState] of Integer = (CBS_NORMAL, CBS_HOT, CBS_PUSHED); var ATheme: TdxTheme; AState, X: Integer; ASize: TSize; begin ATheme := OpenTheme(totWindow); if APressed then AState := CBS_PUSHED else if ASelected then AState := CBS_HOT else AState := CBS_NORMAL; ASize := ThemeCloseButtonSize; if (R.Bottom - R.Top) > ASize.cy then X := ((R.Bottom - R.Top) - ASize.cy) div 2 else X := 0; with R do begin if ACorner in [coTopRight, coBottomRight] then begin Inc(Left, X); Right := Left + ASize.cx; end else begin Dec(Right, X); Left := Right - ASize.cx; end; Inc(Top, X); Bottom := Top + ASize.cy; end; FillRect(DC, R, GetSysColorBrush(COLOR_BTNFACE)); DrawThemeBackground(ATheme, DC, WP_SMALLCLOSEBUTTON, AState, R); end; function ThemeSizeGripSize: TSize; const Offset = 2; // ! var ATheme: TdxTheme; begin ATheme := OpenTheme(totScrollBar); GetThemePartSize(ATheme, 0, SBP_SIZEBOX, SZB_RIGHTALIGN, TS_TRUE, Result); Result.cx := Result.cx + Offset; Result.cy := Result.cy + Offset; end; procedure ThemeDrawSizeGrip(DC: HDC; var R: TRect; ACorner: TdxCorner); const Offset = 2; // ! Delta = 1; var ATheme: TdxTheme; AMirrorX, AMirrorY: Boolean; R1: TRect; AScrollBarSize: TSize; APrevBitmap: HBITMAP; MDC: HDC; X, Y: Integer; begin ATheme := OpenTheme(totScrollBar); AScrollBarSize := ThemeSizeGripSize; with R do begin if ACorner in [coTopRight, coBottomRight] then Left := Right - AScrollBarSize.cx - Delta else Right := Left + AScrollBarSize.cx + Delta; if ACorner in [coBottomLeft, coBottomRight] then Top := Bottom - AScrollBarSize.cy else Bottom := Top + AScrollBarSize.cy; AMirrorX := ACorner in [coTopLeft, coBottomLeft]; AMirrorY := ACorner in [coTopLeft, coTopRight]; end; FillRect(DC, R, GetSysColorBrush(COLOR_BTNFACE)); R1 := R; with R1 do begin if AMirrorX then Dec(Right, Offset) else Inc(Left, Offset); if AMirrorY then Dec(Bottom, Offset) else Inc(Top, Offset); end; X := R1.Left; Y := R1.Top; OffsetRect(R1, -R1.Left, -R1.Top); MDC := CreateCompatibleDC(DC); APrevBitmap := SelectObject(MDC, CreateCompatibleBitmap(DC, R1.Right, R1.Bottom)); FillRect(MDC, R1, COLOR_BTNFACE + 1); DrawThemeBackground(ATheme, MDC, SBP_SIZEBOX, SZB_RIGHTALIGN, R1); with R1 do StretchBlt(DC, X, Y, Right, Bottom, MDC, Byte(AMirrorX) * (Right - 1), Byte(AMirrorY) * (Bottom - 1), (2 * Byte(not AMirrorX) - 1) * Right, (2 * Byte(not AMirrorY) - 1) * Bottom, SRCCOPY); DeleteObject(SelectObject(MDC, APrevBitmap)); DeleteDC(MDC); end; { TdxBarToolbarsPopup } type TdxBarToolbarsPopup = class(TdxBarInternalSubMenuControl); { TdxBarDropDownListBox } type TdxBarDropDownListBox = class(TCustomListBox) private FCombo: TdxBarCustomCombo; WaitForCapture: Boolean; function GetPainter: TdxBarPainter; procedure WMCaptureChanged(var Message: TMessage); message WM_CAPTURECHANGED; procedure WMEraseBkgnd(var Message: TWMEraseBkgnd); message WM_ERASEBKGND; procedure WMLButtonUp(var Message: TWMLButtonUp); message WM_LBUTTONUP; procedure WMNCCalcSize(var Message: TWMNCCalcSize); message WM_NCCALCSIZE; procedure WMNCPaint(var Message: TWMNCPaint); message WM_NCPAINT; protected procedure Click; override; procedure CreateParams(var Params: TCreateParams); override; procedure CreateWnd; override; procedure KeyDown(var Key: Word; Shift: TShiftState); override; procedure MouseMove(Shift: TShiftState; X, Y: Integer); override; property Painter: TdxBarPainter read GetPainter; public constructor Create(AOwner: TComponent); override; property OnDrawItem; property OnMeasureItem; end; constructor TdxBarDropDownListBox.Create(AOwner: TComponent); begin inherited; BorderStyle := bsNone; Style := lbOwnerDrawVariable; Visible := False; end; function TdxBarDropDownListBox.GetPainter: TdxBarPainter; begin Result := TCustomdxBarControl(Parent).Painter; end; procedure TdxBarDropDownListBox.WMCaptureChanged(var Message: TMessage); begin inherited; WaitForCapture := False; end; procedure TdxBarDropDownListBox.WMEraseBkgnd(var Message: TWMEraseBkgnd); begin Message.Result := 1; end; procedure TdxBarDropDownListBox.WMLButtonUp(var Message: TWMLButtonUp); var ACombo: TdxBarCustomCombo; AItemIndex: Integer; AItemLink, RealItemLink: TdxBarItemLink; begin inherited; if WaitForCapture then begin ReleaseCapture; Exit; end; ACombo := FCombo; AItemIndex := ItemIndex; AItemLink := ACombo.CurItemLink; RealItemLink := AItemLink.RealItemLink; if RealItemLink <> nil then begin RealItemLink.BringToTopInRecentList(True); RealItemLink.BarManager.HideAll; end else AItemLink.BarManager.HideAll; if AItemIndex > -1 then ACombo.ItemIndex := AItemIndex; end; procedure TdxBarDropDownListBox.WMNCCalcSize(var Message: TWMNCCalcSize); var ABorderSize: Integer; {$IFDEF CLR} AParams: TNCCalcSizeParams; {$ENDIF} begin inherited; ABorderSize := Painter.DropDownListBoxBorderSize; {$IFDEF CLR} AParams := Message.CalcSize_Params; InflateRect(AParams.rgrc0, -ABorderSize, -ABorderSize); Message.CalcSize_Params := AParams; {$ELSE} InflateRect(Message.CalcSize_Params.rgrc[0], -ABorderSize, -ABorderSize); {$ENDIF} end; procedure TdxBarDropDownListBox.WMNCPaint(var Message: TWMNCPaint); var ARect: TRect; ADC: HDC; begin inherited; GetWindowRect(Handle, ARect); OffsetRect(ARect, -ARect.Left, -ARect.Top); ADC := GetWindowDC(Handle); Painter.DropDownListBoxDrawBorder(ADC, Color, ARect); ReleaseDC(Handle, ADC); end; procedure TdxBarDropDownListBox.Click; begin if ItemIndex > -1 then TdxBarComboControl(FCombo.CurItemLink.Control).LocalItemIndex := ItemIndex; end; procedure TdxBarDropDownListBox.CreateParams(var Params: TCreateParams); begin inherited; with Params do begin ExStyle := WS_EX_TOOLWINDOW or WS_EX_TOPMOST; WindowClass.Style := WindowClass.Style or CS_SAVEBITS; end; end; procedure TdxBarDropDownListBox.CreateWnd; begin inherited CreateWnd; Windows.SetParent(Handle, 0); CallWindowProc(DefWndProc, Handle, WM_SETFOCUS, 0, 0); end; procedure TdxBarDropDownListBox.KeyDown(var Key: Word; Shift: TShiftState); begin if (ItemIndex = -1) and (Items.Count > 0) then ItemIndex := TopIndex; inherited; end; procedure TdxBarDropDownListBox.MouseMove(Shift: TShiftState; X, Y: Integer); var I: Integer; begin if (GetCapture = Handle) and WaitForCapture and PtInRect(ClientRect, Point(X, Y)) then begin WaitForCapture := False; CallWindowProc(DefWndProc, Handle, WM_LBUTTONDOWN, 0, MAKELPARAM(X, Y)); end; inherited; I := ItemAtPos(Point(X, Y), True); if (0 <= I) and (I <= Items.Count - 1) then ItemIndex := I; end; function TdxCustomQuickCustItemControl.GetDefaultWidth: Integer; begin Result := inherited GetDefaultWidth; Inc(Result, GetDefaultHeight); end; procedure TdxCustomQuickCustItemControl.Paint(ARect: TRect; PaintType: TdxBarPaintType); var AFullRect, R: TRect; ADC: HDC; ASelected: Boolean; begin AFullRect := ARect; R := ARect; ASelected := IsSelected; ADC := Parent.Canvas.Handle; Painter.DrawQuickCustItemFrame(Self, ADC, R, ARect, ASelected); Painter.DrawGlyph(Self, ADC, R, cxEmptyRect, ptMenu, True, ASelected, IsDowned, False, False, True, False, False); inherited; Painter.DrawQuickCustItemFrameSelected(Self, ADC, AFullRect, R, ASelected); end; procedure TdxBarQuickCustItem.DoClick; var ItemLink: TdxBarItemLink; begin inherited; ItemLink := TdxBarItemLink(ClickItemLink.Data); with ItemLink do Visible := not Visible; end; function TdxBarQuickCustItemControl.GetLinkedItemLink: TdxBarItemLink; begin Result := TdxBarItemLink(FItemLink.Data); end; procedure TdxBarQuickCustItemControl.ControlUnclick(ByMouse: Boolean); begin inherited; Repaint; end; function TdxBarQuickCustItemControl.GetCaption: string; begin Result := LinkedItemLink.Caption; end; function TdxBarQuickCustItemControl.GetGlyph: TBitmap; begin Result := LinkedItemLink.Glyph; end; function TdxBarQuickCustItemControl.GetImageIndex: Integer; begin Result := LinkedItemLink.Item.ImageIndex; end; function TdxBarQuickCustItemControl.GetImageList( AViewSize: TdxBarItemControlViewSize; AInToolbar: Boolean): TCustomImageList; begin Result := LinkedItemLink.Item.GetCurImages; end; function TdxBarQuickCustItemControl.GetLargeGlyph: TBitmap; begin Result := LinkedItemLink.Item.LargeGlyph; end; function TdxBarQuickCustItemControl.GetLargeImageIndex: Integer; begin Result := LinkedItemLink.Item.LargeImageIndex; end; function TdxBarQuickCustItemControl.IsDowned: Boolean; begin Result := LinkedItemLink.Visible; end; function TdxBarQuickCustItemControl.GetHint: string; begin Result := LinkedItemLink.Item.Hint; end; function TdxBarQuickCustItemControl.GetShortCut: TShortCut; begin Result := LinkedItemLink.Item.ShortCut; end; function TdxBarQuickCustItemControl.IsDestroyOnClick: Boolean; begin Result := False; end; { TdxBarQuickCustExtButton and TdxBarQuickCustExtButtonControl } type TdxBarQuickCustExtButton = class(TdxBarButton); TdxBarQuickCustExtButtonControl = class(TdxCustomQuickCustItemControl) protected function GetTextAreaOffset: Integer; override; function IsDowned: Boolean; override; end; function TdxBarQuickCustExtButtonControl.GetTextAreaOffset: Integer; begin Result := inherited GetTextAreaOffset + GetDefaultHeight; end; function TdxBarQuickCustExtButtonControl.IsDowned: Boolean; begin Result := False; end; { TdxBarQuickAccessItem and TdxBarQuickAccessSubControl } type TdxBarQuickAccessItem = class(TdxBarSubItem) protected function CreateBarControl: TCustomdxBarControl; override; public constructor Create(AOwner: TComponent); override; end; TdxBarQuickAccessSubControl = class(TdxBarSubMenuControl) protected function NeedShowGlyphAndCheckForItem: Boolean; override; end; constructor TdxBarQuickAccessItem.Create(AOwner: TComponent); begin inherited; ItemLinks.Internal := True; end; function TdxBarQuickAccessItem.CreateBarControl: TCustomdxBarControl; begin Result := TdxBarQuickAccessSubControl.Create(BarManager) end; function TdxBarQuickAccessSubControl.NeedShowGlyphAndCheckForItem: Boolean; begin Result := True; end; constructor TdxBarQuickControl.CreateForPopup(AParentBarControl: TdxBarControl; ABar: TdxBar); begin BarDesignController.ClearInternalItems; inherited CreateForPopup(AParentBarControl, ABar); OwnerBounds := ParentBar.MarkScreenRect; FHidingTimer := TcxTimer.Create(nil); FHidingTimer.Enabled := False; FHidingTimer.Interval := 200; FHidingTimer.OnTimer := QuickControlTimer; end; destructor TdxBarQuickControl.Destroy; begin FreeAndNil(FHidingTimer); inherited Destroy; end; function TdxBarQuickControl.GetParentBar: TdxBarControl; begin Result := TdxBarControl(inherited ParentBar); end; procedure TdxBarQuickControl.QuickControlTimer(Sender: TObject); begin FHidingTimer.Enabled := False; //#DG if (BarManager.SelectedItem <> nil) and (GetParentBarForControl(BarManager.SelectedItem) <> Self) then try CloseUp; except end; end; procedure TdxBarQuickControl.SetParentBar(Value: TdxBarControl); begin inherited ParentBar := Value; end; procedure TdxBarQuickControl.WMNCHitTest(var Message: TWMNCHitTest); begin inherited; with Message do if Result <> HTCLIENT then Result := HTBORDER; FHitTest := HTCLIENT; end; procedure TdxBarQuickControl.WMNCPaint(var Message: TMessage); var DC: HDC; begin inherited; DC := GetWindowDC(Handle); Painter.BarDrawOwnerLink(Self, DC); ReleaseDC(Handle, DC); end; procedure TdxBarQuickControl.WMRButtonDown(var Message: TWMRButtonDown); begin with TMessage(Message) do Result := DefWindowProc(Handle, Msg, wParam, lParam); end; function TdxBarQuickControl.GetParentForm: TCustomForm; begin if ParentBar <> nil then Result := ParentBar.GetParentForm else Result := inherited GetParentForm; end; function TdxBarQuickControl.GetSizeForPopup: TSize; begin with GetSizeForWidth(dsNone, 0) do Result := Size(X, Y); with Painter.GetToolbarContentOffsets(Bar, DockingStyle, False) do begin Inc(Result.cx, Left + Right); Inc(Result.cy, Top + Bottom); end; end; function TdxBarQuickControl.GetToolbarBrush: HBRUSH; begin Result := Painter.BarToolbarBrushEx2(Self); end; function TdxBarQuickControl.HasCaption: Boolean; begin Result := False; end; function TdxBarQuickControl.IsLinkedToOwner: Boolean; begin Result := inherited IsLinkedToOwner(* or ((ParentBar <> nil) and (ParentBar.FQuickPopup = Self))*); end; function TdxBarQuickControl.IsPopup: Boolean; begin Result := True; end; function TdxBarQuickControl.LockHotTrackWhenPopup: Boolean; begin Result := False; end; function TdxBarQuickControl.NeedShowGlyphAndCheckForItem: Boolean; begin Result := True; end; function TdxBarQuickControl.GetOwnerControl: TWinControl; begin Result := ParentBar; end; function TdxBarQuickControl.Kind: TdxBarKind; begin Result := bkBarQuickControl; end; procedure TdxBarQuickControl.Popup(const AOwnerRect: TRect); function GetDirection: TXDirection; begin if (ParentBar.DockingStyle = dsNone) and Painter.IsQuickControlPopupOnRight then Result := xdRight else Result := xdLeft; end; begin PopupEx(AOwnerRect, GetDirection); end; procedure TdxBarQuickControl.StartHidingTimer; begin FHidingTimer.Enabled := True; end; { TdxBarManagerCategories } type TdxBarCategoryData = class public ItemsVisible, LoadedItemsVisible: TdxBarItemVisible; Visible: Boolean; end; TdxBarManagerCategories = class(TStringList) private FMoving: Boolean; Owner: TdxBarManager; procedure ListChanged(Sender: TObject); procedure ChangeCategory(OldCategory, NewCategory: Integer); procedure ReadItemsVisibles(Reader: TReader); procedure ReadVisibles(Reader: TReader); procedure WriteItemsVisibles(Writer: TWriter); procedure WriteVisibles(Writer: TWriter); protected procedure ClearObject(AIndex: Integer); procedure ClearObjects; procedure DefineProperties(Filer: TFiler); override; public constructor Create(AOwner: TdxBarManager); destructor Destroy; override; procedure Clear; override; procedure Delete(Index: Integer); override; procedure Insert(Index: Integer; const S: string); override; procedure Exchange(Index1, Index2: Integer); override; procedure Move(CurIndex, NewIndex: Integer); override; end; constructor TdxBarManagerCategories.Create(AOwner: TdxBarManager); begin inherited Create; Owner := AOwner; if not Owner.IsLoading then Add(cxGetResourceString(@dxSBAR_DEFAULTCATEGORYNAME)); OnChange := ListChanged; end; destructor TdxBarManagerCategories.Destroy; begin ClearObjects; inherited; end; procedure TdxBarManagerCategories.Clear; begin ClearObjects; inherited; end; procedure TdxBarManagerCategories.ListChanged(Sender: TObject); begin Owner.DesignerModified; end; procedure TdxBarManagerCategories.ChangeCategory(OldCategory, NewCategory: Integer); var AList: TList; I: Integer; begin if (OldCategory > -1) and (OldCategory < Count) and (NewCategory > -1) then begin AList := TList.Create; try Owner.GetAllItemsByCategory(OldCategory, AList); for I := 0 to AList.Count - 1 do TdxBarItem(AList[I]).FCategory := NewCategory; finally AList.Free; end; end; end; procedure TdxBarManagerCategories.ReadItemsVisibles(Reader: TReader); var I: Integer; begin Reader.ReadListBegin; try BeginUpdate; try for I := 0 to Count - 1 do begin if Reader.EndOfList then Break; Owner.CategoryItemsVisible[I] := TdxBarItemVisible(Reader.ReadInteger); end; finally EndUpdate; end; finally Reader.ReadListEnd; end; end; procedure TdxBarManagerCategories.ReadVisibles(Reader: TReader); var I: Integer; begin Reader.ReadListBegin; try BeginUpdate; try for I := 0 to Count - 1 do begin if Reader.EndOfList then Break; Owner.CategoryVisible[I] := Reader.ReadBoolean; end; finally EndUpdate; end; finally Reader.ReadListEnd; end; end; procedure TdxBarManagerCategories.WriteItemsVisibles(Writer: TWriter); var I: Integer; begin Writer.WriteListBegin; try for I := 0 to Count - 1 do Writer.WriteInteger(Longint(Owner.CategoryItemsVisible[I])); finally Writer.WriteListEnd; end; end; procedure TdxBarManagerCategories.WriteVisibles(Writer: TWriter); var I: Integer; begin Writer.WriteListBegin; try for I := 0 to Count - 1 do Writer.WriteBoolean(Owner.CategoryVisible[I]); finally Writer.WriteListEnd; end; end; procedure TdxBarManagerCategories.ClearObject(AIndex: Integer); begin if Objects[AIndex] <> nil then begin Objects[AIndex].Free; Objects[AIndex] := nil; end; end; procedure TdxBarManagerCategories.ClearObjects; var I: Integer; begin for I := 0 to Count - 1 do ClearObject(I); end; procedure TdxBarManagerCategories.DefineProperties(Filer: TFiler); begin inherited; Filer.DefineProperty('ItemsVisibles', ReadItemsVisibles, WriteItemsVisibles, True); Filer.DefineProperty('Visibles', ReadVisibles, WriteVisibles, True); end; procedure TdxBarManagerCategories.Delete(Index: Integer); var List: TList; I: Integer; begin if FMoving then inherited else begin if (Index > -1 ) and (Index < Count) then begin List := TList.Create; Owner.GetAllItemsByCategory(Index, List); for I := 0 to List.Count - 1 do TdxBarItem(List[I]).Free; List.Free; for I := Index + 1 to Count - 1 do ChangeCategory(I, I - 1); ClearObject(Index); inherited; end; if Count = 0 then Add(cxGetResourceString(@dxSBAR_DEFAULTCATEGORYNAME)); end; end; procedure TdxBarManagerCategories.Insert(Index: Integer; const S: string); var I: Integer; begin if not FMoving and (Index > -1) and (Index < Count) then for I := Count - 1 downto Index do ChangeCategory(I, I + 1); inherited Insert(Index, S); end; procedure TdxBarManagerCategories.Exchange(Index1, Index2: Integer); var I: Integer; List1: TList; List2: TList; begin if (Index1 > -1) and (Index1 < Count) and (Index2 > -1) and (Index2 < Count) then begin List1 := TList.Create; List2 := TList.Create; Owner.GetAllItemsByCategory(Index1, List1); Owner.GetAllItemsByCategory(Index2, List2); for I := 0 to List1.Count - 1 do TdxBarItem(List1[I]).Category := Index2; for I := 0 to List2.Count - 1 do TdxBarItem(List2[I]).Category := Index1; List2.Free; List1.Free; inherited Exchange(Index1, Index2); end; end; procedure TdxBarManagerCategories.Move(CurIndex, NewIndex: Integer); var List: TList; I: Integer; begin if (0 <= CurIndex) and (CurIndex < Count) and (0 <= NewIndex) and (NewIndex < Count) and (CurIndex <> NewIndex) then begin List := TList.Create; Owner.GetAllItemsByCategory(CurIndex, List); for I := 0 to List.Count - 1 do TdxBarItem(List[I]).FCategory := dxBarManagerTempCategoryIndex; if CurIndex < NewIndex then for I := CurIndex + 1 to NewIndex do ChangeCategory(I, I - 1) else for I := CurIndex - 1 downto NewIndex do ChangeCategory(I, I + 1); for I := 0 to List.Count - 1 do TdxBarItem(List[I]).FCategory := NewIndex; List.Free; FMoving := True; inherited Move(CurIndex, NewIndex); FMoving := False; end; end; { TdxBarKeyTipData } constructor TdxBarKeyTipData.Create(const AKeyTipInfo: TdxBarKeyTipInfo); begin inherited Create; FKeyTipInfo := AKeyTipInfo; end; procedure TdxBarKeyTipData.HideKeyTipWindow( AKeyTipWindowsManager: IdxBarKeyTipWindowsManager); begin if FKeyTipWindow <> nil then begin AKeyTipWindowsManager.Delete(FKeyTipWindow); FKeyTipWindow := nil; end; end; procedure TdxBarKeyTipData.ShowKeyTipWindow( AKeyTipWindowsManager: IdxBarKeyTipWindowsManager); begin if FKeyTipWindow = nil then AKeyTipWindowsManager.Add(NormalizedKeyTip, BasePoint, HorzAlign, VertAlign, Enabled, FKeyTipWindow); end; function TdxBarKeyTipData.GetNormalizedKeyTip: string; begin Result := AnsiUpperCase(KeyTip); end; { TdxBarPersistent } constructor TdxBarPersistent.Create(ABarManager: TdxBarManager); begin inherited Create; FBarManager := ABarManager; end; function TdxBarPersistent.GetOwner: TPersistent; begin Result := FBarManager; end; {$IFNDEF DELPHI6} destructor TComponentList.Destroy; begin Clear; inherited; end; {$ENDIF} { TdxBarControlEditor } class procedure TdxBarControlEditor.InitCustomizationPopup(AItemLinks: TdxBarItemLinks); var AItemLink: TdxBarItemLink; begin AItemLink := BarDesignController.AddInternalItem(AItemLinks, PopupItemClass, GetPopupItemCaption); InitializePopupItem(AItemLink); end; class function TdxBarControlEditor.GetAddedItemClass(const AAddedItemName: string): TdxBarItemClass; begin Result := nil; end; class function TdxBarControlEditor.GetPopupItemCaption: string; begin Result := ''; end; class procedure TdxBarControlEditor.InitializePopupItem(AItemLink: TdxBarItemLink); begin // do nothing end; class function TdxBarControlEditor.PopupItemClass: TdxBarItemClass; begin Result := nil; end; class procedure TdxBarControlEditor.AddItem(AClickedButton: TdxBarButton); var AItemLink: TdxBarItemLink; begin AItemLink := BarDesignController.AddItem(GetAddedItemClass(AClickedButton.Caption)); InitializeAddedItem(AItemLink, AClickedButton.Caption); // BarDesignController.SelectItem(AItemLink); // AItemLink.BarControl.SetKeySelectedItem(AItemLink.Control); AItemLink.BarControl.SelectItemControl(AItemLink.Control, mbRight, []); end; class procedure TdxBarControlEditor.InitializeAddedItem(AItemLink: TdxBarItemLink; AAddedItemName: string); begin // do nothing end; class procedure TdxBarControlEditor.OnButtonClick(Sender: TObject); begin AddItem(TdxBarButton(Sender)); end; { TdxAddSubItemEditor } class function TdxAddSubItemEditor.GetAddedItemClass(const AAddedItemName: string): TdxBarItemClass; begin Result := TdxBarSubItem; end; class function TdxAddSubItemEditor.GetPopupItemCaption: string; begin Result := dxSBAR_CP_ADDSUBITEM; end; class procedure TdxAddSubItemEditor.InitializePopupItem(AItemLink: TdxBarItemLink); begin TdxBarButton(AItemLink.Item).OnClick := OnButtonClick; AItemLink.Item.Enabled := BarDesignController.CustomizingBarManager.CanAddComponents; end; class function TdxAddSubItemEditor.PopupItemClass: TdxBarItemClass; begin Result := TdxBarButton; end; { TdxAddButtonEditor } class function TdxAddButtonEditor.GetAddedItemClass(const AAddedItemName: string): TdxBarItemClass; begin Result := TdxBarButton; end; class function TdxAddButtonEditor.GetPopupItemCaption: string; begin Result := dxSBAR_CP_ADDBUTTON; end; { TdxAddSeparatorEditor } class function TdxAddSeparatorEditor.GetAddedItemClass(const AAddedItemName: string): TdxBarItemClass; begin Result := TdxBarSeparator; end; class function TdxAddSeparatorEditor.GetPopupItemCaption: string; begin Result := dxSBAR_CP_ADDSEPARATOR; end; { TdxItemsEditorEx } class procedure TdxItemsEditorEx.InitSubItem(AItemLinks: TdxBarItemLinks); var I: Integer; begin for I := 0 to RegdxItemList.VisibleItemCount - 1 do BarDesignController.AddInternalItem(AItemLinks, TdxBarButton, RegdxItemList.VisibleItemClass[I].ClassName, OnButtonClick); end; class function TdxItemsEditorEx.GetAddedItemClass(const AAddedItemName: string): TdxBarItemClass; begin Result := TdxBarItemClass(FindClass(AAddedItemName)); end; class function TdxItemsEditorEx.GetPopupItemCaption: string; begin Result := dxSBAR_CP_ADDDXITEM; end; class procedure TdxItemsEditorEx.InitializePopupItem(AItemLink: TdxBarItemLink); var ASubItem: TdxBarSubItem; begin ASubItem := TdxBarSubItem(AItemLink.Item); ASubItem.Enabled := BarDesignController.CustomizingBarManager.CanAddComponents; ASubItem.IsInternal := True; if ASubItem.Enabled then begin ASubItem.ItemLinks.BeginUpdate; try InitSubItem(ASubItem.ItemLinks); finally ASubItem.ItemLinks.EndUpdate; end; end; end; class function TdxItemsEditorEx.PopupItemClass: TdxBarItemClass; begin Result := TdxBarSubItem; end; { TCustomdxBarControlDesignHelper } class procedure TCustomdxBarControlDesignHelper.FilterItemActions(var ASupportedActions: TdxBarCustomizationActions); begin ASupportedActions := ASupportedActions - GetForbiddenActions; end; class procedure TCustomdxBarControlDesignHelper.GetEditors(AEditors: TList); var I: Integer; begin for I := 0 to BarDesignController.FRegisteredBarControlEditors.Count - 1 do AEditors.Add(BarDesignController.FRegisteredBarControlEditors[I]) end; class function TCustomdxBarControlDesignHelper.GetForbiddenActions: TdxBarCustomizationActions; begin Result := [caChangeButtonPaintStyle, caChangePosition, caChangeViewLevels, caChangeButtonGroup, caChangeRecentList] end; { TdxBarControlDesignHelper } class function TdxBarControlDesignHelper.GetForbiddenActions: TdxBarCustomizationActions; begin Result := inherited GetForbiddenActions - [caChangeButtonPaintStyle]; end; { TdxBarSubMenuControlDesignHelper } class procedure TdxBarSubMenuControlDesignHelper.GetEditors(AEditors: TList); begin inherited GetEditors(AEditors); AEditors.Add(TdxAddSeparatorEditor); end; class function TdxBarSubMenuControlDesignHelper.GetForbiddenActions: TdxBarCustomizationActions; begin Result := inherited GetForbiddenActions - [caChangeRecentList]; end; { TdxBarDesignController } constructor TdxBarDesignController.Create; begin inherited Create; FRegisteredBarControlDesignHelpers := TcxRegisteredClassList.Create; FRegisteredBarControlEditors := TList.Create; FNotifyComponent := TcxFreeNotificator.Create(nil); FNotifyComponent.OnFreeNotification := FreeNotification; FInternalItems := TComponentList.Create; end; destructor TdxBarDesignController.Destroy; begin FreeAndNil(FInternalItems); FreeAndNil(FNotifyComponent); FreeAndNil(FRegisteredBarControlEditors); FreeAndNil(FRegisteredBarControlDesignHelpers); inherited; end; procedure TdxBarDesignController.AddCustomizeItem(AItemLinks: TdxBarItemLinks; AItemClass: TdxBarItemClass; ABeginGroup: Boolean = True); var AItemLink: TdxBarItemlink; begin if AItemLinks.BarManager.CanCustomize then begin AItemLink := AddInternalItem(AItemLinks, AItemClass, cxGetResourceString(@dxSBAR_CUSTOMIZE), CustomizeItemClick); AItemLink.BeginGroup := ABeginGroup; AItemLink.Item.Enabled := dxBarCustomizingForm = nil; end; end; function TdxBarDesignController.AddInternalItem(AItemLinks: TdxBarItemLinks; AItemClass: TdxBarItemClass; ACaption: string; AOnClick: TNotifyEvent = nil; ATag: Integer = 0; ABeginGroup: Boolean = False): TdxBarItemLink; var AItem: TdxBarItem; begin Result := AItemLinks.AddItem(AItemClass, nil); AItem := Result.Item; AddInternalItem(AItem); AItem.Caption := ACaption; AItem.OnClick := AOnClick; AItem.Tag := ATag; Result.BeginGroup := ABeginGroup; end; procedure TdxBarDesignController.AddInternalItem(AItem: TdxBarItem; AList: TList = nil); begin if AList = nil then AList := FInternalItems; AList.Add(AItem); RemoveItemFromBarManagerList(AItem); end; procedure TdxBarDesignController.ClearInternalItems; begin FInternalItems.Clear; end; procedure TdxBarDesignController.RemoveItemFromBarManagerList(AItem: TdxBarItem); begin AItem.BarManager.ItemList.Remove(AItem); end; function TdxBarDesignController.AddItem(ABarItemClass: TdxBarItemClass): TdxBarItemLink; var ACategoryIndex, AItemIndex: Integer; AItem: TdxBarItem; begin CustomizingBarManager.ItemList.BeginUpdate; try FCustomizingItemLinks.BeginUpdate; try Result := FCustomizingItemLinks.AddItem(ABarItemClass, {GetBarManagerForm(FCustomizingBarManager, fkAny).Designer.GetRoot} FCustomizingBarManager.Owner); AItem := Result.Item; ACategoryIndex := FCustomizingBarManager.Categories.IndexOf(dxSBAR_DEFAULTCATEGORYNAME); if ACategoryIndex = -1 then ACategoryIndex := 0; AItem.Category := ACategoryIndex; AItem.Name := FCustomizingBarManager.GetUniqueItemName(ABarItemClass); AItem.Caption := ABarItemClass.GetNewCaption; AItemIndex := FCustomizingItemLinks.IndexOf(CustomizingItemLink); //#DG ! FCustomizingItemLinks.Index if AItemIndex <> -1 then Result.Index := AItemIndex + 1; finally FCustomizingItemLinks.EndUpdate; end; finally CustomizingBarManager.ItemList.EndUpdate; end; end; procedure TdxBarDesignController.SelectItemLink(AItemLink: TdxBarItemLink); begin if (CustomizingBarControl <> nil) and not IsRectEmpty(CustomizingBarControl.GetItemRect(AItemLink.Control)) then begin CustomizingBarControl.BarGetFocus(AItemLink.Control); SelectItem(AItemLink); //#DG new end; end; procedure TdxBarDesignController.DesignerModified; begin FCustomizingBarManager.DesignerModified; end; procedure TdxBarDesignController.DesignerModified(AForm: TCustomForm); begin if not (IsDesignerModifiedLocked or (dsDesignerModifying in FDesignStates)) then begin Include(FDesignStates, dsDesignerModifying); try if (AForm <> nil) and (AForm.Designer <> nil) then AForm.Designer.Modified; finally Exclude(FDesignStates, dsDesignerModifying); end; end; end; function TdxBarDesignController.IsDesignerModifiedLocked: Boolean; begin Result := FLockDesignerModifiedCount > 0; end; procedure TdxBarDesignController.LockDesignerModified; begin Inc(FLockDesignerModifiedCount); end; procedure TdxBarDesignController.UnLockDesignerModified; begin if FLockDesignerModifiedCount > 0 then Dec(FLockDesignerModifiedCount); end; function TdxBarDesignController.IsCustomizedByPopup: Boolean; begin Result := FCustomizationPopup <> nil; end; procedure TdxBarDesignController.RegisterBarControlDesignHelper( ABarControlClass: TCustomdxBarControlClass; AHelperClass: TCustomdxBarControlDesignHelperClass); begin FRegisteredBarControlDesignHelpers.Register(ABarControlClass, AHelperClass); end; procedure TdxBarDesignController.RegisterBarControlEditor(AEditor: TdxBarControlEditorClass); begin FRegisteredBarControlEditors.Add(AEditor); end; procedure TdxBarDesignController.UnregisterBarControlDesignHelper( ABarControlClass: TCustomdxBarControlClass; AHelperClass: TCustomdxBarControlDesignHelperClass); begin FRegisteredBarControlDesignHelpers.Unregister(ABarControlClass, AHelperClass); end; procedure TdxBarDesignController.UnregisterBarControlEditor( AEditor: TdxBarControlEditorClass); begin FRegisteredBarControlEditors.Remove(AEditor); end; procedure TdxBarDesignController.DropSelection(ASelectableItem: IdxBarSelectableItem); begin if IsItemLastSelected(ASelectableItem) then FLastSelectedItem := nil; end; function TdxBarDesignController.IsItemCustomized(ASelectableItem: IdxBarSelectableItem): Boolean; begin Result := IsCustomizedByPopup and (ASelectableItem.GetInstance = FCustomizingItemLink); end; function TdxBarDesignController.IsItemLastSelected(ASelectableItem: IdxBarSelectableItem): Boolean; begin Result := (ASelectableItem <> nil) and (ASelectableItem = LastSelectedItem); end; function TdxBarDesignController.IsItemLinkCustomized: Boolean; begin Result := IsCustomizedByPopup and (FCustomizingItemLink <> nil); end; function TdxBarDesignController.IsItemSingleSelected(ASelectableItem: IdxBarSelectableItem): Boolean; begin Result := (ASelectableItem <> nil) and IsSelectionSingle(ASelectableItem.GetBarManager); end; function TdxBarDesignController.IsSelectionComplex(ABarManager: TdxBarManager): Boolean; var ASelection: TdxObjectList; I: Integer; begin Result := False; ASelection := TdxObjectList.Create; try ABarManager.GetSelection(ASelection); CleanSelectableItems(ASelection); for I := 0 to ASelection.Count - 1 do Result := Result or GetSelectableItem(ASelection[I]).IsComplex; finally ASelection.Free; end; end; function TdxBarDesignController.IsSelectionSingle(ABarManager: TdxBarManager): Boolean; var ASelection: TdxObjectList; begin ASelection := TdxObjectList.Create; try ABarManager.GetSelection(ASelection); CleanSelectableItems(ASelection); Result := ASelection.Count = 1; finally ASelection.Free; end; end; function TdxBarDesignController.NeedDefaultSelection(ASelectableItem: IdxBarSelectableItem): Boolean; begin // Result := IsItemCustomized(ASelectableItem) or IsItemSingleSelected(ASelectableItem) and not IsSelectionComplex(ASelectableItem.GetBarManager); Result := not ASelectableItem.GetBarManager.Designing and IsItemLastSelected(ASelectableItem) or IsSelectionSingle(ASelectableItem.GetBarManager) and (not IsSelectionComplex(ASelectableItem.GetBarManager) or IsItemCustomized(ASelectableItem)); end; procedure TdxBarDesignController.SelectItem(ASelectableItem: IdxBarSelectableItem; ASelectionOperation: TdxBarSelectionOperation = soExclusive); begin if ASelectableItem <> nil then ASelectableItem.SelectComponent(ASelectionOperation); case ASelectionOperation of soAdd, soExclusive: LastSelectedItem := ASelectableItem; soExclude: SynchronizeLastSelectedItem; end; end; procedure TdxBarDesignController.SynchronizeLastSelectedItem; begin if (LastSelectedItem <> nil) and (not LastSelectedItem.IsComponentSelected or not IsApplicationActive)then LastSelectedItem := nil; end; function TdxBarDesignController.DeleteSelectedObjects(ADestruction, AIsKeyboardAction: Boolean): Boolean; function IsComplexItemSelected(ASelection: TdxObjectList): Boolean; var I: Integer; begin Result := False; for I := 0 to ASelection.Count - 1 do Result := Result or (ASelection[I] is TdxBarItem) and (TdxBarItem(ASelection[I]).LinkCount > 1); end; function GetNextSelectedObject(ASelection: TdxObjectList): TPersistent; function CanSelect(AObject: TObject): Boolean; var I: Integer; AMasterObjects: TdxObjectList; ASelectableItem: IdxBarSelectableItem; begin Result := ASelection.IndexOf(AObject) = -1; if Result and Supports(AObject, IdxBarSelectableItem, ASelectableItem) then begin AMasterObjects := TdxObjectList.Create; try ASelectableItem.GetMasterObjects(AMasterObjects); for I := 0 to AMasterObjects.Count - 1 do Result := Result and CanSelect(AMasterObjects[I]); finally AMasterObjects.Free; end; end; end; var ASelectableItem, ANextSelectableItem: IdxBarSelectableItem; begin Result := nil; ASelectableItem := GetSelectableItem(ASelection.Last); ANextSelectableItem := ASelectableItem.GetNextSelectableItem; while (Result = nil) and (ANextSelectableItem <> nil) and (ANextSelectableItem.GetInstance <> ASelectableItem.GetInstance) do begin if CanSelect(ANextSelectableItem.GetInstance) then Result := ANextSelectableItem.GetInstance; ANextSelectableItem := ANextSelectableItem.GetNextSelectableItem; end; if (Result = nil) and CanSelect(ASelectableItem.GetSelectableParent) then Result := ASelectableItem.GetSelectableParent; end; var ASelection: TdxObjectList; ASelectableItem: IdxBarSelectableItem; ANextSelectedObject: TPersistent; I: Integer; begin Result := False; FindCustomizingBarManager; if CanCustomize(CustomizingBarManager, AIsKeyboardAction) then begin if CustomizingBarManager.Designing then begin ASelection := TdxObjectList.Create; try GetSelection(ASelection); RemoveIrrelevantObjects(ASelection, ADestruction); if ASelection.Count > 0 then begin Result := True; if ADestruction or not IsComplexItemSelected(ASelection) or (dxBarMessageBox(dxSBAR_WANTTODELETECOMPLEXITEM, MB_YESNO) = IDYES) then begin CustomizingBarManager.BeginUpdate; try ANextSelectedObject := GetNextSelectedObject(ASelection); for I := ASelection.Count - 1 downto 0 do begin ASelectableItem := GetSelectableItem(ASelection[I]); ASelectableItem.DeleteSelection(ASelectableItem, ADestruction); end; if ANextSelectedObject <> nil then CustomizingBarManager.SelectComponent(ANextSelectedObject); finally CustomizingBarManager.EndUpdate; end; DesignerModified; end; end; finally ASelection.Free; end; end else CustomizingBarManager.LastSelectedLinkAtDesign.Free; end; end; procedure TdxBarDesignController.DeleteCustomizingItem; begin if FCustomizingItemLink = nil then Exit; FCustomizingItemLink.Item.Free; FCustomizingItemLink := nil; end; procedure TdxBarDesignController.DeleteCustomizingItemLink; begin FreeAndNil(FCustomizingItemLink); end; function TdxBarDesignController.SelectParentComponent: Boolean; var ASelectedObjects: TdxObjectList; ASelectableItem: IdxBarSelectableItem; begin FindCustomizingBarManager; if CanCustomize(CustomizingBarManager, True) then begin ASelectedObjects := TdxObjectList.Create; try CustomizingBarManager.GetActiveSelection(ASelectedObjects); Result := Supports(ASelectedObjects.Last, IdxBarSelectableItem, ASelectableItem) and ASelectableItem.SelectParentComponent; finally ASelectedObjects.Free; end; end else Result := False; end; procedure TdxBarDesignController.ShowCustomCustomizePopup(ABarManager: TdxBarManager; AInitPopupProc: TInitPopupProc; APainter: TdxBarPainter; ACustomizingBarControl: TCustomdxBarControl = nil; ACustomizingItemLink: TdxBarItemLink = nil); procedure DeactivateCustomizingItem; begin // if (FCustomizingBarControl <> nil) and FCustomizingBarControl.IsFocused then // FCustomizingBarControl.SetMouseSelectedItem(GetControlByLink(FCustomizingItemLink)); if (FCustomizingBarControl <> nil) and (FCustomizingBarControl.SelectedControl <> nil) then FCustomizingBarControl.SelectedControl.ControlInactivate(False); end; begin ClearInternalItems; FCustomizingBarControl := ACustomizingBarControl; FCustomizingItemLink := ACustomizingItemLink; FCustomizingBarManager := ABarmanager; FCustomizationPopup := TdxBarCustomizingPopup.Create(FCustomizingBarManager); if ACustomizingBarControl <> nil then FCustomizationPopup.ParentWnd := ACustomizingBarControl.Handle; FCustomizationPopup.FPainter := APainter; FCustomizationPopup.OnCloseUp := CustomizationPopupCloseUp; FCustomizationPopup.OnDestroy := CustomizationPopupDestroy; AInitPopupProc(FCustomizationPopup.ItemLinks); if FCustomizationPopup.ItemLinks.Count > 0 then begin DeactivateCustomizingItem; FCustomizationPopup.DoShowCustomizingPopup; FCustomizationPopup.Left := GetMouseCursorPos.X; FCustomizationPopup.Top := GetMouseCursorPos.Y; FCustomizationPopup.Show; end else FreeAndNil(FCustomizationPopup); end; procedure TdxBarDesignController.ShowCustomizePopup(ABarControl: TCustomdxBarControl; ACustomizingItemLink: TdxBarItemLink); begin FCustomizingItemLinks := ABarControl.ItemLinks; ShowCustomCustomizePopup(ABarControl.Barmanager, InitCustomizationPopup, ABarControl.Painter, ABarControl, ACustomizingItemLink); end; procedure TdxBarDesignController.SetCustomizePopupTopMosts(AShow: Boolean); var APrevBarControl, ABarControl: TCustomdxBarControl; begin if AShow then begin dxSetZOrder(FCustomizationPopup.Handle); APrevBarControl := FCustomizationPopup; if CustomizingItemLink.Control <> nil then begin ABarControl := CustomizingBarControl; repeat dxSetZOrder(ABarControl.Handle, APrevBarControl.Handle); APrevBarControl := ABarControl; ABarControl := ABarControl.ParentBar; until ABarControl = nil; end; end else begin if CustomizingItemLink.Control <> nil then begin ABarControl := CustomizingBarControl; while ABarControl.ParentBar <> nil do ABarControl := ABarControl.ParentBar; repeat dxSetZOrder(ABarControl.Handle, HWND_NOTOPMOST); ABarControl := ABarControl.ChildBar; until ABarControl = nil; end; dxSetZOrder(FCustomizationPopup.Handle, HWND_NOTOPMOST); end; end; procedure TdxBarDesignController.InitToolBarPopup(AItemLinks: TdxBarItemLinks); var I: Integer; ABars: TdxBars; ABar: TdxBar; AItem: TdxBarButton; AItemLink: TdxBarItemLink; begin ClearOwnedItems(AItemLinks); ABars := AItemLinks.BarManager.Bars; for I := 0 to ABars.Count - 1 do begin ABar := ABars[I]; if ABar.CanClose and not ABar.Hidden and (ABar.MergeData.MergedWith = nil) then begin AItemLink := AddInternalItem(AItemLinks, TdxBarButton, ABar.Caption, ToolbarsPopupClick); AItem := TdxBarButton(AItemLink.Item); AItem.Tag := Integer(ABar); AItem.ButtonStyle := bsChecked; AItem.Down := ABars[I].Visible; end; end; AddCustomizeItem(AItemLinks, TdxBarButton); end; procedure TdxBarDesignController.ShowToolbarsPopup(ABarManager: TdxBarManager; APainter: TdxBarPainter); var AToolbarsPopup: TdxBarToolbarsPopup; begin ClearInternalItems; FCustomizingBarManager := ABarManager; AToolbarsPopup := TdxBarToolbarsPopup.Create(ABarManager); AToolbarsPopup.FPainter := APainter; InitToolBarPopup(AToolbarsPopup.ItemLinks); ABarManager.DoShowToolbarsPopup(AToolbarsPopup.ItemLinks); if AToolbarsPopup.FItemLinks.Count = 0 then AToolbarsPopup.Free else begin ABarManager.HideAll; AToolbarsPopup.Left := GetMouseCursorPos.X; AToolbarsPopup.Top := GetMouseCursorPos.Y; AToolbarsPopup.FShowAnimation := True; AToolbarsPopup.Show; end; end; procedure TdxBarDesignController.ShowQuickControl(ABarControl: TdxBarControl; AOwnerRect: TRect); begin FCustomizingBarManager := ABarControl.Barmanager; FQuickControl := ABarControl.GetQuickControlClass.CreateForPopup(ABarControl, ABarControl.Bar); FQuickControl.FPainter := ABarControl.Painter; FQuickControl.OnDestroy := QuickControlDestroy; ABarControl.InitQuickControl(FQuickControl.ItemLinks); FQuickControl.Popup(AOwnerRect); PlaySound(psMenuPopup); end; function TdxBarDesignController.CanDeleteSelectedObjects: Boolean; var ASelection: TdxObjectList; begin ASelection := TdxObjectList.Create; try GetSelection(ASelection); RemoveIrrelevantObjects(ASelection); Result := ASelection.Count > 0; finally ASelection.Free; end; end; procedure TdxBarDesignController.GetSelection(ASelection: TdxObjectList); begin CustomizingBarManager.GetSelection(ASelection); CleanSelectableItems(ASelection); end; procedure TdxBarDesignController.RemoveIrrelevantObjects(ASelection: TdxObjectList; ADestruction: Boolean = False); var I: Integer; begin for I := ASelection.Count - 1 downto 0 do if not GetSelectableItem(ASelection[I]).CanDelete(ADestruction) then ASelection.Delete(I); end; procedure TdxBarDesignController.ClearOwnedItems(AItemLinks: TdxBarItemLinks); begin while AItemLinks.Count > 0 do AItemLinks.Items[0].Item.Free; end; procedure TdxBarDesignController.CustomizeItemClick(Sender: TObject); begin TdxBarItem(Sender).BarManager.Customizing(True); end; procedure TdxBarDesignController.TextItemChange(Sender: TObject); begin if TdxBarEdit(Sender).Text = '' then begin if FCustomizationPopup <> nil then FCustomizationPopup.Hide; dxBarMessageBox(cxGetResourceString(@dxSBAR_COMMANDNAMECANNOTBEBLANK), MB_ICONSTOP); end else if FCustomizingBarManager.Designing then begin CustomizingItemLink.Item.Caption := TdxBarEdit(Sender).Text; SynchronizeAction(caChangeCaption); end else CustomizingItemLink.UserCaption := TdxBarEdit(Sender).Text; end; procedure TdxBarDesignController.CustomizationPopupCloseUp(Sender: TObject); begin { #DG problems when customize empty subcontrol if (FCustomizingItemLink <> nil) and not FCustomizingBarManager.FIsCustomizing and (FCustomizingBarControl <> nil) and (FCustomizingBarControl.SelectedItem = FCustomizingItemLink.Control) then begin FCustomizingBarManager.FSelectedItem := nil; FCustomizingBarControl.SelectedItem := nil; end; } FCustomizingBarControl := nil; end; procedure TdxBarDesignController.CustomizationPopupDestroy(Sender: TObject); begin FCustomizationPopup := nil; end; procedure TdxBarDesignController.CustomizationPopupItemClick(Sender: TObject); procedure ChangeButtonGroup(AButtonGroupAction: TdxChangeButtonGroupAction); const AGroupPosition: array[TdxChangeButtonGroupAction] of TdxBarButtonGroupPosition = (bgpNone, bgpStart, bgpMember, bgpMember, bgpNone); procedure MakeButtonGroup; var I: Integer; ALink: TdxBarItemLink; begin FCustomizingItemLinks.BeginUpdate; try ALink := CustomizingItemLink; for I := FCustomizingItemLinks.Count - 1 downto 0 do if FCustomizingItemLinks[I].IsComponentSelected then begin ALink := FCustomizingItemLinks[I]; ALink.ButtonGroup := AGroupPosition[AButtonGroupAction]; end; if AButtonGroupAction = bgaGroup then ALink.ButtonGroup := bgpStart; finally FCustomizingItemLinks.EndUpdate; end; end; begin if AButtonGroupAction in [bgaNone..bgaMember] then begin CustomizingItemLink.ButtonGroup := AGroupPosition[AButtonGroupAction]; SynchronizeAction(caChangeButtonGroup); end else MakeButtonGroup; end; procedure ChangeViewLevel(AViewLevelAction: TdxChangeViewLevelAction); var AViewLevel: TdxBarItemRealViewLevel; begin case AViewLevelAction of vlaChangeLargeIconWithText..vlaChangeControl: begin AViewLevel := TdxBarItemViewLevel(AViewLevelAction); if AViewLevel in CustomizingItemLink.ViewLevels then CustomizingItemLink.ViewLevels := CustomizingItemLink.ViewLevels - [AViewLevel] else CustomizingItemLink.ViewLevels := CustomizingItemLink.ViewLevels + [AViewLevel]; end; vlaSetAll: CustomizingItemLink.ViewLevels := [ivlLargeIconWithText..ivlControlOnly]; vlaSetLargeIconWithTextOnly: CustomizingItemLink.ViewLevels := [ivlLargeIconWithText]; vlaSetSmallIconWithTextOnly: CustomizingItemLink.ViewLevels := [ivlSmallIconWithText]; vlaSetSmallIconOnly: CustomizingItemLink.ViewLevels := [ivlSmallIcon]; vlaControlOnly: CustomizingItemLink.ViewLevels := [ivlControlOnly]; end; end; var ADetailAction: WORD; ABasicAction: TdxBarCustomizationAction; ABarButton: TdxBarButton; begin ABarButton := TdxBarButton(Sender); ABasicAction := TdxBarCustomizationAction(HiWord(ABarButton.Tag)); ADetailAction := LoWord(ABarButton.Tag); case ABasicAction of caDelete: DeleteSelectedObjects(False, False); caDeleteItem: DeleteSelectedObjects(True, False); caDeleteLink: DeleteCustomizingItemLink; // multiple operations caReset: CustomizingItemLink.UserDefine := []; caChangeButtonPaintStyle: CustomizingItemLink.UserPaintStyle := TdxBarPaintStyle(ADetailAction); caChangePosition: CustomizingItemLink.Position := TdxBarItemPosition(ADetailAction); caChangeViewLevels: begin ChangeViewLevel(TdxChangeViewLevelAction(ADetailAction)); UpdateViewLevelsSubItemButtonStates(ABarButton.Links[0].Owner); end; caChangeButtonGroup: ChangeButtonGroup(TdxChangeButtonGroupAction(ADetailAction)); caChangeBeginGroup: CustomizingItemLink.BeginGroup := not CustomizingItemLink.BeginGroup; caChangeVisible: CustomizingItemLink.Visible := not CustomizingItemLink.Visible; caChangeRecentList: CustomizingItemLink.MostRecentlyUsed := not CustomizingItemLink.MostRecentlyUsed; end; if not (ABasicAction in [caDelete, caDeleteItem, caDeleteLink, caChangeButtonGroup]) then SynchronizeAction(ABasicAction); end; procedure TdxBarDesignController.InitCustomizationPopup(AItemLinks: TdxBarItemLinks); function AddCustomizationButton(AItemLinks: TdxBarItemLinks; const ACaption: string; ABasicAction: TdxBarCustomizationAction; ABeginGroup: Boolean = False; AButtonStyle: TdxBarButtonStyle = bsDefault; AIsDown: Boolean = False; AEnabled: Boolean = True; AGroupIndex: Integer = 0; ADetailAction: Word = 0): TdxBarButton; var AItemLink: TdxBarItemLink; AItem: TdxBarButton; begin AItemLink := AddInternalItem(AItemLinks, TdxBarButton, ACaption, CustomizationPopupItemClick); AItemLink.BeginGroup := ABeginGroup; AItem := TdxBarButton(AItemLink.Item); AItem.Tag := MakeLong(ADetailAction, Word(ABasicAction)); AItem.ButtonStyle := AButtonStyle; AItem.Down := AIsDown; AItem.Enabled := AEnabled; AItem.GroupIndex := AGroupIndex; Result := AItem; end; procedure AddCustomizationEdit(AItemLinks: TdxBarItemLinks; const ACaption: string); var AItemLink: TdxBarItemLink; begin AItemLink := AddInternalItem(AItemLinks, TdxBarEdit, ACaption); AItemLink.BeginGroup := True; TdxBarEdit(AItemLink.Item).Text := CustomizingItemLink.Caption; TdxBarEdit(AItemLink.Item).FOnChange := TextItemChange; end; function AddCustomizationSubItem(AItemLinks: TdxBarItemLinks; const ACaption: string; AActionType: TdxBarCustomizationAction; ABeginGroup: Boolean = False; AEnabled: Boolean = True): TdxBarSubItem; var AItemLink: TdxBarItemLink; begin AItemLink := AddInternalItem(AItemLinks, TdxBarSubItem, ACaption); Result := TdxBarSubItem(AItemLink.Item); AItemLink.BeginGroup := ABeginGroup; Result.Enabled := AEnabled; Result.IsInternal := True; end; function GetBarControlDesignHelperClass: TCustomdxBarControlDesignHelperClass; begin Result := TCustomdxBarControlDesignHelperClass( FRegisteredBarControlDesignHelpers.FindClass(CustomizingBarControl.ClassType)); end; function GetSupportedActions: TdxBarCustomizationActions; var ASelection: TdxObjectList; I: Integer; ASelectableItem: IdxBarSelectableItem; begin Result := FLastSelectedItem.GetSupportedActions; if CustomizingBarManager.Designing then begin ASelection := TdxObjectList.Create; try GetSelection(ASelection); for I := 0 to ASelection.Count - 1 do begin ASelectableItem := GetSelectableItem(ASelection[I]); Result := Result * ASelectableItem.GetSupportedActions; end; finally ASelection.Free; end; end; end; procedure AddViewLevelMenu; function GetButtonStyle(AViewLevelAction: TdxChangeViewLevelAction): TdxBarButtonStyle; begin if AViewLevelAction in [vlaChangeLargeIconWithText..vlaChangeControl] then Result := bsChecked else Result := bsDefault; end; function GetButtonCaption(AViewLevelAction: TdxChangeViewLevelAction; AViewLevelNames: TStringArray): string; begin case AViewLevelAction of vlaChangeLargeIconWithText..vlaChangeControl: Result := AViewLevelNames[Ord(AViewLevelAction)]; vlaSetAll: Result := cxGetResourceString(@dxSBAR_CP_ALLVIEWLEVELS); else Result := AViewLevelNames[Ord(AViewLevelAction) - Ord(vlaSetLargeIconWithTextOnly)] + cxGetResourceString(@dxSBAR_CP_SINGLEVIEWLEVELITEMSUFFIX); end; end; var AViewLevelAction: TdxChangeViewLevelAction; AViewLevelNames: TStringArray; AOwnerLinks: TdxBarItemLinks; begin AViewLevelNames := SetToStringArray(TypeInfo(TdxBarItemViewLevels)); AOwnerLinks := AddCustomizationSubItem(AItemLinks, cxGetResourceString(@dxSBAR_CP_VIEWLEVELSMENU), caChangeViewLevels).ItemLinks; for AViewLevelAction := Low(TdxChangeViewLevelAction) to High(TdxChangeViewLevelAction) do AddCustomizationButton(AOwnerLinks, GetButtonCaption(AViewLevelAction, AViewLevelNames), caChangeViewLevels, AViewLevelAction in [vlaSetAll, vlaSetLargeIconWithTextOnly], GetButtonStyle(AViewLevelAction), False, True, 0, Word(AViewLevelAction)).CloseSubMenuOnClick := False; UpdateViewLevelsSubItemButtonStates(AOwnerLinks); end; procedure AddButtonPaintStyleMenu; const APaintStyleCaptions: array [TdxBarPaintStyle] of TcxResourceStringID = (@dxSBAR_CP_DEFAULTSTYLE, @dxSBAR_CP_TEXTONLYALWAYS, @dxSBAR_CP_TEXTONLYINMENUS, @dxSBAR_CP_IMAGEANDTEXT); var APaintStyle: TdxBarPaintStyle; AOwnerLinks: TdxBarItemLinks; begin { unusually if CustomizingBarManager.Designing then AOwnerLinks := AddCustomizationSubItem(AItemLinks, cxGetResourceString(@dxSBAR_CP_BUTTONPAINTSTYLEMENU), caChangeButtonPaintStyle, True).ItemLinks else } AOwnerLinks := AItemLinks; for APaintStyle := Low(TdxBarPaintStyle) to High(TdxBarPaintStyle) do AddCustomizationButton(AOwnerLinks, cxGetResourceString(APaintStyleCaptions[APaintStyle]), caChangeButtonPaintStyle, APaintStyle = Low(TdxBarPaintStyle), bsChecked, CustomizingItemLink.PaintStyle = APaintStyle, CustomizingItemLink.CanChangePaintStyle, dxBarCustomizingPopupPaintStyleGroupIndex, Word(APaintStyle)); end; procedure AddPositionMenu; var APosition: TdxBarItemPosition; APositionNames: TStringArray; AOwnerLinks: TdxBarItemLinks; begin APositionNames := EnumToStringArray(TypeInfo(TdxBarItemPosition)); AOwnerLinks := AddCustomizationSubItem(AItemLinks, cxGetResourceString(@dxSBAR_CP_POSITIONMENU), caChangePosition, True).ItemLinks; for APosition := Low(TdxBarItemPosition) to High(TdxBarItemPosition) do AddCustomizationButton(AOwnerLinks, APositionNames[Ord(APosition)], caChangePosition, False, bsChecked, CustomizingItemLink.Position = APosition, True, 0, Word(APosition)); end; procedure AddButtonGroupMenu; function IsDowned(AButtonGroupAction: TdxChangeButtonGroupAction): Boolean; begin Result := (AButtonGroupAction in [bgaNone..bgaMember]) and (CustomizingItemLink.ButtonGroup = TdxBarButtonGroupPosition(AButtonGroupAction)); end; function GetByttonStyle(AButtonGroupAction: TdxChangeButtonGroupAction): TdxBarButtonStyle; begin if AButtonGroupAction in [bgaNone..bgaMember] then Result := bsChecked else Result := bsDefault; end; function GetButtonCaption(AButtonGroupAction: TdxChangeButtonGroupAction; AButtonGroupNames: TStringArray): string; begin case AButtonGroupAction of bgaGroup: Result := cxGetResourceString(@dxSBAR_CP_BUTTONGROUP); bgaUngroup: Result := cxGetResourceString(@dxSBAR_CP_BUTTONUNGROUP); else Result := AButtonGroupNames[Ord(AButtonGroupAction)]; end; end; var AButtonGroupAction: TdxChangeButtonGroupAction; AButtonGroupNames: TStringArray; AOwnerLinks: TdxBarItemLinks; begin AButtonGroupNames := EnumToStringArray(TypeInfo(TdxBarButtonGroupPosition)); AOwnerLinks := AddCustomizationSubItem(AItemLinks, cxGetResourceString(@dxSBAR_CP_BUTTONGROUPMENU), caChangeButtonGroup).ItemLinks; for AButtonGroupAction := Low(TdxChangeButtonGroupAction) to High(TdxChangeButtonGroupAction) do AddCustomizationButton(AOwnerLinks, GetButtonCaption(AButtonGroupAction, AButtonGroupNames), caChangeButtonGroup, AButtonGroupAction = bgaGroup, GetByttonStyle(AButtonGroupAction), IsDowned(AButtonGroupAction), True, 0, Word(AButtonGroupAction)); end; const AChangeCaptionName: array [Boolean] of TcxResourceStringID = (@dxSBAR_CP_NAME, @dxSBAR_CP_CAPTION); ADeleteLinkName: array [Boolean] of TcxResourceStringID = (@dxSBAR_CP_DELETE, @dxSBAR_CP_DELETELINK); var ABarControlEditors: TList; I: Integer; AAction: TdxBarCustomizationAction; ASupportedActions: TdxBarCustomizationActions; begin AItemLinks.BeginUpdate; try FCustomizingBarManager.ItemList.BeginUpdate; try if FCustomizingBarManager.Designing and IsSelectionSingle(FCustomizingBarManager) then begin ABarControlEditors := TList.Create; try GetBarControlDesignHelperClass.GetEditors(ABarControlEditors); for I := 0 to ABarControlEditors.Count - 1 do TdxBarControlEditorClass(ABarControlEditors[I]).InitCustomizationPopup(AItemLinks); finally FreeAndNil(ABarControlEditors); end; end; ASupportedActions := GetSupportedActions; GetBarControlDesignHelperClass.FilterItemActions(ASupportedActions); for AAction := Low(TdxBarCustomizationAction) to High(TdxBarCustomizationAction) do if AAction in ASupportedActions then case AAction of caReset: AddCustomizationButton(AItemLinks, cxGetResourceString(@dxSBAR_CP_RESET), AAction, True); caDelete: AddCustomizationButton(AItemLinks, cxGetResourceString(@dxSBAR_CP_DELETE), AAction, True, bsDefault, False, CanDeleteSelectedObjects).ShortCut := VK_DELETE; caDeleteItem: AddCustomizationButton(AItemLinks, cxGetResourceString(@dxSBAR_CP_DELETEITEM), AAction, False, bsDefault, False, CustomizingItemLink.Item.CanDelete(True)).ShortCut := ShortCut(VK_DELETE, [ssCtrl]); caDeleteLink: AddCustomizationButton(AItemLinks, cxGetResourceString(ADeleteLinkName[FCustomizingBarManager.Designing]), AAction, False, bsDefault, False); caChangeCaption: AddCustomizationEdit(AItemLinks, cxGetResourceString(AChangeCaptionName[FCustomizingBarManager.Designing])); caChangeButtonPaintStyle: AddButtonPaintStyleMenu; caChangePosition: AddPositionMenu; caChangeViewLevels: AddViewLevelMenu; caChangeButtonGroup: AddButtonGroupMenu; caChangeBeginGroup: AddCustomizationButton(AItemLinks, cxGetResourceString(@dxSBAR_CP_BEGINAGROUP), AAction, True, bsChecked, CustomizingItemLink.BeginGroup, CustomizingItemLink.Index > 0); caChangeVisible: AddCustomizationButton(AItemLinks, cxGetResourceString(@dxSBAR_CP_VISIBLE), AAction, not (caChangeBeginGroup in ASupportedActions), bsChecked, CustomizingItemLink.Visible); caChangeRecentList: AddCustomizationButton(AItemLinks, cxGetResourceString(@dxSBAR_CP_MOSTRECENTLYUSED), AAction, False, bsChecked, CustomizingItemLink.MostRecentlyUsed); end; finally FCustomizingBarManager.ItemList.EndUpdate(False); end; finally AItemLinks.EndUpdate; end; end; procedure TdxBarDesignController.SynchronizeAction(ABasicAction: TdxBarCustomizationAction); var I: Integer; ASelection: TdxObjectList; begin ASelection := TdxObjectList.Create; try GetSelection(ASelection); for I := 0 to ASelection.Count - 1 do GetSelectableItem(ASelection[I]).ExecuteCustomizationAction(ABasicAction); finally ASelection.Free; end; end; procedure TdxBarDesignController.UpdateViewLevelsSubItemButtonStates(AItemLinks: TdxBarItemLinks); var I: Integer; AButton: TdxBarButton; begin for I := 0 to AItemLinks.Count - 1 do begin AButton := TdxBarButton(AItemLinks[I].Item); if TdxChangeViewLevelAction(LoWord(AButton.Tag)) in [vlaChangeLargeIconWithText..vlaChangeControl] then AButton.Down := TdxBarItemViewLevel(LoWord(AButton.Tag)) in CustomizingItemLink.ViewLevels; end; end; procedure TdxBarDesignController.ToolbarsPopupClick(Sender: TObject); var ABar: TdxBar; begin ABar := TdxBar(TComponent(Sender).Tag); ABar.Visible := not ABar.Visible; end; procedure TdxBarDesignController.QuickControlDestroy(Sender: TObject); begin FQuickControl := nil; end; procedure TdxBarDesignController.FindCustomizingBarManager; var I: Integer; ASelection: TdxObjectList; begin if LastSelectedItem <> nil then FCustomizingBarManager := LastSelectedItem.GetBarManager else begin ASelection := TdxObjectList.Create; try FCustomizingBarManager := nil; for I := 0 to dxBarManagerList.Count - 1 do begin dxBarManagerList[I].GetActiveSelection(ASelection); CleanSelectableItems(ASelection); if ASelection.Count > 0 then begin FCustomizingBarManager := dxBarManagerList[I]; Break; end; end; finally ASelection.Free; end; end; end; function TdxBarDesignController.CanCustomize(ABarManager: TdxBarManager; AIsKeyboardAction: Boolean): Boolean; begin Result := (ABarManager <> nil) and (not AIsKeyboardAction or (ABarManager.Owner.HandleAllocated) and (IsParentFocused(ABarManager.Owner.Handle))); end; procedure TdxBarDesignController.SetLastSelectedItem(Value: IdxBarSelectableItem); procedure UpdateItem(ASelectedItem: IdxBarSelectableItem; AOperation: TOperation); var AInstance: TPersistent; begin if ASelectedItem <> nil then begin ASelectedItem.Invalidate; //#DG for RunTime only AInstance := ASelectedItem.GetInstance; if AInstance is TComponent then case AOperation of opInsert: FNotifyComponent.FreeNotification(TComponent(AInstance)); opRemove: FNotifyComponent.RemoveFreeNotification(TComponent(AInstance)); end; end; end; var APrevSelectedItem: IdxBarSelectableItem; begin if FLastSelectedItem <> Value then begin APrevSelectedItem := FLastSelectedItem; FLastSelectedItem := Value; UpdateItem(APrevSelectedItem, opRemove); UpdateItem(FLastSelectedItem, opInsert); end; end; procedure TdxBarDesignController.FreeNotification(AComponent: TComponent); begin DropSelection(GetSelectableItem(AComponent)); end; { TdxBarCanvas } constructor TdxBarCanvas.Create; begin inherited Create(TCanvas.Create); end; destructor TdxBarCanvas.Destroy; begin Canvas.Free; inherited; end; procedure TdxBarCanvas.BeginPaint(ADC: THandle); begin SetLength(FSavedDCs, FCounter + 1); if HandleValid then begin SaveState; FSavedDCs[FCounter].PrevDC := Handle; end else FSavedDCs[FCounter].PrevDC := 0; FSavedDCs[FCounter].NewDC := ADC; FSavedDCs[FCounter].NewDCIndex := Windows.SaveDC(ADC); SynchronizeObjects(ADC); Canvas.Handle := ADC; Inc(FCounter); end; procedure TdxBarCanvas.BeginPaint(ACanvas: TcxCanvas); begin BeginPaint(ACanvas.Handle); end; procedure TdxBarCanvas.EndPaint; begin if FCounter > 0 then begin Dec(FCounter); Canvas.Handle := FSavedDCs[FCounter].PrevDC; Windows.RestoreDC(FSavedDCs[FCounter].NewDC, FSavedDCs[FCounter].NewDCIndex); if HandleValid then RestoreState; SetLength(FSavedDCs, FCounter); end; end; function TdxBarCanvas.HandleValid; begin Result := {$IFDEF DELPHI6}Canvas.HandleAllocated{$ELSE}FCounter > 0{$ENDIF}; end; { TdxBarComponent } constructor TdxBarComponent.Create(AOwner: TComponent); begin inherited; FChangeNotifies := TObjectList.Create(False); end; destructor TdxBarComponent.Destroy; begin FreeAndNil(FChangeNotifies); inherited; end; procedure TdxBarComponent.AddChangeNotify(AComponentList: TdxBarComponentList); begin FChangeNotifies.Add(AComponentList); end; procedure TdxBarComponent.RemoveChangeNotify(AComponentList: TdxBarComponentList); begin FChangeNotifies.Remove(AComponentList); end; procedure TdxBarComponent.Changed(AllItems: Boolean = False); var I: Integer; begin if not (csDestroying in ComponentState) then for I := 0 to FChangeNotifies.Count - 1 do if AllItems then TdxBarComponentList(FChangeNotifies[I]).Update(nil) else TdxBarComponentList(FChangeNotifies[I]).Update(Self); end; procedure TdxBarComponent.GetMasterObjects(AList: TdxObjectList); begin AList.Add(Owner); end; function TdxBarComponent.GetNextSelectableItem: IdxBarSelectableItem; begin Result := nil; end; function TdxBarComponent.GetSelectableParent: TPersistent; begin Result := Owner; end; function TdxBarComponent.CanDelete(ADestruction: Boolean = False): Boolean; begin Result := BarManager.CanDeleteComponent(Self); end; procedure TdxBarComponent.DeleteSelection(var AReference: IdxBarSelectableItem; ADestruction: Boolean); begin if CanDelete(ADestruction) then begin AReference := nil; Free; end; end; procedure TdxBarComponent.ExecuteCustomizationAction(ABasicAction: TdxBarCustomizationAction); begin // do nothing end; function TdxBarComponent.GetBarManager: TdxBarManager; begin Result := FBarManager; end; function TdxBarComponent.GetSelectionStatus: TdxBarSelectionStatus; begin Result := BarManager.GetSelectionStatus(Self); end; function TdxBarComponent.GetSupportedActions: TdxBarCustomizationActions; begin Result := [caDelete]; end; procedure TdxBarComponent.Invalidate; begin // do nothing end; function TdxBarComponent.IsComplex: Boolean; begin Result := False; end; function TdxBarComponent.IsComponentSelected: Boolean; begin Result := BarManager.IsComponentSelected(Self); end; procedure TdxBarComponent.SelectComponent(ASelectionOperation: TdxBarSelectionOperation = soExclusive); begin BarManager.SelectComponent(Self, ASelectionOperation); end; function TdxBarComponent.SelectParentComponent: Boolean; begin Result := False; end; procedure TdxBarComponent.SelectionChanged; begin // do nothing end; function TdxBarComponent.GetPersistentInstance: TPersistent; begin Result := Self; end; function TdxBarComponent.GetComponentInstance: TComponent; begin Result := Self; end; { TdxObjectList } constructor TdxObjectList.Create; begin inherited Create(False); end; procedure TdxObjectList.Add(AObject: TObject); begin if (AObject <> nil) and (IndexOf(AObject) = -1) then inherited Add(AObject); end; procedure TdxObjectList.AddList(AObjects: TList); begin AddFromList(AObjects, Self); end; procedure TdxObjectList.CopyFrom(ASource: TList); begin CopyList(ASource, Self); end; procedure TdxObjectList.CopyTo(ADestination: TList); begin CopyList(Self, ADestination); end; procedure TdxObjectList.XorList(ASourceA, ASourceB: TList); begin Clear; AddFromList(ASourceA, ASourceB); AddFromList(ASourceB, ASourceA); end; function TdxObjectList.First: TObject; begin Result := GetItem(0); end; function TdxObjectList.Last: TObject; begin Result := GetItem(Count - 1); end; procedure TdxObjectList.CopyList(ASource, ADestination: TList); var I: Integer; begin ADestination.Clear; ADestination.Capacity := ASource.Capacity; for I := 0 to ASource.Count - 1 do if ADestination is TdxObjectList then TdxObjectList(ADestination).Add(ASource[I]) else ADestination.Add(ASource[I]); end; function TdxObjectList.GetItem(AIndex: Integer): TObject; begin if (AIndex >= 0) and (AIndex < Count) then Result := inherited GetItem(AIndex) else Result := nil; end; procedure TdxObjectList.AddFromList(ASource, AExcludedList: TList); var I: Integer; begin for I := 0 to ASource.Count - 1 do if AExcludedList.IndexOf(ASource[I]) = -1 then Add(ASource[I]); end; { TdxEventHandlerCollection } procedure TdxEventHandlerCollection.Add(AEvent: TdxEventHandler); var ALength: Integer; begin if IndexOf(AEvent) <> -1 then Exit; ALength := Length(FEvents); SetLength(FEvents, ALength + 1); FEvents[ALength] := AEvent; end; procedure TdxEventHandlerCollection.CallEvents(Sender: TObject; const AEventArgs); var I: Integer; begin for I := Low(FEvents) to High(FEvents) do FEvents[I](Sender, AEventArgs); end; procedure TdxEventHandlerCollection.Delete(AIndex: Integer); var ALength, I: Integer; begin ALength := Length(FEvents); if (AIndex < 0) or (AIndex >= ALength) then Exit; for I := AIndex to ALength - 2 do FEvents[I] := FEvents[I + 1]; SetLength(FEvents, ALength - 1); end; function TdxEventHandlerCollection.IndexOf(AEvent: TdxEventHandler): Integer; function IsEventsEqual(AEvent1, AEvent2: TdxEventHandler): Boolean; begin Result := (TMethod(AEvent1).Code = TMethod(AEvent2).Code) and (TMethod(AEvent1).Data = TMethod(AEvent2).Data); end; var I: Integer; begin Result := -1; for I := Low(FEvents) to High(FEvents) do if IsEventsEqual(AEvent, FEvents[I]) then begin Result := I; Break; end; end; procedure TdxEventHandlerCollection.Remove(AEvent: TdxEventHandler); begin Delete(IndexOf(AEvent)); end; { TdxComponentList } destructor TdxComponentList.Destroy; begin FUpdateCount := 1; inherited Destroy; end; procedure TdxComponentList.BeginUpdate; begin Inc(FUpdateCount); end; procedure TdxComponentList.EndUpdate(AForceUpdate: Boolean = True); begin Dec(FUpdateCount); if AForceUpdate then Update; end; procedure TdxComponentList.DoNotify(AItem: TComponent; AAction: TListNotification); function ConvertNotificaton(ANotification: TListNotification): TcxComponentCollectionNotification; begin case ANotification of lnAdded: Result := ccnAdded; lnExtracted: Result := ccnExtracted; else {lnDeleted} Result := ccnDeleting; end; end; begin inherited Notify(AItem, AAction); if Assigned(OnNotify) then OnNotify(Self, AItem, AAction); Update(AItem, ConvertNotificaton(AAction)); end; function TdxComponentList.GetItemClass: TClass; begin Result := TComponent; end; procedure TdxComponentList.Notify(Ptr: Pointer; Action: TListNotification); begin if TObject(Ptr) is GetItemClass then DoNotify(Ptr, Action) else if Action = lnAdded then Extract(Ptr); end; procedure TdxComponentList.Update(AItem: TComponent = nil; AAction: TcxComponentCollectionNotification = ccnChanged); begin if (FUpdateCount = 0) and Assigned(OnComponentListChanged) then OnComponentListChanged(Self, AItem, AAction); end; { TdxBarComponentList } procedure TdxBarComponentList.DoNotify(AItem: TComponent; AAction: TListNotification); begin case AAction of lnExtracted, lnDeleted: if not (csDestroying in TdxBarComponent(AItem).ComponentState) then TdxBarComponent(AItem).RemoveChangeNotify(Self); lnAdded: TdxBarComponent(AItem).AddChangeNotify(Self); end; inherited; end; function TdxBarComponentList.GetItemClass: TClass; begin Result := TdxBarComponent; end; { TdxBarGroup } constructor TdxBarGroup.Create(AOwner: TComponent); begin inherited; FEnabled := True; FItems := TdxBarComponentList.Create(False); FVisible := ivAlways; end; destructor TdxBarGroup.Destroy; begin FreeAndNil(FItems); inherited; end; function TdxBarGroup.GetCount: Integer; begin // Result := FItems.Count; Result := InternalGetCount; end; function TdxBarGroup.GetIndex: Integer; begin Result := FBarManager.FGroups.IndexOf(Self); end; function TdxBarGroup.GetItem(Index: Integer): TComponent; begin Result := TComponent(FItems[Index]); end; function TdxBarGroup.InternalGetCount: Integer; begin if IsAncestorComponentDifferencesDetection(Self) then Result := FItemsNames.Count else Result := FItems.Count; end; function TdxBarGroup.InternalGetItemName(Index: Integer): string; begin if IsAncestorComponentDifferencesDetection(Self) then Result := FItemsNames[Index] else Result := Items[Index].Name; end; procedure TdxBarGroup.SetIndex(Value: Integer); begin if Index <> Value then FBarManager.GroupList.Move(Index, Value); end; procedure TdxBarGroup.ReadItems(Reader: TReader); var AItem: TComponent; begin if csLoading in ComponentState then begin if FItemsNames = nil then FItemsNames := TStringList.Create else FItemsNames.Clear; Reader.ReadListBegin; try while not Reader.EndOfList do FItemsNames.Add(Reader.ReadString); finally Reader.ReadListEnd; end; end else begin ItemList.Clear; Reader.ReadListBegin; try while not Reader.EndOfList do begin AItem := BarManager.Owner.FindComponent(Reader.ReadString); if AItem <> nil then Add(TdxBarComponent(AItem)); end; finally Reader.ReadListEnd; end; end; end; procedure TdxBarGroup.WriteItems(Writer: TWriter); var I: Integer; begin Writer.WriteListBegin; try for I := 0 to InternalGetCount - 1 do Writer.WriteString(InternalGetItemName(I)); finally Writer.WriteListEnd; end; end; procedure TdxBarGroup.DefineProperties(Filer: TFiler); function NeedWriteItems: Boolean; function IsGroupsEqual(AGroup1, AGroup2: TdxBarGroup): Boolean; var I: Integer; begin Result := AGroup1.InternalGetCount = AGroup2.InternalGetCount; if Result then for I := 0 to AGroup1.InternalGetCount - 1 do Result := Result and (AGroup1.InternalGetItemName(I) = AGroup2.InternalGetItemName(I)) end; begin Result := (Filer.Ancestor = nil) or not IsGroupsEqual(Self, TdxBarGroup(Filer.Ancestor)); end; begin inherited; Filer.DefineProperty('Items', ReadItems, WriteItems, NeedWriteItems); end; function TdxBarGroup.GetEnabled: Boolean; begin Result := FEnabled; end; procedure TdxBarGroup.Loaded; var I: Integer; AItem: TComponent; begin inherited; if FItemsNames = nil then Exit; try for I := 0 to FItemsNames.Count - 1 do begin AItem := FBarManager.Owner.FindComponent(FItemsNames[I]);//#DG if AItem <> nil then Add(TdxBarComponent(AItem)); end; finally FreeAndNil(FItemsNames); end; end; procedure TdxBarGroup.SetName(const NewName: TComponentName); begin inherited; Changed; end; procedure TdxBarGroup.SetEnabled(Value: Boolean); var ALock: Boolean; I: Integer; begin //if FEnabled <> Value then begin FEnabled := Value; ALock := (BarDesignController.QuickControl = nil) and ([csLoading, csDestroying] * ComponentState = []); if ALock then FBarManager.BeginUpdate; try for I := 0 to Count - 1 do TdxBarComponent(Items[I]).Enabled := Value; finally if ALock then FBarManager.EndUpdate; end; end; end; procedure TdxBarGroup.SetVisible(Value: TdxBarItemVisible); var I: Integer; begin //if FVisible <> Value then begin FVisible := Value; if [csLoading, csDestroying] * ComponentState = [] then FBarManager.BeginUpdate; try for I := 0 to Count - 1 do TdxBarComponent(Items[I]).Visible := Value; finally if [csLoading, csDestroying] * ComponentState = [] then FBarManager.EndUpdate; end; end; end; function TdxBarGroup.GetParentComponent: TComponent; begin Result := FBarManager; end; function TdxBarGroup.HasParent: Boolean; begin Result := FBarManager <> nil; end; procedure TdxBarGroup.SetParentComponent(AParent: TComponent); begin inherited; if AParent is TdxBarManager then TdxBarManager(AParent).AddGroup(Self); end; procedure TdxBarGroup.Add(AItem: TdxBarComponent); function IsRecursive(AItem: TComponent): Boolean; var I: Integer; begin Result := False; if AItem is TdxBarGroup then begin Result := AItem = Self; if not Result then with TdxBarGroup(AItem) do for I := 0 to Count - 1 do begin Result := IsRecursive(Items[I]); if Result then Break; end; end; end; begin if not (AItem is TdxBarComponent) or (IndexOf(AItem) <> -1) then Exit; if IsRecursive(AItem) then raise Exception.Create(cxGetResourceString(@dxSBAR_RECURSIVEGROUPS)); FItems.Add(AItem); end; procedure TdxBarGroup.Delete(Index: Integer); begin FItems.Delete(Index); end; function TdxBarGroup.IndexOf(AItem: TdxBarComponent): Integer; begin Result := FItems.IndexOf(AItem); end; procedure TdxBarGroup.Move(FromIndex, ToIndex: Integer); begin FItems.Move(FromIndex, ToIndex); end; procedure TdxBarGroup.Remove(AItem: TdxBarComponent); begin FItems.Remove(AItem); end; { TdxBarPopupMenuLink } function TdxBarPopupMenuLink.GetBarManager: TdxBarManager; begin Result := TdxBarPopupMenuLinks(Collection).BarManager; end; function TdxBarPopupMenuLink.GetWinControl: TWinControl; begin if Control is TWinControl then Result := TWinControl(Control) else Result := nil; end; procedure TdxBarPopupMenuLink.SetControl(Value: TControl); begin if (Value <> nil) and not IsControlUnderBarManager(BarManager, Value) then Value := nil; if FControl <> Value then begin if FControl <> nil then FControl.WindowProc := FPrevWndProc; FControl := Value; if FControl <> nil then begin FControl.FreeNotification(BarManager); FPrevWndProc := FControl.WindowProc; FControl.WindowProc := NewWndProc; end; end; end; procedure TdxBarPopupMenuLink.SetPopupMenu(Value: TdxBarPopupMenu); begin if FPopupMenu <> Value then begin FPopupMenu := Value; if Value <> nil then Value.FreeNotification(BarManager); end; end; function TdxBarPopupMenuLink.DoAction(const AScreenPopupPoint: TPoint): Boolean; var AClickedByMouse: Boolean; AClientPopupPoint: TPoint; begin AClickedByMouse := not cxPointIsEqual(cxInvalidPoint, AScreenPopupPoint); if AClickedByMouse then AClientPopupPoint := Control.ScreenToClient(AScreenPopupPoint) else if (WinControl <> nil) and HideCaret(WinControl.Handle) then begin ShowCaret(WinControl.Handle); GetCaretPos(AClientPopupPoint); end else AClientPopupPoint := cxNullPoint; Result := False; TControlAccess(Control).DoContextPopup(AClientPopupPoint, Result); if Result then Exit; Result := FPopupMenu <> nil; if Assigned(FOnAction) then FOnAction(Self, AClientPopupPoint.X, AClientPopupPoint.Y, AClickedByMouse, Result); if Result and (FPopupMenu <> nil) then begin with Control.ClientToScreen(AClientPopupPoint) do FPopupMenu.Popup(X, Y); end; end; function TdxBarPopupMenuLink.IsShortCut(AShortCut: TShortCut): Boolean; var X, Y: Integer; begin Result := FPopupMenu <> nil; if Assigned(FOnAction) then begin X := -1; Y := -1; FOnAction(Self, X, Y, False, Result); end; if Result then Result := (FPopupMenu <> nil) and FPopupMenu.IsShortCut(AShortCut); end; procedure TdxBarPopupMenuLink.NewWndProc(var Message: TMessage); var AScreenPoint, AClientPoint: TPoint; AControlAtPos: TControl; begin if (Message.Msg = WM_CONTEXTMENU) and (Message.Result = 0) and not(csDesigning in Control.ComponentState) then begin AScreenPoint := SmallPointToPoint(TSmallPoint(Message.lParam)); AClientPoint := Control.ScreenToClient(AScreenPoint); if Control is TWinControl then begin AControlAtPos := TWinControl(Control).ControlAtPos(AClientPoint, False); if AControlAtPos <> nil then Message.Result := AControlAtPos.Perform(WM_CONTEXTMENU, 0, Message.lParam); if (Message.Result = 0) and (ProcessChildren or (TWinControl(Control).ControlAtPos(AClientPoint, True, True) = nil)) then Message.Result := Ord(DoAction(AScreenPoint)); end else Message.Result := Ord(DoAction(AScreenPoint)); end; FPrevWndProc(Message); end; constructor TdxBarPopupMenuLink.Create(Collection: TCollection); begin inherited; FProcessChildren := True; end; destructor TdxBarPopupMenuLink.Destroy; begin Control := nil; inherited; end; procedure TdxBarPopupMenuLink.Assign(Source: TPersistent); function FindLinkComponent(AComponent: TComponent): TComponent; begin if AComponent <> nil then Result := BarManager.Owner.FindComponent(AComponent.Name) else Result := nil; end; begin if Source is TdxBarPopupMenuLink then begin Control := FindLinkComponent(TdxBarPopupMenuLink(Source).Control) as TWinControl; PopupMenu := FindLinkComponent(TdxBarPopupMenuLink(Source).PopupMenu) as TdxBarPopupMenu; ProcessChildren := TdxBarPopupMenuLink(Source).ProcessChildren; end else inherited Assign(Source); end; function TdxBarPopupMenuLink.DoAction(Wnd: HWND; const P: TPoint): Boolean; begin Result := DoAction(P); end; { TdxBarPopupMenuLinks } constructor TdxBarPopupMenuLinks.Create(ABarManager: TdxBarManager); begin inherited Create(TdxBarPopupMenuLink); FBarManager := ABarManager; end; function TdxBarPopupMenuLinks.GetItem(Index: Integer): TdxBarPopupMenuLink; begin Result := TdxBarPopupMenuLink(inherited GetItem(Index)); end; procedure TdxBarPopupMenuLinks.SetItem(Index: Integer; Value: TdxBarPopupMenuLink); begin inherited SetItem(Index, Value); end; function TdxBarPopupMenuLinks.GetOwner: TPersistent; begin Result := FBarManager; end; function TdxBarPopupMenuLinks.IsShortCut(AControl: TWinControl; AShortCut: TShortCut): Boolean; var AItem: TdxBarPopupMenuLink; AParentBarManager: TdxBarManager; I: Integer; begin Result := False; for I := 0 to Count - 1 do begin if Items[I].Control = AControl then Result := Items[I].IsShortCut(AShortCut); if Result then Break; end; if not Result then for I := 0 to Count - 1 do begin AItem := Items[I]; if AItem.ProcessChildren and (AItem.WinControl <> nil) and IsChildControl(AItem.WinControl, AControl) then Result := AItem.IsShortCut(AShortCut); if Result then Break; end; if not Result then begin AParentBarManager := BarManager.ParentBarManager; if AParentBarManager <> nil then Result := AParentBarManager.PopupMenuLinks.IsShortCut(AControl, AShortCut); end; end; function TdxBarPopupMenuLinks.Add: TdxBarPopupMenuLink; begin Result := TdxBarPopupMenuLink(inherited Add); end; function TdxBarPopupMenuLinks.DoAction(AControl: TWinControl; Wnd: HWND; const P: TPoint): Boolean; var AItem: TdxBarPopupMenuLink; AParentBarManager: TdxBarManager; I: Integer; begin Result := False; if BarManager.Designing then Exit; for I := 0 to Count - 1 do begin if Items[I].Control = AControl then Result := Items[I].DoAction(Wnd, P); if Result then Break; end; if not Result then for I := 0 to Count - 1 do begin AItem := Items[I]; if AItem.ProcessChildren and (AItem.WinControl <> nil) and IsChildControl(AItem.WinControl, Wnd) then Result := Items[I].DoAction(Wnd, P); if Result then Break; end; if not Result then begin AParentBarManager := BarManager.ParentBarManager; if AParentBarManager <> nil then Result := AParentBarManager.PopupMenuLinks.DoAction(AControl, Wnd, P); end; end; { TdxBarBackgrounds } constructor TdxBarBackgrounds.Create(ABarManager: TdxBarManager); begin inherited; FBarBackgroundBitmap := dxBarCreateBitmap(BitmapChanged); FSubMenuBackgroundBitmap := TBitmap.Create; end; destructor TdxBarBackgrounds.Destroy; begin FreeAndNil(FSubMenuBackgroundBitmap); FreeAndNil(FBarBackgroundBitmap); inherited Destroy; end; procedure TdxBarBackgrounds.Assign(Source: TPersistent); begin if Source is TdxBarBackgrounds then begin Bar := TdxBarBackgrounds(Source).Bar; SubMenu := TdxBarBackgrounds(Source).SubMenu; end else inherited Assign(Source); end; procedure TdxBarBackgrounds.Changed; begin BarManager.InternalStyleChanged; // TODO: ??? end; procedure TdxBarBackgrounds.BitmapChanged(Sender: TObject); begin Changed; end; procedure TdxBarBackgrounds.SetBarBackgroundBitmap(Value: TBitmap); var AChanged: Boolean; begin AChanged := not ((Value = nil) and FBarBackgroundBitmap.Empty); FBarBackgroundBitmap.Assign(Value); if AChanged then Changed; end; procedure TdxBarBackgrounds.SetSubMenuBackgroundBitmap(Value: TBitmap); begin FSubMenuBackgroundBitmap.Assign(Value); end; { TdxBarManager } var KeyboardHookHandle: HHOOK; MouseHookHandle: HHOOK; WndProcHookHandle: HHOOK; EatKey, WaitForMenu, DontCallNextKeybHook: Boolean; EatingKey: WPARAM; InMouseHook: Boolean; AClassName: {$IFDEF CLR}StringBuilder{$ELSE}PChar{$ENDIF}; FDockTimerID: UINT; FDockBarManager: TdxBarManager; FHintWindowShowing: Boolean; FHintTimerID, FHiddenHintTimerID: UINT; FCustomHint: string; FLiveHiddenHint: Boolean; procedure KillHintTimer; begin dxKillTimer(0, FHintTimerID); end; procedure KillHiddenHintTimer; begin if dxKillTimer(0, FHiddenHintTimerID) then FLiveHiddenHint := False; end; function dxBarKeyboardHook(Code: Integer; wParam: WParam; lParam: LParam): LRESULT; {$IFNDEF CLR}stdcall;{$ENDIF} function AnyKeyPressed: Boolean; var KS: TKeyboardState; I: Integer; begin GetKeyboardState(KS); for I := Low(KS) to High(KS) do begin Result := KS[I] and 128 <> 0; if Result then Break; end; end; function ShiftState: TShiftState; begin Result := []; if GetAsyncKeyState(VK_SHIFT) < 0 then Result := Result + [ssShift]; if GetAsyncKeyState(VK_CONTROL) < 0 then Result := Result + [ssCtrl]; if GetAsyncKeyState(VK_MENU) < 0 then Result := Result + [ssAlt]; end; function KeyPressed: Boolean; begin Result := (lParam shr 31) and 1 = 0; end; procedure HandleKey(ABarManager: TdxBarManager; var AHookResult: LRESULT); var AIsUniqueItem: Boolean; AItemLink: TdxBarItemLink; AShift: TShiftState; AShortCut: TShortCut; begin AShortCut := Byte(wParam); if GetAsyncKeyState(VK_SHIFT) < 0 then Inc(AShortCut, scShift); if GetAsyncKeyState(VK_CONTROL) < 0 then Inc(AShortCut, scCtrl); if GetAsyncKeyState(VK_MENU) < 0 then Inc(AShortCut, scAlt); if ABarManager.HandleShortCut(AShortCut) then AHookResult := 1 else if GetAsyncKeyState(VK_MENU) < 0 then begin AShift := ShiftState - [ssAlt]; AItemLink := ABarManager.GetItemLinkWithAccel(wParam, AShift); if (AItemLink <> nil) and AItemLink.Item.Enabled then with AItemLink do begin AIsUniqueItem := Owner.FindItemWithAccel(wParam, AShift, AItemLink) = AItemLink; if not Control.IsDestroyOnClick or not AIsUniqueItem then TdxBarControl(BarControl).BarGetFocus(Control); if AIsUniqueItem then begin if Control is TdxBarSubItemControl then BarControl.IsDowned := True; Control.Click(False); end; AHookResult := 1; end; end; end; function ActiveBarFocused(ABarManager: TdxBarManager): boolean; var ACurIndex: Integer; begin ACurIndex := dxBarManagerList.IndexOf(ABarManager); repeat Result := ABarManager.BarControlFocused; ABarManager := dxBarManagerList.NextActive(ABarManager, True); until Result or (dxBarManagerList.IndexOf(ABarManager) = ACurIndex); end; function GetBarManager(AFindRootAccessibleObject: Boolean; out AIRootAccessibilityHelper: IdxBarAccessibilityHelper): TdxBarManager; function FindBarManagerAmongParents(AWnd: HWND): TdxBarManager; begin Result := nil; repeat if AFindRootAccessibleObject then begin AIRootAccessibilityHelper := GetRootAccessibleObject(AWnd); if AIRootAccessibilityHelper <> nil then Result := AIRootAccessibilityHelper.GetBarManager; end else Result := GetBarManagerByHandle(AWnd); if not IsChildClassWindow(AWnd) then Break; AWnd := GetParent(AWnd); until Result <> nil; end; var AControl: TWinControl; I: Integer; begin Result := nil; if GetFocus <> 0 then Result := FindBarManagerAmongParents(GetFocus); if (Result = nil) and (GetActiveForm <> nil) then begin Result := FindBarManagerAmongParents(GetActiveForm.Handle); if (Result = nil) and (Application.MainForm <> nil) and IsWindowEnabled(Application.MainForm.Handle) then begin Result := FindBarManagerAmongParents(Application.MainForm.Handle); if (Result <> nil) and not Result.AllowCallFromAnotherForm then Result := nil; end; end; if (Result = nil) and not AFindRootAccessibleObject then begin AControl := FindControl(GetActiveWindow); if (AControl <> nil) and not IsWindowEnabled(AControl.Handle) then AControl := nil; if (AControl is TCustomForm) and (TCustomForm(AControl).Parent = nil) then begin if Assigned(cxControls.cxGetParentFormForDocking) then AControl := cxControls.cxGetParentFormForDocking(TCustomForm(AControl)); end; if AControl is TCustomForm then for I := 0 to dxBarManagerList.Count - 1 do if dxBarManagerList[I].GetMainForm = AControl then begin Result := dxBarManagerList[I]; Break; end; end; if (Result <> nil) and (Result.IsCustomizing or ActiveBarFocused(Result)) then Result := nil; end; function MenuActivateIfNeeded(var AHookResult: LRESULT): Boolean; var AKeyTipWindowsManager: IdxBarKeyTipWindowsManager; AIRootAccessibilityHelper: IdxBarAccessibilityHelper; ABarManager: TdxBarManager; begin Result := False; ABarManager := GetBarManager((wParam = VK_F10) or (wParam = VK_MENU), AIRootAccessibilityHelper); if ABarManager <> nil then begin if not KeyPressed then // release key begin if (wParam = VK_MENU) and WaitForMenu and not AnyKeyPressed or ABarManager.UseF10ForMenu and (wParam = VK_F10) and (ShiftState = []) then begin WaitForMenu := False; BarNavigationController.SelectDefaultObject(AIRootAccessibilityHelper); AHookResult := 1; Result := True; if AIRootAccessibilityHelper.AreKeyTipsSupported(AKeyTipWindowsManager) then BarNavigationController.EndKeyTipsWaiting(True); end else WaitForMenu := False; end else // press key if wParam = VK_MENU then begin WaitForMenu := True; if AIRootAccessibilityHelper.AreKeyTipsSupported(AKeyTipWindowsManager) then BarNavigationController.BeginKeyTipsWaiting(AIRootAccessibilityHelper); end else begin WaitForMenu := False; HandleKey(ABarManager, AHookResult); Result := True; end; end; end; function HandleByActiveBarControlIfNeeded(var AHookResult: LRESULT): Boolean; const KeyMessages: array[Boolean] of Integer = (WM_KEYUP, WM_KEYDOWN); begin Result := False; if EatKey and (wParam = EatingKey) and not KeyPressed then // release eating key begin EatKey := False; AHookResult := 1; Result := True; Exit; end; if dsKeyAlreadyProcessed in BarDesignController.FDesignStates then Exit; if BarNavigationController.NeedsKey(wParam) then begin if KeyPressed then begin EatKey := True; EatingKey := wParam; BarNavigationController.HandleKey(Word(wParam)); end; if (BarNavigationController.SelectedObjectParent <> nil) or (GetAsyncKeyState(wParam) >= 0) then EatKey := False; AHookResult := 1; Result := True; end else if IsActiveBarControlAccessible and not ActiveBarControl.IsCustomizing then begin if not (ActiveBarControl.SelectedControl is TdxBarWinControl and TdxBarWinControl(ActiveBarControl.SelectedControl).Focused) then begin if KeyPressed then begin EatKey := True; EatingKey := wParam; end; SendMessage(ActiveBarControl.Handle, KeyMessages[KeyPressed], wParam, lParam); if (ActiveBarControl <> nil) or (GetAsyncKeyState(wParam) >= 0) then EatKey := False; AHookResult := 1; Result := True; end end else case wParam of VK_DELETE: if KeyPressed and BarDesignController.DeleteSelectedObjects(ssCtrl in ShiftState, True) then begin AHookResult := 1; Result := True; end; //#DG { if ActiveBarControl.BarManager.SelectedItem <> nil then begin if not (ssCtrl in ShiftState) then ActiveBarControl.BarManager.SelectedItem.ItemLink.Free else if ActiveBarControl.BarManager.Designing and ActiveBarControl.BarManager.CanDeleteComponent(ActiveBarControl.BarManager.SelectedItem.Item) then ActiveBarControl.BarManager.SelectedItem.Item.Free; AHookResult := 1; Result := True; end; } VK_ESCAPE: if (ActiveBarControl <> nil) and (GetCapture = ActiveBarControl.Handle) then begin ReleaseCapture; AHookResult := 1; Result := True; Exit; end else if KeyPressed and BarDesignController.SelectParentComponent then begin AHookResult := 1; Result := True; end; end; end; var Res: LRESULT; begin Result := 0; try if Code = HC_NOREMOVE then Exit; if FIsMDIButtonPressed then begin Result := 1; Exit; end; if wParam = VK_PROCESSKEY then Exit; // for Korean windows if Code < 0 then Exit; if HandleByActiveBarControlIfNeeded(Result) then Exit; if GetCapture = 0 then begin if MenuActivateIfNeeded(Result) then Exit; end; finally if DontCallNextKeybHook then Result := 0 else begin Res := CallNextHookEx(KeyboardHookHandle, Code, wParam, lParam); if Result = 0 then Result := Res; end; end; end; function BarGetMouseWheelReceiver: TdxBarMouseWheelEventReceiver; begin if ActiveBarControl <> nil then if ActiveBarControl.SelectedControl is TdxBarWinControl and TdxBarWinControl(ActiveBarControl.SelectedControl).Focused then Result := mwrFocusedItemControl else Result := mwrNone else Result := mwrWindow; end; function dxBarMouseHook(Code: Integer; wParam: WParam; lParam: LParam): LRESULT; {$IFNDEF CLR}stdcall;{$ENDIF} var AMHS: PMouseHookStruct; function ActiveControl: TdxBarItemControl; begin Result := nil; if FindControl(AMHS.hwnd) is TCustomdxBarControl then Result := TCustomdxBarControl(FindControl(AMHS.hwnd)).SelectedControl; if (Result = nil) and (GetCapture > 0) and (ActiveBarControl <> nil) then if WindowFromPointEx(AMHS.pt) = ActiveBarControl.Handle then Result := ActiveBarControl.SelectedControl else begin Result := ActiveBarControl.SelectedControl; if (Result <> nil) and (not (Result.ItemLink.Item is TCustomdxBarCombo) or not TCustomdxBarCombo(Result.ItemLink.Item).DroppedDown) then Result := nil; end; end; function NeedProccessThisEvent(AWnd: HWND): Boolean; var I: Integer; begin Result := FindControl(AWnd) <> nil; if IsWin95 and not Result then for I := 0 to Screen.FormCount - 1 do if Screen.Forms[I].Handle = AWnd then begin Result := True; Break; end; end; procedure CheckHookParams; function IsMouseOverCustomizingControl(AParentHandle, AControlHandle: HWND; const AMousePos: TPoint): Boolean; var AChildHandle: HWND; AClientPos: TPoint; begin AClientPos := AMousePos; ScreenToClient(AParentHandle, AClientPos); AChildHandle := ChildWindowFromPointEx(AParentHandle, AClientPos, CWP_SKIPINVISIBLE); Result := AChildHandle = AControlHandle; if not Result and (AChildHandle <> 0) and (AChildHandle <> AParentHandle) then Result := IsMouseOverCustomizingControl(AChildHandle, AControlHandle, AMousePos); end; var ACustomizingControl: TWinControl; begin //## Check whole procedure if dxBarCustomizingForm <> nil then begin ACustomizingControl := dxBarCustomizingForm.BarManager.Owner; if (ACustomizingControl <> nil) and IsChildClassWindow(ACustomizingControl.Handle) then begin if IsMouseOverCustomizingControl(AMHS.hwnd, ACustomizingControl.Handle, AMHS.pt) then begin if (WM_MOUSEMOVE <= wParam) and (wParam <= WM_MBUTTONDBLCLK) then wParam := wParam - WM_MOUSEMOVE + WM_NCMOUSEMOVE; AMHS.hwnd := ACustomizingControl.Handle; AMHS.wHitTestCode := UINT(HTERROR); end; end; end; end; function BarsWantMouse: Boolean; function AllowCustomize(ABarManager: TdxBarManager): Boolean; begin Result := (dxBarCustomizingForm <> nil) and {#DG when adding new toolbar - BarControl must ignore mouse} (dxBarCustomizingForm.Active or IsChildEx(GetActiveWindow, ABarManager.Owner.Handle)); end; var ABarManager: TdxBarManager; I: Integer; begin Result := False; if NeedProccessThisEvent(AMHS.hwnd) and (SmallInt(AMHS.wHitTestCode) = HTERROR) then begin ABarManager := dxBarManagerList.CustomizingBarManager; if (ABarManager <> nil) and AllowCustomize(ABarManager) then for I := 0 to ABarManager.Bars.Count - 1 do if (ABarManager.Bars[I].Control <> nil) and ABarManager.Bars[I].Control.WantMouse then begin Result := True; AMHS.hwnd := ABarManager.Bars[I].Control.Handle; AMHS.wHitTestCode := SendMessage(AMHS.hwnd, WM_NCHITTEST, 0, MakeLParam(AMHS.pt.X, AMHS.pt.Y)); SendMessage(AMHS.hwnd, WM_SETCURSOR, AMHS.hwnd, MakeLParam(AMHS.wHitTestCode, wParam)); Break; end; end; end; function ProcessMouseMessage: Boolean; var AControl: TCustomdxBarControl; begin Result := not ActiveBarControl.IsWindowEnabled and not ActiveBarManager.IsCustomizing; // Result := not IsWindowEnabled(AMHS.hwnd) and not ActiveBarControl.BarManager.IsCustomizing and not ActiveBarControl.IsWindowEnabled; AControl := ActiveBarControl; while (AControl <> nil) and not Result do begin Result := AControl.IsChildWindow(AMHS.hwnd) or AControl.IsMeaningParent(AMHS.hwnd); AControl := AControl.GetEquivalentParentBar; end; end; function HideAllIfNeeded(var AHookResult: LRESULT): Boolean; begin Result := False; if not InMouseHook and (Code >= 0) and (ActiveBarControl <> nil) then begin InMouseHook := True; if ((wParam = WM_RBUTTONUP) or (wParam = WM_NCRBUTTONUP) or (wParam = WM_MBUTTONUP) or (wParam = WM_NCMBUTTONUP)) and (ActiveControl = nil) and not ProcessMouseMessage then begin InMouseHook := False; AHookResult := 1; Result := True; Exit; end; if not ActiveBarManager.Dragging then repeat if ({((wParam = WM_LBUTTONUP) or (wParam = WM_NCLBUTTONUP)) and (ActiveControl = nil) and (AnimatingSubMenu = nil) and not ActiveBarControl.IsCustomizing and ((ActiveBarControl is TdxBarControl) or (ActiveBarControl.ParentBar <> nil)) or} IsMouseDownMessage(wParam)) and not ProcessMouseMessage then begin ActiveBarControl.HideAll; if not IsWindowVisible(AMHS.hwnd) then begin AHookResult := 1; Result := True; end; end else Break; until ActiveBarControl = nil; InMouseHook := False; { if not IsWindowVisible(AMHS.hwnd) and (ActiveBarControl <> nil) and ActiveBarControl.IsWindowEnabled then begin AHookResult := 1; Result := True; end; } end; end; procedure CheckNavigationController; begin if ((BarNavigationController.AssignedSelectedObject <> nil) or BarNavigationController.IsKeyTipsWaiting or BarNavigationController.KeyTipsHandlingMode) and IsMouseDownMessage(wParam) then BarNavigationController.StopKeyboardHandling; end; procedure CheckBarMarkState; var // P: TPoint; // ABarControl: TCustomdxBarControl; AQuickControl: TdxBarControl; begin if (BarDesignController.QuickControl <> nil) and not BarDesignController.QuickControl.IsActive and (BarDesignController.QuickControl <> BarDesignController.CustomizingBarControl) and // ((WM_MOUSEFIRST < wParam) and (wParam <= WM_MOUSELAST) or // (WM_NCMOUSEMOVE < wParam) and (wParam <= WM_NCMBUTTONDBLCLK)) then IsMouseDownMessage(wParam) then begin AQuickControl := BarDesignController.QuickControl; if (AMHS.hwnd <> AQuickControl.Handle) and (not AQuickControl.ParentBar.MouseOnMark or (wParam = WM_RBUTTONDOWN)) then AQuickControl.CloseUp; { if FindControl(AMHS.hwnd) is TCustomdxBarControl then begin ABarControl := TCustomdxBarControl(FindControl(AMHS.hwnd)); P := AMHS.pt; ScreenToClient(AMHS.hwnd, P) end else ABarControl := nil; if (ABarControl = nil) or (ABarControl <> QuickCustBar) and ((ABarControl <> QuickCustBar.ParentBar) or not PtInRect(TdxBarControl(ABarControl).MarkRect, P) or (wParam = WM_RBUTTONDOWN)) then QuickCustBar.ParentBar.MarkState := msNone; } end; end; procedure ProcessManually(var AHookResult: LRESULT); var P: TPoint; AKeys: Longint; begin P := AMHS.pt; if (WM_NCMOUSEMOVE <= wParam) and (wParam <= WM_NCMBUTTONDBLCLK) then begin wParam := wParam - WM_NCMOUSEMOVE + WM_MOUSEMOVE; ScreenToClient(AMHS.hwnd, P); end; if wParam <> WM_MOUSEMOVE then SetForegroundWindow(dxBarCustomizingForm.Handle); AKeys := Byte(GetAsyncKeyState(VK_CONTROL) < 0) * MK_CONTROL + Byte(LeftButtonPressed) * MK_LBUTTON + Byte(GetAsyncKeyState(VK_MBUTTON) < 0) * MK_MBUTTON + Byte(RightButtonPressed) * MK_RBUTTON + Byte(GetAsyncKeyState(VK_SHIFT) < 0) * MK_SHIFT; SendMessage(AMHS.hwnd, wParam, AKeys, MakeLParam(P.X, P.Y)); AHookResult := 1; end; var AManualProcessing: Boolean; Res: HRESULT; begin Result := 0; try if (Code = HC_ACTION) and IsMouseDownMessage(wParam) then BarNavigationController.ResetNavigationMode; if (Code >= 0) and (wParam = WM_MOUSEWHEEL) and (BarGetMouseWheelReceiver = mwrNone) then begin Result := 1; Exit; end; AMHS := PMouseHookStruct(lParam); if (AMHS.hwnd = GetCapture) and (wParam <> WM_RBUTTONUP) then // TTreeView has capture while WM_RBUTTONUP Exit; CheckHookParams; AManualProcessing := BarsWantMouse; if HideAllIfNeeded(Result) then Exit; CheckBarMarkState; CheckNavigationController; if AManualProcessing then ProcessManually(Result); finally Res := CallNextHookEx(MouseHookHandle, Code, wParam, lParam); if Result = 0 then Result := Res; end; end; // win95 bug fix var FIsGetingBarManagerdxBarWndProcHook: Boolean; function dxBarWndProcHook(Code: Integer; wParam: WParam; lParam: LParam): LRESULT; stdcall; function GetWindowParentForm(AWnd: HWND): TCustomForm; begin while not (FindControl(AWnd) is TCustomForm) and (GetParent(AWnd) <> 0) do AWnd := GetParent(AWnd); if FindControl(AWnd) is TCustomForm then Result := TCustomForm(FindControl(AWnd)) else Result := nil; end; function GetBarManager(AWnd: HWND): TdxBarManager; begin FIsGetingBarManagerdxBarWndProcHook := True; try Result := GetBarManagerByHandle(AWnd); finally FIsGetingBarManagerdxBarWndProcHook := False; end; end; procedure ActivateMDIChildFormToolbars(AActivate: Boolean; AActiveWindow: HWND); var ABarManagerMainForm: TCustomForm; AControl: TWinControl; I: Integer; begin AControl := FindControl(AActiveWindow); if AControl is TCustomdxBarControl then begin ABarManagerMainForm := GetBarManagerForm(TCustomdxBarControl(AControl).BarManager, fkMainOrMDIChild); if IsMDIChild(ABarManagerMainForm) then Exit; end; ABarManagerMainForm := Application.MainForm.ActiveMDIChild; if ABarManagerMainForm <> nil then for I := 0 to dxBarManagerList.Count - 1 do if GetBarManagerForm(dxBarManagerList[I], fkMainOrMDIChild) = ABarManagerMainForm then dxBarManagerList[I].ShowToolbars(AActivate, False, AActiveWindow); end; procedure CallOwnerWndProc(Msg: Cardinal; wParam, lParam: Integer; AHandle: HWND); var ABarManager: TdxBarManager; //#DG AControl: TWinControl; AParentForm: TCustomForm; AWnd: HWND; begin if (Msg = WM_ACTIVATE) and ((AHandle = GetParent(lParam)) or (HWND(lParam) = GetParent(AHandle))) and not IsAnotherApplicatonWindow(AHandle) and not IsAnotherApplicatonWindow(lParam) then Exit; AWnd := AHandle; if (Msg = WM_HELP) and (ActiveBarControl <> nil) then begin AParentForm := GetWindowParentForm(AWnd); if (AParentForm = nil) or not IsBarManagerOwner(ActiveBarManager, AParentForm.Handle) then AWnd := GetBarManagerForm(ActiveBarManager, fkAny).Handle; end; ABarManager := GetBarManager(AWnd); //## if (ABarManager = nil) and (Msg = WM_ACTIVATE) then begin //#DG AControl := FindControl(AHandle); //#DG if not (AControl is TCustomdxBarControl) and IsWindowVisible(GetParent(AHandle)) then if IsWindowVisible(GetParent(AHandle)) then //#DG ABarManager := GetBarManager(GetParent(AHandle)); //## end; if ABarManager <> nil then ABarManager.OwnerWndProc(AWnd, Msg, wParam, lParam); TdxBarManager.SendFormBroadcastMessage(AWnd, Msg, wParam, lParam); end; procedure CallMainFormClientWndProc(AWnd: HWND; Msg: Cardinal; wParam, lParam: Integer); var ABarManager: TdxBarManager; begin if AWnd <> 0 then begin {$IFDEF CLR} GetClassName(AWnd, AClassName, AClassName.Capacity); {$ELSE} GetClassName(AWnd, AClassName, 256); {$ENDIF} if AnsiStrIComp(AClassName{$IFDEF CLR}.ToString{$ENDIF}, 'MDICLIENT') = 0 then begin ABarManager := GetBarManager(Application.MainForm.Handle); if ABarManager <> nil then ABarManager.MainFormClientWndProc(Msg, wParam, lParam); end; end; end; var AMsg: PCWPStruct; begin AMsg := PCWPStruct(lParam); case AMsg.message of WM_ACTIVATE: if (LOWORD(AMsg.wParam) = WA_INACTIVE) and IsAnotherApplicatonWindow(AMsg.lParam) then FApplicationDeactivation := True; WM_ACTIVATEAPP: begin FApplicationDeactivation := False; FApplicationActive := Bool(AMsg.wParam); BarDesignController.SynchronizeLastSelectedItem; //#DG new end; end; if not FIsGetingBarManagerdxBarWndProcHook then begin CallOwnerWndProc(AMsg.message, AMsg.wParam, AMsg.lParam, AMsg.hwnd); if (Application.MainForm <> nil) and (Application.MainForm.FormStyle = fsMDIForm) and Application.MainForm.HandleAllocated and (AMsg.hwnd = Application.MainForm.Handle) and not IsPopupMenuShowed then case AMsg.message of WM_ACTIVATE: ActivateMDIChildFormToolbars(LOWORD(AMsg.wParam) <> WA_INACTIVE, AMsg.lParam); WM_WINDOWPOSCHANGED: if dxBarCustomizingForm <> nil then dxBarCustomizingForm.UpdateVisibility(PWindowPos(AMsg.lParam)^); end; end; Result := CallNextHookEx(WndProcHookHandle, Code, wParam, lParam); case AMsg.message of WM_CHILDACTIVATE, WM_DESTROY, WM_MDIACTIVATE: CallMainFormClientWndProc(GetParent(AMsg.hwnd), AMsg.message, AMsg.wParam, AMsg.lParam); end; end; var FPrevInitProc: TProcedure; procedure dxBarInitProc; begin if Assigned(FPrevInitProc) then FPrevInitProc; InitMMSystem; end; procedure RegisterdxBarManager(ABarManager: TdxBarManager); procedure SetHook(var AHook: HHook; AHookId: Integer; AHookProc: TFNHookProc); begin // if AHook = 0 then AHook := SetWindowsHookEx(AHookId, AHookProc, 0, GetCurrentThreadId); end; begin if dxBarManagerList.IndexOf(ABarManager) < 0 then begin if dxBarManagerList.Count = 0 then begin SetHook(KeyboardHookHandle, WH_KEYBOARD, dxBarKeyboardHook); SetHook(MouseHookHandle, WH_MOUSE, dxBarMouseHook); SetHook(WndProcHookHandle, WH_CALLWNDPROC, dxBarWndProcHook); end; dxBarManagerList.Add(ABarManager); if Assigned(FOnRegisterBarManager) then FOnRegisterBarManager(ABarManager); end; if not ABarManager.Designing and (FHintWindow = nil) then FHintWindow := dxBarHintWindowClass.Create(nil); end; procedure FinalizationBars; procedure ReleaseHook(var AHook: HHOOK); begin if AHook <> 0 then begin UnhookWindowsHookEx(AHook); AHook := 0; end; end; begin ReleaseHook(WndProcHookHandle); ReleaseHook(MouseHookHandle); ReleaseHook(KeyboardHookHandle); FreeAndNil(FHintWindow); end; procedure UnregisterdxBarManager(ABarManager: TdxBarManager); begin if dxBarManagerList <> nil then begin dxBarManagerList.Extract(ABarManager); if dxBarManagerList.Count = 0 then FinalizationBars; end; if Assigned(FOnUnregisterBarManager) then FOnUnregisterBarManager(ABarManager); end; { TCustomdxBarControlViewInfo } constructor TCustomdxBarControlViewInfo.Create(ABarControl: TCustomdxBarControl); begin inherited Create; FBarControl := ABarControl; FItemControlViewInfos := TList.Create end; destructor TCustomdxBarControlViewInfo.Destroy; begin FreeAndNil(FItemControlViewInfos); inherited Destroy; end; procedure TCustomdxBarControlViewInfo.Calculate; begin Clear; end; function TCustomdxBarControlViewInfo.GetItemControlIndex( AItemControl: TdxBarItemControl): Integer; begin Result := FItemControlViewInfos.IndexOf(AItemControl.ViewInfo); end; function TCustomdxBarControlViewInfo.IsAssociatedWithSeparator( AItemControl: TdxBarItemControl; out ASeparatorIndex: Integer): Boolean; var I: Integer; begin Result := False; for I := 0 to High(FSeparatorsData) do if FSeparatorsData[I].AssociatedItemControl = AItemControl then begin Result := True; ASeparatorIndex := I; Break; end; end; function TCustomdxBarControlViewInfo.IsItemControlVisible( AItemControl: TdxBarItemControl): Boolean; begin Result := FItemControlViewInfos.IndexOf(AItemControl.ViewInfo) <> -1; end; procedure TCustomdxBarControlViewInfo.AddItemControlViewInfo( AViewInfo: TdxBarItemControlViewInfo); begin FItemControlViewInfos.Add(AViewInfo); end; procedure TCustomdxBarControlViewInfo.AddSeparatorInfo(const ARect: TRect; AKind: TdxBarItemSeparatorKind; AAssociatedItemControl: TdxBarItemControl); var AIndex: Integer; begin AIndex := Length(FSeparatorsData); SetLength(FSeparatorsData, AIndex + 1); with FSeparatorsData[AIndex] do begin AssociatedItemControl := AAssociatedItemControl; Bounds := ARect; Kind := AKind; end; end; procedure TCustomdxBarControlViewInfo.Clear; begin FItemControlViewInfos.Clear; RemoveSeparatorInfos; end; procedure TCustomdxBarControlViewInfo.RemoveItemControlViewInfo( AViewInfo: TdxBarItemControlViewInfo); begin FItemControlViewInfos.Remove(AViewInfo); end; procedure TCustomdxBarControlViewInfo.RemoveSeparatorInfos; begin SetLength(FSeparatorsData, 0); end; function TCustomdxBarControlViewInfo.GetItemControlCount: Integer; begin Result := FItemControlViewInfos.Count; end; function TCustomdxBarControlViewInfo.GetItemControlViewInfo( AIndex: Integer): TdxBarItemControlViewInfo; begin Result := TdxBarItemControlViewInfo(FItemControlViewInfos[AIndex]); end; function TCustomdxBarControlViewInfo.GetSeparatorCount: Integer; begin Result := Length(FSeparatorsData); end; function TCustomdxBarControlViewInfo.GetSeparatorInfo( AIndex: Integer): TdxBarItemSeparatorInfo; begin with FSeparatorsData[AIndex] do begin Result.Bounds := Bounds; Result.Kind := Kind; end; end; procedure TCustomdxBarControlViewInfo.SetSeparatorInfo(AIndex: Integer; const Value: TdxBarItemSeparatorInfo); begin with FSeparatorsData[AIndex] do begin Bounds := Value.Bounds; Kind := Value.Kind; end; end; { TdxBarDragInfo } constructor TdxBarDragInfo.Create(ABarManager: TdxBarmanager); begin inherited Create; FBarManager := ABarManager; end; destructor TdxBarDragInfo.Destroy; begin cxRemoveObjectLink(FDragOverBarControlLink); cxRemoveObjectLink(FDragLineBarControlLink); inherited; end; procedure TdxBarDragInfo.BeginDrag(AItem: TdxBarItem; AItemLink: TdxBarItemLink); begin FDraggingItem := AItem; FDraggingItemLink := AItemLink; if FDraggingItemLink <> nil then FDragDownPoint := FDraggingItemLink.ScreenToClient(GetMouseCursorPos); FDefaultCursor := Screen.Cursor; FCaptureWnd := FBarManager.GetWindowForMouseCapturing; SetCapture(FCaptureWnd); ProcessMouseMessages; end; procedure TdxBarDragInfo.DragDrop; begin case DraggingState of dsNoDrop: DeleteDraggingItemLink; dsNoDrag: {do nothing}; dsBeginGroup: ChangeBeginGroup; dsCategory: MoveItemToAnotherCategory; dsCopy, dsDrag: begin FDraggingState := dsNoDrag; CreateNewItemLink; end; end; end; procedure TdxBarDragInfo.EndDrag; begin if GetCapture = FCaptureWnd then ReleaseCapture; DraggingState := dsNoDrag; DestroyWindow(FDraggingItemLinkParentHandle); RepaintItemControl(DraggingControl); FDraggingItem := nil; FDraggingItemLink := nil; DragOverBarControl := nil; DragLineBarControl := nil; end; procedure TdxBarDragInfo.HandleDragging; var AWnd: HWND; AMsg: TMsg; P: TPoint; AControl: TWinControl; ACategoryItemIndex: Integer; AAccept: Boolean; begin Include(BarDesignController.FDesignStates, dsKeyAlreadyProcessed); try while GetCapture = FCaptureWnd do begin case Integer(GetMessage(AMsg, 0, 0, 0)) of -1: Break; 0: begin PostQuitMessage(AMsg.wParam); Break; end; end; case AMsg.message of WM_KEYDOWN: case AMsg.wParam of VK_ESCAPE: Break; VK_CONTROL: if HasTarget then DraggingState := dsCopy; end; WM_KEYUP: case AMsg.wParam of VK_CONTROL: if HasTarget then DraggingState := dsDrag; end; WM_MOUSEMOVE: begin P := GetMouseCursorPos; AWnd := WindowFromPointEx(P); AControl := FindControl(AWnd); if CategoriesList <> nil then if AControl = CategoriesList then begin P := CategoriesList.ScreenToClient(P); ACategoryItemIndex := CategoriesList.ItemAtPos(P, True); if (0 <= ACategoryItemIndex) and (ACategoryItemIndex <= CategoriesList.Items.Count - 1) then begin CategoriesList.ItemIndex := ACategoryItemIndex; DraggingState := dsCategory; end else begin CategoriesList.ItemIndex := FDraggingItem.Category; DraggingState := dsNoDrop; end; Continue; end else begin CategoriesList.ItemIndex := FDraggingItem.Category; end; BeginUpdate; try if (dxBarSubMenuEditor <> nil) and (dxBarSubMenuEditor.Handle = AWnd) then dxBarSubMenuEditor.Perform(CM_ACTIVATE, 0, 0); CalcDragOverItemParameters(P); AAccept := True; if DragOverBarControl <> nil then DragOverBarControl.DragOver(P.X, P.Y, AAccept); if AAccept and HasTarget then begin if IsDragCopy then DraggingState := dsCopy else begin if (DragOverItemControl <> nil) and (FDraggingItemLink <> nil) and ((DragOverItemLink = FDraggingItemLink) or NoNeedDragLine) then DraggingState := dsBeginGroup else DraggingState := dsDrag end; end else DraggingState := dsNoDrop; finally EndUpdate; end; end; WM_LBUTTONUP: begin DragDrop; Break; end; else TranslateMessage(AMsg); DispatchMessage(AMsg); end; end; finally Exclude(BarDesignController.FDesignStates, dsKeyAlreadyProcessed); end; end; procedure TdxBarDragInfo.BeginUpdate; begin Inc(FLockCount); end; procedure TdxBarDragInfo.EndUpdate; begin if FLockCount > 0 then begin Dec(FLockCount); DragInfoChanged; end; end; procedure TdxBarDragInfo.CalcDragOverItemParameters(var ACursorPos: TPoint); function GetDragOverBarControl(AControl: TWinControl): TCustomdxBarControl; var I: Integer; ABarControl: TdxBarControl; begin Result := nil; if AControl is TCustomdxBarControl then begin if TCustomdxBarControl(AControl).BarManager = FBarManager then Result := TCustomdxBarControl(AControl) end else for I := 0 to FBarManager.Bars.Count - 1 do begin ABarControl := FBarManager.Bars[I].Control; if (ABarControl <> nil) and ABarControl.WantMouse then begin Result := ABarControl; Break; end; end; if (Result <> nil) and not Result.CanCustomizing then Result := nil; end; var AItemLink: TdxBarItemLink; AIsBeginGroup, AIsFirstPart, AIsVerticalDirection: Boolean; begin AIsFirstPart := False; AIsBeginGroup := False; AIsVerticalDirection := False; AItemLink := nil; DragOverBarControl := GetDragOverBarControl(FindControl(WindowFromPointEx(ACursorPos))); if DragOverBarControl <> nil then begin ACursorPos := DragOverBarControl.ScreenToClient(ACursorPos); DragOverBarControl.CalcDragOverParameters(ACursorPos, AItemLink, AIsBeginGroup, AIsFirstPart, AIsVerticalDirection); end; DragOverItemLink := AItemLink; DragOverBeginGroup := AIsBeginGroup; DragOverFirstPart := AIsFirstPart; DragOverVerticalDirection := AIsVerticalDirection; end; function TdxBarDragInfo.CategoriesList: TListBox; begin if (dxBarCustomizingForm <> nil) and (FDraggingItemLink = nil) and FBarManager.Designing then Result := dxBarCustomizingForm.lbCategories else Result := nil; end; procedure TdxBarDragInfo.DragInfoChanged; var ACursor: TCursor; begin if FLockCount = 0 then begin case DraggingState of dsNoDrop: begin ACursor := crdxBarDragNoDrop; DrawDraggingLine(False); FDragOverItemLink := nil; end; dsDrag: begin DrawDraggingLine(False); ACursor := crdxBarDrag; if not NoNeedDragLine then DrawDraggingLine(True); end; dsCopy: begin DrawDraggingLine(False); ACursor := crdxBarDragCopy; DrawDraggingLine(True); end; dsCategory: ACursor := crdxBarDrag; dsBeginGroup: begin DrawDraggingLine(False); ACursor := crdxBarDrag; end; else {dsNoDrag} begin ACursor := FDefaultCursor; DrawDraggingLine(False); end; end; SetCursor(Screen.Cursors[ACursor]); FModified := False; end else FModified := True; end; procedure TdxBarDragInfo.DrawDraggingLine(AVisible: Boolean); procedure CalculateDragLineParameters; var ADragLineItemLink: TdxBarItemLink; AIsLastControl: Boolean; AParentLinks: TdxBarItemLinks; begin FDragLineVerticalDirection := DragOverVerticalDirection; if DragOverItemLink <> nil then begin ADragLineItemLink := DragOverItemLink; FDragLineFirstPart := DragOverFirstPart; AParentLinks := FDragOverItemLink.Owner; if FDragOverBeginGroup then begin if FDragLineFirstPart then ADragLineItemLink := AParentLinks.Prev(ADragLineItemLink, True); FDragLineFirstPart := not FDragLineFirstPart; end else if not FDragLineFirstPart then begin AIsLastControl := ADragLineItemLink.Control.FLastInRow or AParentLinks.Next(ADragLineItemLink, True).BeginGroup; if not AIsLastControl then begin ADragLineItemLink := AParentLinks.Next(ADragLineItemLink, True); FDragLineFirstPart := True; end; end; FDragLineRect := ADragLineItemLink.ItemRect; end else begin FDragLineFirstPart := True; FDragLineRect := DragLineBarControl.ClientRect; end; end; begin if (FDragLineVisible <> AVisible) then begin (* {TODO CHECK IT} if not ADragLineVisible then FDragOverItemControl.Parent.Update; *) if AVisible then begin if DragOverBarControl <> nil then begin DragLineBarControl := DragOverBarControl; CalculateDragLineParameters; InternalDrawDraggingLine; FDragLineVisible := AVisible; end; end else begin if DragLineBarControl <> nil then InternalDrawDraggingLine; DragLineBarControl := nil; FDragLineVisible := AVisible; end; end; end; function TdxBarDragInfo.HasTarget: Boolean; begin Result := (DragOverItemControl <> nil) or (DragOverBarControl <> nil) and (DragOverBarItemLinks.VisibleItemCount = 0); end; function TdxBarDragInfo.IsDragCopy: Boolean; begin Result := (GetAsyncKeyState(VK_CONTROL) < 0) or (FDraggingItemLink = nil); end; function TdxBarDragInfo.NoNeedDragLine: Boolean; begin //#DG to drop on empty toolbar Result := (FDragOverItemLink = nil) or Result := not HasTarget or //#DG to drop on empty toolbar ((DraggingItemLink <> nil) and ((DragOverItemLink = DraggingItemLink) and (not DragOverBeginGroup or not FDragOverFirstPart) or (FDraggingItemLink.VisibleIndex > 0) and (DragOverItemLink = FDraggingItemLink.Owner.Prev(FDraggingItemLink, True)) and (not FDraggingItemLink.BeginGroup and not FDragOverBeginGroup and not FDragOverFirstPart) or (FDraggingItemLink.VisibleIndex < (FDraggingItemLink.Owner.VisibleItemCount - 1)) and ((DragOverItemLink = FDraggingItemLink.Owner.Next(FDraggingItemLink, True)) and ((FDragOverBeginGroup or not DragOverItemLink.BeginGroup) and FDragOverFirstPart)))); end; procedure TdxBarDragInfo.ChangeBeginGroup; var ACursorPos: TPoint; ABeginGroup: Boolean; ACursorOffset: Integer; begin ACursorPos := FDraggingItemLink.ScreenToClient(GetMouseCursorPos); if DragOverBarControl.IsVerticalDirection then ACursorOffset := ACursorPos.Y - FDragDownPoint.Y else ACursorOffset := ACursorPos.X - FDragDownPoint.X; ABeginGroup := ACursorOffset > 0; if Abs(ACursorOffset) >= MakeBeginGroupDragSize then if FDraggingItemLink.BeginGroup <> ABeginGroup then begin FDraggingItemLink.BarControl.SelectedLink := DraggingItemLink; FBarManager.FSelectedItem := DraggingControl; FDraggingItemLink.BeginGroup := ABeginGroup; end else FDraggingItemLink.BarControl.SetKeySelectedItem(DraggingControl); end; procedure TdxBarDragInfo.CreateNewItemLink; var ASetBeginGroup{, ANeedRepaintBar}: Boolean; AItemLink: TdxBarItemLink; begin FBarManager.LockDesignerModified(True); FBarManager.BeginUpdate; //#DG without this - AV, when dropped on empty subcontrol FBarManager.ItemList.BeginUpdate; DragOverBarItemLinks.BeginUpdate; //#DG try AItemLink := DragOverBarItemLinks.Add; begin AItemLink.InternalBringToTopInRecentList(True); if FDraggingItemLink <> nil then begin if not IsDragCopy then FDraggingItemLink.FIsMarkedForDeletion := True; try AItemLink.Assign(FDraggingItemLink); finally FDraggingItemLink.FIsMarkedForDeletion := False; end; AItemLink.FBeginGroup := False; end else AItemLink.Item := FDraggingItem; if DragOverItemLink <> nil then begin ASetBeginGroup := FDragOverBeginGroup and not FDragOverFirstPart or not FDragOverBeginGroup and FDragOverFirstPart and DragOverItemLink.BeginGroup; AItemLink.Index := DragOverItemLink.Index + Byte(not FDragOverBeginGroup and not FDragOverFirstPart); if ASetBeginGroup then begin AItemLink.BeginGroup := True; DragOverItemLink.BeginGroup := False; end; end; AItemLink.CreateControl; FBarManager.FSelectedItem := AItemLink.Control; DragOverBarControl.SelectedLink := AItemLink; //temp if not IsDragCopy then DeleteDraggingItemLink; { WHY ??? if (FDraggingItemLink <> nil) and not IsDragCopy then begin ANeedRepaintBar := FDraggingItemLink.Owner <> DragOverBarItemLinks; DeleteDraggingItemlink; end else ANeedRepaintBar := True; if ANeedRepaintBar then DragOverBarControl.RepaintBar; } // activate barcontrol which contains new itemlink if (ActiveBarControl <> nil) and (DragOverBarControl is TdxBarControl) and (ActiveBarControl <> DragOverBarControl) then begin ActiveBarControl.HideAll; TdxBarControl(DragOverBarControl).BarGetFocus(AItemLink.Control); end; BarDesignController.SelectItem(AItemLink, soAdd); end finally DragOverBarItemLinks.EndUpdate; FBarManager.ItemList.EndUpdate(False); FBarManager.EndUpdate; FBarManager.LockDesignerModified(False); end; end; procedure TdxBarDragInfo.DeleteDraggingItemLink; begin if FDraggingItemLink <> nil then FDraggingItemLink.MoveBeginGroupItemIfNeeded; dxFreeAndNil(FDraggingItemLink); FBarManager.DesignerModified; end; procedure TdxBarDragInfo.InternalDrawDraggingLine; const LineSize = 6; Pairs: array[0..5] of DWORD = (2, 2, 2, 2, 2, 2); procedure PolyPolyLine(ADC: HDC; const Points: array of TPoint); begin Windows.PolyPolyLine(ADC, Points, Pairs, 6); end; var ADC: HDC; AOrigin: Integer; begin ADC := DragLineBarControl.Canvas.Handle; SetROP2(ADC, R2_NOT); try with FDragLineRect do if FDragLineVerticalDirection then begin if FDragLineFirstPart then AOrigin := Top else AOrigin := Bottom - LineSize; PolyPolyLine(ADC, [Point(Left, AOrigin), Point(Left, AOrigin + LineSize), Point(Left + 1, AOrigin + 1), Point(Left + 1, AOrigin + LineSize - 1), Point(Left + 2, AOrigin + 2), Point(Right - 2, AOrigin + 2), Point(Left + 2, AOrigin + 3), Point(Right - 2, AOrigin + 3), Point(Right - 2, AOrigin + 1), Point(Right - 2, AOrigin + LineSize - 1), Point(Right - 1, AOrigin), Point(Right - 1, AOrigin + LineSize)]); end else begin if FDragLineFirstPart then AOrigin := Left else AOrigin := Right - LineSize; PolyPolyLine(ADC, [Point(AOrigin, Top), Point(AOrigin + LineSize, Top), Point(AOrigin + 1, Top + 1), Point(AOrigin + LineSize - 1, Top + 1), Point(AOrigin + 2, Top + 2), Point(AOrigin + 2, Bottom - 2), Point(AOrigin + 3, Top + 2), Point(AOrigin + 3, Bottom - 2), Point(AOrigin + 1, Bottom - 2), Point(AOrigin + LineSize - 1, Bottom - 2), Point(AOrigin, Bottom - 1), Point(AOrigin + LineSize, Bottom - 1)]); end; finally SetROP2(ADC, R2_COPYPEN); end; end; procedure TdxBarDragInfo.MoveItemToAnotherCategory; var AList: TList; ANewIndex: Integer; begin if (CategoriesList <> nil) and (FDraggingItem.Category <> CategoriesList.ItemIndex) then begin AList := TList.Create; try FBarManager.GetAllItemsByCategory(CategoriesList.ItemIndex, AList); if AList.Count > 0 then begin ANewIndex := TdxBarItem(AList[AList.Count - 1]).Index + 1; if ANewIndex > FBarManager.ItemCount - 1 then Dec(ANewIndex); FBarManager.MoveItem(FDraggingItem.Index, ANewIndex); end; finally AList.Free; end; FDraggingItem.Category := CategoriesList.ItemIndex; end; end; function TdxBarDragInfo.GetDraggingControl: TdxBarItemControl; begin Result := GetControlByLink(FDraggingItemLink); end; function TdxBarDragInfo.GetDragLineBarControl: TCustomdxBarControl; begin Result := TCustomdxBarControl(GetObjectByObjectLink(FDragLineBarControlLink)); end; function TdxBarDragInfo.GetDragOverBarControl: TCustomdxBarControl; begin Result := TCustomdxBarControl(GetObjectByObjectLink(FDragOverBarControlLink)); end; function TdxBarDragInfo.GetDragOverBarItemLinks: TdxBarItemLinks; begin if DragOverBarControl <> nil then Result := DragOverBarControl.ItemLinks else Result := nil; end; function TdxBarDragInfo.GetDragOverItemControl: TdxBarItemControl; begin Result := GetControlByLink(FDragOverItemLink); end; procedure TdxBarDragInfo.SetDraggingState(Value: TdxBarDraggingState); begin if FDraggingState <> Value then begin FDraggingState := Value; DragInfoChanged; end; end; procedure TdxBarDragInfo.SetDragLineBarControl(Value: TCustomdxBarControl); begin cxRemoveObjectLink(FDragLineBarControlLink); FDragLineBarControlLink := cxAddObjectLink(Value); end; procedure TdxBarDragInfo.SetDragOverBarControl(Value: TCustomdxBarControl); begin cxRemoveObjectLink(FDragOverBarControlLink); FDragOverBarControlLink := cxAddObjectLink(Value); end; procedure TdxBarDragInfo.SetDragOverBeginGroup(Value: Boolean); begin if FDragOverBeginGroup <> Value then begin FDragOverBeginGroup := Value; DragInfoChanged; end; end; procedure TdxBarDragInfo.SetDragOverFirstPart(Value: Boolean); begin if FDragOverFirstPart <> Value then begin FDragOverFirstPart := Value; DragInfoChanged; end; end; procedure TdxBarDragInfo.SetDragOverVerticalDirection(Value: Boolean); begin if FDragOverVerticalDirection <> Value then begin FDragOverVerticalDirection := Value; DragInfoChanged; end; end; procedure TdxBarDragInfo.SetDragOverItemLink(Value: TdxBarItemLink); begin if FDragOverItemLink <> Value then begin FDragOverItemLink := Value; if FDragOverItemLink <> nil then begin DrawDraggingLine(False); if (DragOverItemControl is TdxBarSubItemControl) or (DragOverBarControl.SelectedControl is TdxBarSubItemControl) then DragOverBarControl.SetMouseSelectedItem(DragOverItemControl) else begin // for better painting FBarManager.SelectedItem := DragOverItemControl; DragOverBarControl.SelectedLink := DragOverItemLink; end; ProcessPaintMessages; end; DragInfoChanged; end; end; { TdxBarImageOptions } constructor TdxBarImageOptions.Create; begin inherited; FNotifyComponent := TcxFreeNotificator.Create(nil); FNotifyComponent.OnFreeNotification := FreeNotification; FImagesChangeLink := TChangeLink.Create; FLargeImagesChangeLink := TChangeLink.Create; FHotImagesChangeLink := TChangeLink.Create; FDisabledImagesChangeLink := TChangeLink.Create; FDisabledLargeImagesChangeLink := TChangeLink.Create; FUseLeftBottomPixelAsTransparent := True; FStretchGlyphs := True; FImageListBkColor := clFuchsia; CalcGlyphSize; end; destructor TdxBarImageOptions.Destroy; begin FreeAndNil(FDisabledImagesChangeLink); FreeAndNil(FDisabledLargeImagesChangeLink); FreeAndNil(FHotImagesChangeLink); FreeAndNil(FLargeImagesChangeLink); FreeAndNil(FImagesChangeLink); FreeAndNil(FNotifyComponent); inherited; end; procedure TdxBarImageOptions.Assign(Source: TPersistent); begin if Source is TdxBarImageOptions then begin DisabledImages := TdxBarImageOptions(Source).DisabledImages; DisabledLargeImages := TdxBarImageOptions(Source).DisabledLargeImages; HotImages := TdxBarImageOptions(Source).HotImages; ImageListBkColor := TdxBarImageOptions(Source).ImageListBkColor; Images := TdxBarImageOptions(Source).Images; LargeImages := TdxBarImageOptions(Source).LargeImages; LargeIcons := TdxBarImageOptions(Source).LargeIcons; MakeDisabledImagesFaded := TdxBarImageOptions(Source).MakeDisabledImagesFaded; SmoothGlyphs := TdxBarImageOptions(Source).SmoothGlyphs; StretchGlyphs := TdxBarImageOptions(Source).StretchGlyphs; UseLargeImagesForLargeIcons := TdxBarImageOptions(Source).UseLargeImagesForLargeIcons; UseLeftBottomPixelAsTransparent := TdxBarImageOptions(Source).UseLeftBottomPixelAsTransparent; end else inherited Assign(Source); end; procedure TdxBarImageOptions.SetImageList(var ANewValue, AOldValue: TCustomImageList; const AChangeLink: TChangeLink); begin if ANewValue <> AOldValue then begin if AOldValue <> nil then begin AOldValue.RemoveFreeNotification(FNotifyComponent); AOldValue.UnRegisterChanges(AChangeLink); end; AOldValue := ANewValue; if ANewValue <> nil then begin ANewValue.RegisterChanges(AChangeLink); ANewValue.FreeNotification(FNotifyComponent); end; AChangeLink.Change; end; end; procedure TdxBarImageOptions.SetHotImages(Value: TCustomImageList); begin SetImageList(Value, FHotImages, FHotImagesChangeLink); end; procedure TdxBarImageOptions.SetImageListBkColor(Value: TColor); begin if FImageListBkColor <> Value then begin FImageListBkColor := Value; CallNotify(FOnImageOptionsChange, Self); end; end; procedure TdxBarImageOptions.SetImages(Value: TCustomImageList); begin SetImageList(Value, FImages, FImagesChangeLink); end; procedure TdxBarImageOptions.SetDisabledImages(Value: TCustomImageList); begin SetImageList(Value, FDisabledImages, FDisabledImagesChangeLink); end; procedure TdxBarImageOptions.SetDisabledLargeImages(Value: TCustomImageList); begin SetImageList(Value, FDisabledLargeImages, FDisabledLargeImagesChangeLink); end; procedure TdxBarImageOptions.SetLargeIcons(Value: Boolean); begin if FLargeIcons <> Value then begin FLargeIcons := Value; CallNotify(FOnLargeIconsChange, Self); end; end; procedure TdxBarImageOptions.SetLargeImages(Value: TCustomImageList); begin if FLargeImages <> Value then begin SetImageList(Value, FLargeImages, FLargeImagesChangeLink); if LargeIcons and UseLargeImagesForLargeIcons then CallNotify(FOnLargeIconsChange, Self); end; end; procedure TdxBarImageOptions.SetMakeDisabledImagesFaded(Value: Boolean); begin if FMakeDisabledImagesFaded <> Value then begin FMakeDisabledImagesFaded := Value; CallNotify(FOnImageOptionsChange, Self); end; end; procedure TdxBarImageOptions.SetUseLargeImagesForLargeIcons(Value: Boolean); begin if FUseLargeImagesForLargeIcons <> Value then begin FUseLargeImagesForLargeIcons := Value; CallNotify(FOnImageOptionsChange, Self); end; end; procedure TdxBarImageOptions.SetUseLeftBottomPixelAsTransparent(Value: Boolean); begin if FUseLeftBottomPixelAsTransparent <> Value then begin FUseLeftBottomPixelAsTransparent := Value; CallNotify(FOnImageOptionsChange, Self); end; end; procedure TdxBarImageOptions.CalcGlyphSize; begin if LargeIcons then begin if IsLargeImagesForLargeIcons then FGlyphSize := LargeImages.Width else FGlyphSize := DefautGlyphSize * 2; end else FGlyphSize := DefautGlyphSize; // * (1 + Byte(FLargeIcons)); end; function TdxBarImageOptions.IsLargeImagesForLargeIcons: Boolean; begin Result := UseLargeImagesForLargeIcons and (LargeImages <> nil); end; procedure TdxBarImageOptions.FreeNotification(AComponent: TComponent); begin BarManager.LockDesignerModified(True); try if AComponent = DisabledLargeImages then DisabledLargeImages := nil; if AComponent = DisabledImages then DisabledImages := nil; if AComponent = HotImages then HotImages := nil; if AComponent = Images then Images := nil; if AComponent = LargeImages then LargeImages := nil; finally BarManager.LockDesignerModified(False, False); end; end; { TdxBarManager } constructor TdxBarManager.Create(AOwner: TComponent); begin Include(FInternalState, bisCreating); if (AOwner = nil) and (Application.MainForm <> nil) then AOwner := Application.MainForm; if not (AOwner is TWinControl) then raise Exception.Create(cxGetResourceString(@dxSBAR_BARMANAGERBADOWNER)); if GetBarManagerByComponent(AOwner) <> nil then raise Exception.Create(cxGetResourceString(@dxSBAR_BARMANAGERMORETHANONE)); Exclude(FInternalState, bisCreating); inherited Create(AOwner); RegisterdxBarManager(Self); FBackgrounds := TdxBarBackgrounds.Create(Self); InitPainter; FAllowReset := True; FAutoDockColor := True; FInternalItems := TComponentList.Create; FItems := TdxBarComponentList.Create(False); //#DG list FItems.OnComponentListChanged := ItemsChanged; FCategories := TdxBarManagerCategories.Create(Self); FDockControls := TList.Create; FPopupMenus := TComponentList.Create(False); FBars := TdxBars.Create(Self); FReadIniFileHandlers := TdxEventHandlerCollection.Create; FWriteIniFileHandlers := TdxEventHandlerCollection.Create; FMDIStateChangedHandlers := TdxEventHandlerCollection.Create; FSystemFontChangedHandlers := TdxEventHandlerCollection.Create; FCanCustomize := True; FDockColor := clBtnFace; FBarCaptionFont := TFont.Create; FEditFont := TFont.Create; FFont := TFont.Create; FFont.OnChange := FontChanged; FGroups := TdxBarComponentList.Create(False); //#DG list FHelpButtonGlyph := dxBarCreateBitmap(HelpButtonGlyphChanged); FHideFloatingBarsWhenInactive := True; FThemeChangedNotificator := TdxThemeChangedNotificator.Create; FThemeChangedNotificator.OnThemeChanged := ThemeChanged; FButtonArrowWidth := dxBarDefaultButtonArrowWidth; FLargeButtonArrowWidth := dxBarDefaultLargeButtonArrowWidth; FMenusShowRecentItemsFirst := True; FMostRecentItemsPercents := 95; CalcMostRecentlyUsedUseCount; FPopupMenuLinks := TdxBarPopupMenuLinks.Create(Self); FScaled := True; FShowFullMenusAfterDelay := True; FShowHint := True; FShowHintForDisabledItems := True; FLookAndFeel := TcxLookAndFeel.Create(Self); FLookAndFeel.OnChanged := LFChanged; Style := bmsEnhanced; FUseF10ForMenu := True; UseSystemFont := True; FWaitForDockingTime := 21; CreateToolbarsBrushes; FCreatedByMergingBarMergeDataList := TList.Create; FDragInfo := TdxBarDragInfo.Create(Self); FImageOptions := TdxBarImageOptions.Create(Self); FImageOptions.FImagesChangeLink.OnChange := ImageListChange; FImageOptions.FLargeImagesChangeLink.OnChange := LargeImageListChange; FImageOptions.FHotImagesChangeLink.OnChange := HotImageListChange; FImageOptions.FDisabledImagesChangeLink.OnChange := DisabledImageListChange; FImageOptions.FDisabledLargeImagesChangeLink.OnChange := DisabledLargeImageListChange; FImageOptions.FOnImageOptionsChange := ImageOptionsChange; FImageOptions.FOnLargeIconsChange := LargeIconsChange; if not (csDesigning in ComponentState) then FSavedState := TMemIniFile.Create(''); end; destructor TdxBarManager.Destroy; begin if not (bisCreating in FInternalState) then begin FHintObject := nil; FreeAndNil(FSavedState); FreeAndNil(FImageOptions); FreeAndNil(FDragInfo); FreeAndNil(FLookAndFeel); FreeAndNil(FThemeChangedNotificator); if FHintTimerID <> 0 then begin KillHintTimer; HintActivate(False, ''); end; KillHiddenHintTimer; Customizing(False); DestroyToolbarsBrushes; FPopupMenus.OwnsObjects := True; FreeAndNil(FPopupMenus); FreeAndNil(FHelpButtonGlyph); FGroups.OwnsObjects := True; FreeAndNil(FGroups); FreeAndNil(FFont); FreeAndNil(FEditFont); FreeAndNil(FBarCaptionFont); dxFreeAndNil(FBars); FreeAndNil(FMDIStateChangedHandlers); FreeAndNil(FSystemFontChangedHandlers); FreeAndNil(FReadIniFileHandlers); FreeAndNil(FWriteIniFileHandlers); FreeAndNil(FDockControls); DestroyItems; UnregisterdxBarManager(Self); FreeAndNil(FCategories); DestroyBarRestoringList; FreeAndNil(FPopupMenuLinks); FreeAndNil(FBackgrounds); FreeAndNil(FCreatedByMergingBarMergeDataList); FreeAndNil(FDefaultPainter); end; inherited Destroy; end; procedure TdxBarManager.ActivateHint(AShow: Boolean; const CustomHint: string; AHintObject: TObject = nil); begin HintActivate(AShow, CustomHint, AHintObject); end; procedure TdxBarManager.BeginUpdate; begin Inc(FLockUpdateCount); if FLockUpdateCount = 1 then DoLockUpdate(True, False); end; procedure TdxBarManager.EndUpdate(ACheckBarsChanges: Boolean = True); begin Dec(FLockUpdateCount); if FLockUpdateCount = 0 then DoLockUpdate(False, ACheckBarsChanges); end; procedure TdxBarManager.BarDestroyHandler(Sender: TObject); var ABarMergeData: TdxBarMergeData; begin ABarMergeData := TdxBarMergeData.Create; ABarMergeData.Assign(TdxBar(Sender).MergeData); FCreatedByMergingBarMergeDataList.Insert(0, ABarMergeData); end; procedure TdxBarManager.FormatRegistryPath(var ARegistryPath: string); begin if ARegistryPath[1] <> '\' then ARegistryPath := '\' + ARegistryPath; if ARegistryPath[Length(ARegistryPath)] <> '\' then ARegistryPath := ARegistryPath + '\'; end; function TdxBarManager.GetBarControlFocused: Boolean; begin Result := FFocusedBarControl <> nil; end; function TdxBarManager.GetBarsLoading: Boolean; begin Result := bisBarsLoading in FInternalState; end; function TdxBarManager.GetCanModifyDesigner: Boolean; begin Result := FLockDesignerModifiedCount = 0; end; function TdxBarManager.GetCategoryItemsVisible(AIndex: Integer): TdxBarItemVisible; begin if (0 <= AIndex) and (AIndex < FCategories.Count) then with FCategories do if Objects[AIndex] = nil then Result := ivAlways else Result := TdxBarCategoryData(Objects[AIndex]).ItemsVisible else Result := ivNever; end; function TdxBarManager.GetCategoryVisible(AIndex: Integer): Boolean; begin if (0 <= AIndex) and (AIndex < FCategories.Count) then with FCategories do Result := (Objects[AIndex] = nil) or TdxBarCategoryData(Objects[AIndex]).Visible else Result := False; end; function TdxBarManager.GetDesigning: Boolean; begin Result := csDesigning in ComponentState; end; function TdxBarManager.GetDockColor: TColor; begin if FAutoDockColor then Result := TControlAccess(Owner).Color else Result := FDockColor; end; function TdxBarManager.GetDockControl(Index: Integer): TdxDockControl; begin Result := FDockControls[Index]; end; function TdxBarManager.GetDockControlCount: Integer; begin Result := FDockControls.Count; end; function TdxBarManager.GetDragging: Boolean; begin Result := DragInfo.DraggingState <> dsNoDrag; end; function TdxBarManager.GetDraggingItem: TdxBarItem; begin Result := DragInfo.DraggingItem; end; function TdxBarManager.GetDraggingItemLink: TdxBarItemLink; begin Result := DragInfo.DraggingItemLink; end; function TdxBarManager.GetFlat: Boolean; begin Result := FStyle = bmsFlat; end; function TdxBarManager.GetFlatToolbarsBorderColor: COLORREF; function GetDarkValue(Value: Byte): Byte; begin Result := MulDiv(Value, 8, 10); end; begin Result := GetSysColor(COLOR_BTNSHADOW); Result := RGB( GetDarkValue(GetRValue(Result)), GetDarkValue(GetGValue(Result)), GetDarkValue(GetBValue(Result))); Result := GetRealColor(Result); end; function TdxBarManager.GetFlatToolbarsColor: COLORREF; function GetLightValue(Value: Byte): Byte; begin Result := Value + MulDiv(255 - Value, 16, 100); end; begin Result := GetSysColor(COLOR_BTNFACE); Result := RGB( GetLightValue(GetRValue(Result)), GetLightValue(GetGValue(Result)), GetLightValue(GetBValue(Result))); Result := GetRealColor(Result); end; function TdxBarManager.GetFlatToolbarsDownedColor: COLORREF; begin Result := GetRealColor(GetLightColor(11, 9, 73)); end; function TdxBarManager.GetFlatToolbarsDownedSelColor: COLORREF; begin Result := GetRealColor(GetLightColor(14, 44, 40)); end; function TdxBarManager.GetFlatToolbarsSelColor: COLORREF; begin Result := GetRealColor(GetLightColor(-2, 30, 72)); end; function TdxBarManager.GetGroup(Index: Integer): TdxBarGroup; begin Result := TdxBarGroup(FGroups[Index]); end; function TdxBarManager.GetGroupCount: Integer; begin Result := FGroups.Count; end; function TdxBarManager.GetInternalDockControl( ADockingStyle: TdxBarDockedDockingStyle): TdxDockControl; begin Result := DockControls[Integer(ADockingStyle) - 1]; end; function TdxBarManager.GetIsCustomizing: Boolean; begin Result := FIsCustomizing or Designing; end; function TdxBarManager.GetIsDestroying: Boolean; begin Result := csDestroying in ComponentState; end; function TdxBarManager.GetIsHandleCreating: Boolean; begin Result := bisHandleCreating in FInternalState; end; function TdxBarManager.GetIsInitializing: Boolean; begin Result := IsLoading or (bisAfterLoading in FInternalState); end; function TdxBarManager.GetItemCount: Integer; begin Result := FItems.Count; end; function TdxBarManager.GetItem(Index: Integer): TdxBarItem; begin if (0 <= Index) and (Index < FItems.Count) then Result := TdxBarItem(FItems[Index]) else Result := nil; end; function TdxBarManager.GetLastSelectedLinkAtDesign: TdxBarItemLink; var ASelectedItem: TPersistent; begin { #DG remove from BarControl if BarManager.Dragging then Result := BarManager.DraggingItemLink else if (SelectedItem = BarManager.SelectedItem) and (SelectedItem <> nil) then Result := BarManager.SelectedItem.ItemLink else Result := nil } ASelectedItem := GetInstance(BarDesignController.LastSelectedItem); if not(ASelectedItem is TdxBarItemLink) or (TdxBarItemLink(ASelectedItem).BarManager <> Self) then ASelectedItem := nil; Result := TdxBarItemLink(ASelectedItem); end; function TdxBarManager.GetRestoringListBar(Index: Integer): TdxBar; begin Result := TdxBar(FBarRestoringList[Index]); end; function TdxBarManager.GetRestoringListBarCount: Integer; begin if BarRestoringListExists then Result := FBarRestoringList.Count else Result := 0; end; function TdxBarManager.GetTabOrder: Integer; begin Result := dxBarManagerList.IndexOf(Self); end; procedure TdxBarManager.IniFileCollectionCallMethods(ACollection: TdxEventHandlerCollection; AIniFile: TCustomIniFile; AStoringKind: TdxBarStoringKind; ASection: string); var AIniFileEventData: TdxBarIniFileEventData; begin AIniFileEventData.IniFile := AIniFile; AIniFileEventData.StoringKind := AStoringKind; AIniFileEventData.BaseSection := ASection; AIniFileEventData.Delimiter := GetSectionDelimiter(AStoringKind); ACollection.CallEvents(Self, AIniFileEventData); end; function TdxBarManager.InternalGetPainterClass: TdxBarPainterClass; begin Result := TdxBarPainterClass(DefaultPainter.ClassType); end; procedure TdxBarManager.SetAutoDockColor(Value: Boolean); var I: Integer; begin if FAutoDockColor <> Value then begin FAutoDockColor := Value; for I := 0 to DockControlCount - 1 do DockControls[I].ColorChanged; end; end; procedure TdxBarManager.SetAutoHideEmptyBars(Value: Boolean); var I: Integer; begin if FAutoHideEmptyBars <> Value then begin FAutoHideEmptyBars := Value; if not Value then for I := 0 to FBars.Count - 1 do Bars[I].FInternallyHidden := False; end; end; procedure TdxBarManager.SetBackgrounds(Value: TdxBarBackgrounds); begin FBackgrounds.Assign(Value); end; procedure TdxBarManager.SetButtonArrowWidth(Value: Integer); begin if FButtonArrowWidth <> Value then begin if Value < 2 then Exit; FButtonArrowWidth := Value; Bars.Repaint; end; end; procedure TdxBarManager.SetCategories(Value: TStrings); begin Categories.Assign(Value); end; procedure TdxBarManager.SetCategoryItemsVisible(AIndex: Integer; Value: TdxBarItemVisible); var ACategoryData: TdxBarCategoryData; AEmptyBars, AList: TList; APrevValue: TdxBarItemVisible; I: Integer; begin if (AIndex < 0) or (AIndex >= FCategories.Count) then Exit; APrevValue := CategoryItemsVisible[AIndex]; with FCategories do begin ACategoryData := TdxBarCategoryData(Objects[AIndex]); if ACategoryData = nil then begin Objects[AIndex] := TdxBarCategoryData.Create; ACategoryData := TdxBarCategoryData(Objects[AIndex]); ACategoryData.ItemsVisible := ivAlways; ACategoryData.Visible := True; end; if Self.IsLoading then begin ACategoryData.LoadedItemsVisible := Value; Exit; end; ACategoryData.ItemsVisible := Value; if not Designing then begin AEmptyBars := nil; if AutoHideEmptyBars then begin AEmptyBars := TList.Create; for I := 0 to FBars.Count - 1 do if FBars[I].ItemLinks.AvailableItemCount = 0 then AEmptyBars.Add(FBars[I]); end; Self.BeginUpdate; AList := TList.Create; try GetAllItemsByCategory(AIndex, AList); if Value = ivAlways then begin for I := AList.Count - 1 downto 0 do if TdxBarItem(AList[I]).Visible = APrevValue then TdxBarItem(AList[I]).Visible := Value; end else for I := 0 to AList.Count - 1 do if TdxBarItem(AList[I]).Visible = APrevValue then TdxBarItem(AList[I]).Visible := Value; finally AList.Free; if AutoHideEmptyBars then for I := 0 to Bars.Count - 1 do if (Value = ivNever) and (Bars[I].ItemLinks.AvailableItemCount = 0) and (AEmptyBars.IndexOf(Bars[I]) = -1) or (Value = ivAlways) and (Bars[I].ItemLinks.AvailableItemCount > 0) and Bars[I].FInternallyHidden then begin Bars[I].Visible := Value = ivAlways; Bars[I].FInternallyHidden := Value = ivNever; end; FreeAndNil(AEmptyBars); Self.EndUpdate; end; end; end; if Value <> APrevValue then DesignerModified; end; procedure TdxBarManager.SetCategoryVisible(AIndex: Integer; Value: Boolean); begin if (0 <= AIndex) and (AIndex < FCategories.Count) and (CategoryVisible[AIndex] <> Value) then begin with FCategories do begin if Objects[AIndex] = nil then begin Objects[AIndex] := TdxBarCategoryData.Create; TdxBarCategoryData(Objects[AIndex]).ItemsVisible := ivAlways; end; TdxBarCategoryData(Objects[AIndex]).Visible := Value; end; DesignerModified; end; end; function TdxBarManager.GetMainForm: TCustomForm; begin Result := GetBarManagerForm(Self, fkMain); end; function TdxBarManager.GetMainMenuControl: TdxBarControl; begin if FMainMenuBar <> nil then Result := FMainMenuBar.Control else Result := nil; end; function TdxBarManager.GetMasterForm: TCustomForm; begin Result := GetBarManagerForm(Self, fkMainOrMDIChild); end; function TdxBarManager.GetNotDocking: TdxBarDockingStyles; begin Result := FNotDocking; end; function TdxBarManager.GetParentBarManager: TdxBarManager; begin Result := nil; if Owner.HandleAllocated then Result := GetBarManagerForComponent(GetChildWindowVCLParent(Owner.Handle)); end; function TdxBarManager.GetParentedOwner: TWinControl; begin Result := TWinControl(inherited Owner); end; function TdxBarManager.GetParentForm: TCustomForm; begin if FParentForm = nil then FParentForm := GetBarManagerForm(Self, fkAny); Result := FParentForm; end; procedure TdxBarManager.SetDockColor(Value: TColor); var I: Integer; begin if FDockColor <> Value then begin FDockColor := Value; FAutoDockColor := False; for I := 0 to DockControlCount - 1 do DockControls[I].ColorChanged; end; end; procedure TdxBarManager.SetFlatCloseButton(Value: Boolean); begin if FFlatCloseButton <> Value then begin FFlatCloseButton := Value; if MainMenuControl <> nil then begin //#DG if (SelectedItem <> nil) and (SelectedItem.Parent = MainMenuControl) then SelectedItem := nil; MainMenuControl.RepaintBar; end; end; end; procedure TdxBarManager.SetFont(Value: TFont); begin Font.Assign(Value); end; procedure TdxBarManager.SetHelpButtonGlyph(Value: TBitmap); begin FHelpButtonGlyph.Assign(Value); end; procedure TdxBarManager.SetHideFloatingBarsWhenInactive(Value: Boolean); begin if FHideFloatingBarsWhenInactive <> Value then begin FHideFloatingBarsWhenInactive := Value; ShowToolbars(FMainFormActive or not FHideFloatingBarsWhenInactive, False, 0); end; end; procedure TdxBarManager.SetDraggingItem(Value: TdxBarItem); begin DragInfo.DraggingItem := Value; end; procedure TdxBarManager.SetDraggingItemLink(Value: TdxBarItemLink); begin DragInfo.DraggingItemLink := Value; end; function TdxBarManager.GetIsLoading: Boolean; begin Result := csLoading in ComponentState; end; function TdxBarManager.GetIsRecreating: Boolean; begin {$IFDEF DELPHI10} Result := csRecreating in Owner.ControlState; {$ELSE} Result := False; {$ENDIF} end; function TdxBarManager.GetIsStateSaving: Boolean; begin Result := bisStateSaving in FInternalState; end; procedure TdxBarManager.SetLargeButtonArrowWidth(Value: Integer); var I: Integer; begin if FLargeButtonArrowWidth <> Value then begin if Value < 2 then Exit; FLargeButtonArrowWidth := Value; for I := 0 to Bars.Count - 1 do with Bars[I] do if Control <> nil then Control.RepaintBar; end; end; procedure TdxBarManager.SetLockUpdate(Value: Boolean); begin if Value <> FLockUpdate then begin FLockUpdate := Value; if FLockUpdate then BeginUpdate else EndUpdate(False); end; end; procedure TdxBarManager.SetLookAndFeel(Value: TcxLookAndFeel); begin FLookAndFeel.Assign(Value); end; procedure TdxBarManager.SetMenuAnimations(Value: TdxBarMenuAnimations); begin if FMenuAnimations <> Value then begin FMenuAnimations := Value; DesignerModified; UpdateBarManagerOptions; end; end; procedure TdxBarManager.SetMenusShowRecentItemsFirst(Value: Boolean); begin if FMenusShowRecentItemsFirst <> Value then begin FMenusShowRecentItemsFirst := Value; DesignerModified; UpdateBarManagerOptions; end; end; procedure TdxBarManager.SetMostRecentItemsPercents(Value: Byte); begin if Value > 100 then Value := 100; FMostRecentItemsPercents := Value; CalcMostRecentlyUsedUseCount; end; procedure TdxBarManager.SetNotDocking(Value: TdxBarDockingStyles); begin if FNotDocking <> Value then begin FNotDocking := Value; InternalStyleChanged; // TODO: ??? end; end; procedure TdxBarManager.SetPopupMenuLinks(Value: TdxBarPopupMenuLinks); begin FPopupMenuLinks.Assign(Value); end; procedure TdxBarManager.SetRegistryPath(Value: string); begin FRegistryPath := Value; FormatRegistryPath(FRegistryPath); end; procedure TdxBarManager.SetScaled(Value: Boolean); begin if FScaled <> Value then begin FScaled := Value; if Value and not FUseSystemFont then AssignFont; end; end; procedure TdxBarManager.SetSelectedItem(Value: TdxBarItemControl); //#DG var //#DG OldSelectedItem: TdxBarItemControl; begin if FSelectedItem <> Value then begin if IsCustomizing and (FSelectedItem <> nil) and ((Value = nil) or (GetParentBarForControl(Value) <> GetParentBarForControl(FSelectedItem))) then if GetParentBarForControl(FSelectedItem) <> nil then GetParentBarForControl(FSelectedItem).SetMouseSelectedItem(nil) else if (dxBarSubMenuEditor <> nil) and (GetParentBarOrSubMenuForControl(FSelectedItem) = dxBarSubMenuEditor.ItemLinks.BarControl) then dxBarSubMenuEditor.ItemLinks.DestroyBarControl; //#DG OldSelectedItem := FSelectedItem; FSelectedItem := Value; {#DG may be un necessary ? if (OldSelectedItem <> nil) and (OldSelectedItem.Parent <> nil) and not Dragging then OldSelectedItem.Repaint; } {#DG if Designing and (FSelectedItem <> nil) and not Dragging then SelectComponent(FSelectedItem.ItemLink.Item); } (* #DG LastSelectedObject idea if (Value = nil) and IsCustomizing and not Designing then SelectedLink := nil; *) end; end; procedure TdxBarManager.SetShowCloseButton(Value: Boolean); begin if FShowCloseButton <> Value then begin FShowCloseButton := Value; if MainMenuControl <> nil then begin //#DG if (SelectedItem <> nil) and (SelectedItem.Parent = MainMenuControl) then SelectedItem := nil; MainMenuControl.RepaintBar; end; end; end; procedure TdxBarManager.SetShowFullMenusAfterDelay(Value: Boolean); begin if FShowFullMenusAfterDelay <> Value then begin FShowFullMenusAfterDelay := Value; DesignerModified; UpdateBarManagerOptions; end; end; procedure TdxBarManager.SetShowHelpButton(Value: Boolean); begin if FShowHelpButton <> Value then begin FShowHelpButton := Value; UpdateHelpButton; end; end; procedure TdxBarManager.SetShowHint(Value: Boolean); begin if FShowHint <> Value then begin FShowHint := Value; DesignerModified; UpdateBarManagerOptions; end; end; procedure TdxBarManager.SetShowShortCutInHint(Value: Boolean); begin if FShowShortCutInHint <> Value then begin FShowShortCutInHint := Value; DesignerModified; UpdateBarManagerOptions; end; end; procedure TdxBarManager.SetStyle(Value: TdxBarManagerStyle); begin if FStyle <> Value then begin FStyle := Value; InternalStyleChanged; end; end; procedure TdxBarManager.SetSunkenBorder(Value: Boolean); var I: Integer; begin if FSunkenBorder <> Value then begin FSunkenBorder := Value; for I := 0 to DockControlCount - 1 do DockControls[I].NCChanged; end; end; procedure TdxBarManager.SetTabOrder(Value: Integer); begin if Value < 0 then Value := 0; if Value >= dxBarManagerList.Count then Value := dxBarManagerList.Count - 1; dxBarManagerList.Move(dxBarManagerList.IndexOf(Self), Value); end; procedure TdxBarManager.SetUseSystemFont(Value: Boolean); begin if FUseSystemFont <> Value then begin FUseSystemFont := Value; if FUseSystemFont then OwnerWndProc(0, WM_SETTINGCHANGE, SPI_SETNONCLIENTMETRICS, 0); end; end; procedure TdxBarManager.SetWaitForDockingTime(Value: Integer); begin if Value >= 0 then FWaitForDockingTime := Value; end; function TdxBarManager.GetDisabledImages: TCustomImageList; begin Result := FImageOptions.DisabledImages; end; function TdxBarManager.GetDisabledLargeImages: TCustomImageList; begin Result := FImageOptions.DisabledLargeImages; end; function TdxBarManager.GetGlyphSize: Integer; begin Result := FImageOptions.FGlyphSize; end; function TdxBarManager.GetHotImages: TCustomImageList; begin Result := FImageOptions.HotImages; end; function TdxBarManager.GetImageListBkColor: TColor; begin Result := FImageOptions.FImageListBkColor; end; function TdxBarManager.GetImages: TCustomImageList; begin Result := FImageOptions.Images; end; function TdxBarManager.GetLargeImages: TCustomImageList; begin Result := FImageOptions.LargeImages; end; function TdxBarManager.GetLargeIcons: Boolean; begin Result := FImageOptions.LargeIcons; end; function TdxBarManager.GetMakeDisabledImagesFaded: Boolean; begin Result := FImageOptions.MakeDisabledImagesFaded; end; function TdxBarManager.GetStretchGlyphs: Boolean; begin Result := FImageOptions.StretchGlyphs; end; function TdxBarManager.GetUseLargeImagesForLargeIcons: Boolean; begin Result := FImageOptions.UseLargeImagesForLargeIcons; end; procedure TdxBarManager.SetDisabledImages(Value: TCustomImageList); begin FImageOptions.DisabledImages := Value; end; procedure TdxBarManager.SetDisabledLargeImages(Value: TCustomImageList); begin FImageOptions.DisabledLargeImages := Value; end; procedure TdxBarManager.SetGlyphSize(Value: Integer); begin FImageOptions.FGlyphSize := Value; end; procedure TdxBarManager.SetHotImages(Value: TCustomImageList); begin FImageOptions.HotImages := Value; end; procedure TdxBarManager.SetImageListBkColor(Value: TColor); begin FImageOptions.ImageListBkColor := Value; end; procedure TdxBarManager.SetImages(Value: TCustomImageList); begin FImageOptions.Images := Value; end; procedure TdxBarManager.SetLargeIcons(Value: Boolean); begin FImageOptions.LargeIcons := Value; end; procedure TdxBarManager.SetLargeImages(Value: TCustomImageList); begin FImageOptions.LargeImages := Value; end; procedure TdxBarManager.SetMakeDisabledImagesFaded(Value: Boolean); begin FImageOptions.MakeDisabledImagesFaded := Value; end; procedure TdxBarManager.SetStretchGlyphs(Value: Boolean); begin FImageOptions.StretchGlyphs := Value; end; procedure TdxBarManager.SetUseLargeImagesForLargeIcons(Value: Boolean); begin FImageOptions.UseLargeImagesForLargeIcons := Value; end; procedure TdxBarManager.DisabledImageListChange(Sender: TObject); begin CustomImagesChanged(DisabledImagesChanged); end; procedure TdxBarManager.DisabledLargeImageListChange(Sender: TObject); begin CustomImagesChanged(DisabledLargeImagesChanged); end; procedure TdxBarManager.HotImageListChange(Sender: TObject); begin CustomImagesChanged(HotImagesChanged); end; procedure TdxBarManager.ImageListChange(Sender: TObject); begin CustomImagesChanged(ImagesChanged); end; procedure TdxBarManager.ImageOptionsChange(Sender: TObject); begin Bars.Repaint; end; procedure TdxBarManager.LargeIconsChange; begin FImageOptions.CalcGlyphSize; DesignerModified; UpdateBarManagerOptions; Bars.Repaint; end; procedure TdxBarManager.LargeImageListChange(Sender: TObject); begin CustomImagesChanged(LargeImagesChanged); end; function TdxBarManager.BarByNewName(const AName: string): TdxBar; var I: Integer; begin for I := 0 to FBars.Count - 1 do begin Result := FBars[I]; if Result.Name = AName then Exit; end; Result := nil; end; procedure TdxBarManager.FontChanged(Sender: TObject); procedure ProcessBars; var I: Integer; begin for I := 0 to Bars.Count - 1 do with Bars[I] do begin FInternalFontChange := True; try if UseOwnFont then FontChanged(nil) else Font := Self.Font; finally FInternalFontChange := False; end; end; end; procedure ProcessPopupMenus; var I: Integer; begin for I := 0 to FPopupMenus.Count - 1 do with TdxBarPopupMenu(FPopupMenus[I]) do begin FInternalFontChange := True; try if UseOwnFont then FontChanged(nil) else Font := Self.Font; finally FInternalFontChange := False; end; end; end; procedure ProcessSystemFontListeners; begin FSystemFontChangedHandlers.CallEvents(Self, []); end; begin if not FInternalFontChange then FUseSystemFont := False; if FScaled then begin Font.OnChange := nil; try AssignFont; finally Font.OnChange := FontChanged; end; end; CreateEditFontHandle(Font, FEditFont, FScaled); FBarCaptionFont.Handle := CreateToolbarCaptionFontHandle(Font, UseSystemFont); ProcessSystemFontListeners; ProcessBars; ProcessPopupMenus; end; { TSystemMenuSubItem } type TSystemMenuSubItem = class(TCustomdxBarSubItem) private FMDIChildHandle: HWND; function GetIconHandle: HICON; procedure ButtonClick(Sender: TObject); protected procedure BuildMenu; procedure DirectClick; override; public property IconHandle: HICON read GetIconHandle; property MDIChildHandle: HWND read FMDIChildHandle write FMDIChildHandle; end; function TSystemMenuSubItem.GetIconHandle: HICON; begin Result := SendMessage(FMDIChildHandle, WM_GETICON, ICON_SMALL, 0); if Result = 0 then Result := SendMessage(FMDIChildHandle, WM_GETICON, ICON_BIG, 0); Result := CopyImage(Result, IMAGE_ICON, 16, 16, LR_COPYFROMRESOURCE); end; procedure TSystemMenuSubItem.ButtonClick(Sender: TObject); begin with TdxBarItem(Sender) do SendMessage(MDIChildHandle, WM_SYSCOMMAND, Tag, 0); end; procedure TSystemMenuSubItem.BuildMenu; const SLength = 1024; procedure BuildSubMenu(SubItem: TCustomdxBarSubItem; Menu: HWND); const BitmapNames: array[HBMMENU_POPUP_CLOSE..HBMMENU_POPUP_MINIMIZE] of string = ('DXBARCLOSE', 'DXBARRESTORE', 'DXBARMAXIMIZE', 'DXBARMINIMIZE'); var ABeginGroup: Boolean; S: PChar; I, P: Integer; MI: TMenuItemInfo; AShortCutText: string; AItem: TdxBarItem; begin ABeginGroup := False; GetMem(S, SLength); try for I := 0 to GetMenuItemCount(Menu) - 1 do begin with MI do begin if IsWin98Or2000 then cbSize := SizeOf(MI) else begin cbSize := 44; MI.hbmpItem := 0; end; fMask := MIIM_CHECKMARKS or MIIM_ID or MIIM_STATE or MIIM_SUBMENU or MIIM_TYPE; dwTypeData := S; cch := SLength; end; GetMenuItemInfo(Menu, I, True, MI); if MI.fType and MFT_SEPARATOR <> 0 then begin ABeginGroup := True; Continue; end; if MI.fType and MFT_BITMAP <> 0 then GetMenuString(Menu, I, S, SLength, MF_BYPOSITION) else if MI.cch = 0 then StrCopy(S, ''); P := Pos(#9, S); if P = 0 then AShortCutText := '' else begin AShortCutText := Copy(S, P + 1, Length(S) - P); StrLCopy(S, S, P - 1); end; if MI.hSubMenu = 0 then begin AItem := TdxBarButton.Create(Owner); if MI.fState and MFS_CHECKED <> 0 then with TdxBarButton(AItem) do begin ButtonStyle := bsChecked; Down := True; end; with AItem do begin Tag := MI.wID; OnClick := ButtonClick; end; end else begin AItem := TdxBarSubItem.Create(Owner); BuildSubMenu(TCustomdxBarSubItem(AItem), MI.hSubMenu); end; BarDesignController.AddInternalItem(AItem); with AItem do begin Caption := S; Enabled := MI.fState and (MFS_DISABLED or MFS_GRAYED) = 0; if MI.hbmpItem in [HBMMENU_POPUP_CLOSE..HBMMENU_POPUP_MINIMIZE] then Glyph.Handle := LoadBitmap(HInstance, PChar(BitmapNames[MI.hbmpItem])) else begin if MI.fState and MFS_CHECKED <> 0 then if MI.hbmpChecked <> 0 then Glyph.Handle := CopyImage(MI.hbmpChecked, IMAGE_BITMAP, 0, 0, 0) else else if MI.hbmpUnchecked <> 0 then Glyph.Handle := CopyImage(MI.hbmpUnchecked, IMAGE_BITMAP, 0, 0, 0); if (Glyph.Handle = 0) and (MI.fType and MFT_BITMAP <> 0) then Glyph.Handle := CopyImage(HBITMAP(MI.dwTypeData), IMAGE_BITMAP, 0, 0, 0); end; ShortCut := TextToShortCut(AShortCutText); end; with SubItem.ItemLinks.Add do begin BeginGroup := ABeginGroup; Item := AItem; end; ABeginGroup := False; end; finally FreeMem(S); end; end; begin BarDesignController.ClearInternalItems; BuildSubMenu(Self, GetSystemMenu(FMDIChildHandle, False)); end; procedure TSystemMenuSubItem.DirectClick; begin BuildMenu; inherited; end; { TSystemMenuSubItemControl } type TSystemMenuSubItemControl = class(TdxBarSubItemControl) private function GetItem: TSystemMenuSubItem; protected function CanCustomize: Boolean; override; function CanSelect: Boolean; override; procedure DblClick; override; function HasShadow: Boolean; override; function GetDefaultHeight: Integer; override; function GetDefaultWidth: Integer; override; function IsExpandable: Boolean; override; procedure Paint(ARect: TRect; PaintType: TdxBarPaintType); override; function WantsDblClick: Boolean; override; public property Item: TSystemMenuSubItem read GetItem; end; function TSystemMenuSubItemControl.GetItem: TSystemMenuSubItem; begin Result := TSystemMenuSubItem(ItemLink.Item); end; function TSystemMenuSubItemControl.CanCustomize: Boolean; begin Result := False; end; function TSystemMenuSubItemControl.CanSelect: Boolean; begin Result := not BarManager.IsCustomizing; end; procedure TSystemMenuSubItemControl.DblClick; begin inherited; Parent.HideAll; with Item do SendMessage(FMDIChildHandle, WM_SYSCOMMAND, GetMenuDefaultItem(GetSystemMenu(FMDIChildHandle, False), 0, 0), 0); end; function TSystemMenuSubItemControl.HasShadow: Boolean; begin Result := False; end; function TSystemMenuSubItemControl.GetdefaultHeight: Integer; begin Result := GetSystemMetrics(SM_CYSMICON); end; function TSystemMenuSubItemControl.GetDefaultWidth: Integer; begin Result := GetSystemMetrics(SM_CXSMICON); end; function TSystemMenuSubItemControl.IsExpandable: Boolean; begin Result := False; end; procedure TSystemMenuSubItemControl.Paint(ARect: TRect; PaintType: TdxBarPaintType); var Icon: HIcon; begin Icon := Item.IconHandle; with ARect do begin Parent.FillBackground(Parent.Canvas.Handle, ARect, Parent.BkBrush, clNone, True); DrawIconEx(Parent.Canvas.Handle, Left, Top, Icon, Right - Left, Bottom - Top, 0, 0{Parent.BkBrush}, DI_NORMAL); end; DestroyIcon(Icon); end; function TSystemMenuSubItemControl.WantsDblClick: Boolean; begin Result := True; end; { continuation } function TdxBarManager.ActiveMDIChild: HWND; begin if (Application.MainForm <> nil) and (Application.MainForm.ClientHandle <> 0) then Result := SendMessage(Application.MainForm.ClientHandle, WM_MDIGETACTIVE, 0, 0) else Result := 0; end; procedure TdxBarManager.CreateMDIChildSystemMenu(AWnd: HWND); var ASystemMenuSubItem: TSystemMenuSubItem; begin if GetSystemMenu(AWnd, False) = 0 then Exit; ASystemMenuSubItem := TSystemMenuSubItem.Create(Owner);//#DG BarDesignController.AddInternalItem(ASystemMenuSubItem, FInternalItems); ASystemMenuSubItem.MDIChildHandle := AWnd; with MainMenuBar.ItemLinks.Add do begin Item := ASystemMenuSubItem; Index := 0; end; end; procedure TdxBarManager.DestroyMDIChildSystemMenu; begin FInternalItems.Clear; end; procedure TdxBarManager.MDIStateChanged(AChange: TdxBarMDIStateChange; AWnd: HWND); type TMergeOperation = (moNone, moMerge, moUnmerge); procedure UpdateSystemMenu; begin if MainMenuBar <> nil then if (AChange <> scChildDeactivated) and IsMDIMaximized then CreateMDIChildSystemMenu(AWnd) else if (AChange = scChildDeactivated) or (AChange = scMaximizedChanged) and not IsMDIMaximized then DestroyMDIChildSystemMenu; end; function GetMergeOperation: TMergeOperation; begin Result := moNone; if not ((AChange = scMaximizedChanged) and FAlwaysMerge) then if (AChange <> scChildDeactivated) and (FAlwaysMerge or IsMDIMaximized) then Result := moMerge else if (AChange = scChildDeactivated) or (AChange = scMaximizedChanged) and not IsMDIMaximized then Result := moUnmerge; end; procedure DoMenuMerging; var ABar: TdxBar; ABarManager: TdxBarManager; AMergedBarList: TList; I: Integer; begin ABarManager := GetBarManagerByHandle(AWnd); if (MainMenuBar = nil) or (ABarManager = nil) or (ABarManager.MainMenuBar = nil) then Exit; case GetMergeOperation of moMerge: if Assigned(FOnMenuMerge) then begin FOnMenuMerge(Self, ABarManager, True); if ABarManager.MainMenuBar.MergeData.MergedWith = nil then begin ABarManager.MainMenuBar.MergeData.MergedWith := MainMenuBar; MainMenuBar.MergeData.MergedBarList.Add(ABarManager.MainMenuBar); ABarManager.MainMenuBar.MergeData.PrevVisible := ABarManager.MainMenuBar.Visible; end; ABarManager.MainMenuBar.SetVisibility(False); end else MainMenuBar.Merge(ABarManager.MainMenuBar); moUnmerge: begin AMergedBarList := TList.Create; try MainMenuBar.MergeData.SaveMergedBarList(AMergedBarList); MainMenuBar.InternalUnmergeFromBar(nil, False); if Assigned(FOnMenuMerge) then FOnMenuMerge(Self, ABarManager, False); for I := 0 to AMergedBarList.Count - 1 do begin ABar := TdxBar(AMergedBarList[I]); ABar.SetVisibility(ABar.MergeData.PrevVisible); end; finally AMergedBarList.Free; end; end; end; end; procedure DoMerging; var ABarManager: TdxBarManager; begin if Assigned(FOnMerge) then begin ABarManager := GetBarManagerByHandle(AWnd); if (ABarManager <> nil) and (GetMergeOperation <> moNone) then FOnMerge(Self, ABarManager, GetMergeOperation = moMerge); end; end; var AEventData: TdxBarMDIStateChangeEventData; begin UpdateSystemMenu; DoMenuMerging; DoMerging; AEventData.Change := AChange; AEventData.Wnd := AWnd; FMDIStateChangedHandlers.CallEvents(Self, AEventData); end; procedure TdxBarManager.CheckToolbarsVisibility; var WorkArea, R: TRect; I: Integer; begin WorkArea := GetWorkArea(Point(Owner.Left + Owner.Width div 2, Owner.Top + Owner.Height div 2));//#DG for I := 0 to FBars.Count - 1 do with FBars[I] do if DockingStyle = dsNone then begin if Control = nil then R := Bounds(FloatLeft, FloatTop, BarNCSizeX(dsNone) + FloatClientWidth, BarNCSizeY(dsNone) + FloatClientHeight) else R := Control.BoundsRect; with WorkArea do begin if R.Bottom > Bottom then OffsetRect(R, 0, Bottom - R.Bottom); if R.Top < Top then OffsetRect(R, 0, Top - R.Top); if R.Right > Right then OffsetRect(R, Right - R.Right, 0); if R.Left < Left then OffsetRect(R, Left - R.Left, 0); end; if Control = nil then begin LockDesignerModified(True); try FloatLeft := R.Left; FloatTop := R.Top; finally LockDesignerModified(False); end; end else Control.BoundsRect := R; end; end; class function TdxBarManager.IsFormBroadcastMessage(AMsg: UINT): Boolean; begin Result := (AMsg = WM_ACTIVATE) or (AMsg = WM_ACTIVATEAPP) or (AMsg = WM_CHILDACTIVATE) or (AMsg = WM_MDIACTIVATE) or (AMsg = WM_SETTINGCHANGE) or (AMsg = WM_SYSCOLORCHANGE) or (AMsg = WM_SYSCOMMAND) or (AMsg = WM_WINDOWPOSCHANGED) or (AMsg = WM_WINDOWPOSCHANGING); end; procedure TdxBarManager.MainFormClientWndProc(Msg: UINT; wParam: WPARAM; lParam: LPARAM); var APrevIsMDIMaximized: Boolean; begin APrevIsMDIMaximized := IsMDIMaximized; FIsMDIMaximized := (ActiveMDIChild <> 0) and IsZoomed(ActiveMDIChild); BeginUpdate; try if ActiveMDIChild <> FPrevActiveMDIChild then begin MDIStateChanged(scChildDeactivated, FPrevActiveMDIChild); MDIStateChanged(scChildActivated, ActiveMDIChild); end else if IsMDIMaximized <> APrevIsMDIMaximized then MDIStateChanged(scMaximizedChanged, ActiveMDIChild); finally EndUpdate; end; if (IsMDIMaximized <> APrevIsMDIMaximized) and (MainMenuControl <> nil) then MainMenuControl.RepaintBar; FPrevActiveMDIChild := ActiveMDIChild; end; procedure TdxBarManager.OwnerWndProc(AWnd: HWND; AMsg: UINT; wParam: WPARAM; lParam: LPARAM); procedure HandleFormBroadcastMessage; var ABar: TdxBar; I: Integer; begin case AMsg of WM_ACTIVATE: DoActivate(LOWORD(wParam), HiWord(wParam), AWnd, lParam); WM_ACTIVATEAPP: DoActivateApp(Bool(wParam), lParam); WM_CHILDACTIVATE: ActivateFloatToolbars(True, False, 0); WM_MDIACTIVATE: ActivateFloatToolbars(HWND(lParam) = AWnd, False, 0); WM_SETTINGCHANGE: case wParam of SPI_SETNONCLIENTMETRICS: AssignFont; SPI_SETWORKAREA: CheckToolbarsVisibility; end; WM_SYSCOLORCHANGE: begin RefreshDeviceConsts; CreatePatternBrush; RecreateToolbarsBrushes; RefreshFloatingBarsShadows; end; WM_SYSCOMMAND: begin if (wParam = SC_CLOSE) and Designing and (ActiveBarControl <> nil) and (ActiveBarManager = Self) then ActiveBarControl.HideAll; if (wParam = SC_MINIMIZE) or (wParam = SC_MAXIMIZE) or (wParam = SC_RESTORE) or (wParam = SC_CLOSE) then begin for I := 0 to Bars.Count - 1 do begin ABar := Bars[I]; if ABar.Visible and (ABar.Control <> nil) and (ABar.DockingStyle = dsNone) then if (wParam = SC_MINIMIZE) or (wParam = SC_CLOSE) then ShowWindow(ABar.Control.Handle, SW_HIDE) else begin ShowWindow(ABar.Control.Handle, SW_SHOWNOACTIVATE); UpdateWindow(ABar.Control.Handle); end; end; //if IsWindowVisible(MainForm.Handle) then ProcessPaintMessages; end; end; WM_WINDOWPOSCHANGING: if PWindowPos(lParam).flags and SWP_HIDEWINDOW <> 0 then ActivateFloatToolbars(False, True, 0); WM_WINDOWPOSCHANGED: begin if FIsCustomizing and (dxBarCustomizingForm <> nil) then begin dxBarCustomizingForm.UpdateVisibility(PWindowPos(lParam)^); if dxBarSubMenuEditor <> nil then if PWindowPos(lParam).flags and SWP_SHOWWINDOW <> 0 then ShowWindow(dxBarSubMenuEditor.Handle, SW_SHOWNA) else if PWindowPos(lParam).flags and SWP_HIDEWINDOW <> 0 then ShowWindow(dxBarSubMenuEditor.Handle, SW_HIDE); end; if PWindowPos(lParam).flags and SWP_SHOWWINDOW <> 0 then ActivateFloatToolbars(True, False, 0); end; end; end; procedure HandleOwnerMessage; var AContextID: Integer; AControl: TWinControl; AItem: TdxBarItemControl; P: TPoint; begin case AMsg of WM_CANCELMODE: DoModalActivate; WM_CREATE: DoCreate; WM_DISPLAYCHANGE: CheckToolbarsVisibility; WM_HELP: if not Designing and (PHelpInfo(lParam).iContextType = HELPINFO_WINDOW) then with PHelpInfo(lParam)^ do begin AItem := nil; if ActiveBarControl <> nil then begin AControl := ActiveBarControl; AItem := TCustomdxBarControl(AControl).SelectedControl; if (AItem = nil) or (AItem.Item.HelpContext = 0) then begin while TCustomdxBarControl(AControl).ParentBar <> nil do begin AItem := TdxBarSubMenuControl(AControl).FSubItem; AControl := TCustomdxBarControl(AControl).ParentBar; if (AItem = nil) or (AItem.Item.HelpContext <> 0) then Break; end; if (AItem = nil) or (AItem.Item.HelpContext = 0) then begin HideAll; AContextID := AControl.HelpContext; if AContextID <> 0 then if biHelp in TCustomFormAccess(GetBarManagerForm(Self, fkAny)).BorderIcons then Application.HelpCommand(HELP_CONTEXTPOPUP, AContextID) else Application.HelpContext(AContextID); Exit; end; end; end else begin AControl := FindControl(hItemHandle); if AControl is TCustomdxBarControl then begin P := MousePos; ScreenToClient(AControl.Handle, P); AItem := TCustomdxBarControl(AControl).ItemAtPos(P); end; end; if AItem <> nil then begin with AItem.ItemBounds do P := Point((Left + Right) div 2, Bottom); ClientToScreen(AControl.Handle, P); AContextID := AItem.Item.HelpContext; HideAll; if AContextID = 0 then Exit; if biHelp in TCustomFormAccess(GetBarManagerForm(Self, fkAny)).BorderIcons then begin Application.HelpCommand(HELP_SETPOPUP_POS, Longint(PointToSmallPoint(P))); Application.HelpCommand(HELP_CONTEXTPOPUP, AContextID); end else Application.HelpContext(AContextID); end; end; end; end; begin if (csDestroying in Owner.ComponentState) or (Owner = dxBarCustomizingForm) then begin if (AMsg = WM_DESTROY) and not Designing then begin if StoreInRegistry then SaveToRegistry(RegistryPath); if StoreInIniFile then SaveToIniFile(IniFileName); end; Exit; end; if Bars = nil then Exit; if IsFormBroadcastMessage(AMsg) then HandleFormBroadcastMessage else HandleOwnerMessage; {WM_NCACTIVATE: - does not allow submenu.edit.setfocus if TCustomFormAccess(MainForm).FormStyle = fsMDIChild then ActivateToolbars(Boolean(wParam), False, 0);} end; class procedure TdxBarManager.SendFormBroadcastMessage( AOwnerHandle: HWND; AMsg: UINT; wParam: WPARAM; lParam: LPARAM); var ABarManager: TdxBarManager; I: Integer; begin if IsFormBroadcastMessage(AMsg) then for I := 0 to dxBarManagerList.Count - 1 do begin ABarManager := dxBarManagerList[I]; if ABarManager.Owner.HandleAllocated and (ABarManager.Owner.Handle <> AOwnerHandle) and IsBarManagerOwner(ABarManager, AOwnerHandle) then ABarManager.OwnerWndProc(AOwnerHandle, AMsg, wParam, lParam); end; end; var HintTimerABarManager: TdxBarManager; procedure ShowHintTimerProc(Wnd: HWnd; Msg, TimerID, SysTime: Longint); stdcall; begin if (HintTimerABarManager <> nil) and not HintTimerABarManager.IsDestroying then with HintTimerABarManager do begin KillHintTimer; DisplayHint; end; end; procedure HideHintTimerProc(Wnd: HWnd; Msg, TimerID, SysTime: Longint); stdcall; begin if (HintTimerABarManager <> nil) and not HintTimerABarManager.IsDestroying then with HintTimerABarManager do begin KillHintTimer; HintActivate(False, ''); end; end; procedure KillHiddenHintTimerProc(Wnd: HWnd; Msg, TimerID, SysTime: Longint); stdcall; begin KillHiddenHintTimer; end; procedure TdxBarManager.DisplayHint; function ActivateHintWindow(const AHintText: string; AShortCut: string = ''): Boolean; begin Result := FHintWindow.ActivateHint(Self, AHintText, AShortCut); if Result then begin FHintWindowShowing := True; HintTimerABarManager := Self; FHintTimerID := SetTimer(0, 0, FHintWindow.HideHintTime, @HideHintTimerProc); end; end; var AHintKeeper: IdxBarHintKeeper; ANeedDeactivate: Boolean; AHintText, AShortCut: string; begin ANeedDeactivate := True; if FCustomHint <> '' then ANeedDeactivate := not ActivateHintWindow(FCustomHint) else if Supports(FHintObject, IdxBarHintKeeper, AHintKeeper) then if AHintKeeper.DoHint(ANeedDeactivate, AHintText, AShortCut) then begin if AHintKeeper.GetEnabled or ShowHintForDisabledItems then begin if not ShowShortCutInHint and not Application.HintShortCuts then AShortCut := ''; ANeedDeactivate := not ActivateHintWindow(AHintText, AShortCut); end else ANeedDeactivate := True; end; if ANeedDeactivate then HintActivate(False, ''); end; var FHintTimerPrevShow: Boolean; //*** procedure TdxBarManager.HintActivate(AShow: Boolean; const CustomHint: string; AHintObject: TObject); var PrevShow: Boolean; begin if IsCustomizing or not FShowHint or (not AShow and not FHintTimerPrevShow){***} then Exit; FHintTimerPrevShow := AShow; //*** FCustomHint := CustomHint; FHintWindowShowing := False; PrevShow := AShow; //#DG AShow := AShow and ((SelectedItem <> nil) and not SelectedItem.Parent.IsActive or (FCustomHint <> '') or (AHintObject <> nil)); KillHintTimer; FHintObject := AHintObject; if AShow then begin if not IsWindowVisible(FHintWindow.Handle) and not FLiveHiddenHint then begin HintTimerABarManager := Self; FHintTimerID := SetTimer(0, 0, FHintWindow.ShowHintTime, @ShowHintTimerProc); end else DisplayHint; end else begin if IsWindowVisible(FHintWindow.Handle) then begin ShowWindow(FHintWindow.Handle, SW_HIDE); if PrevShow then begin KillHiddenHintTimer; FLiveHiddenHint := True; FHiddenHintTimerID := SetTimer(0, 0, dxBarHiddedHintLifeTime, @KillHiddenHintTimerProc); end; end; end; end; procedure TdxBarManager.DestroyItems; begin FreeAndNil(FInternalItems); FItems.OwnsObjects := True; FreeAndNil(FItems); end; procedure TdxBarManager.HelpButtonGlyphChanged(Sender: TObject); begin UpdateHelpButton; end; procedure TdxBarManager.CalcMostRecentlyUsedUseCount; var I: Integer; begin if FMostRecentItemsPercents = 100 then FMostRecentlyUsedUseCount := 0 else for I := 1 to MaxInt do if I * (100 - FMostRecentItemsPercents) div 100 > 0 then begin FMostRecentlyUsedUseCount := I; Break; end; end; function TdxBarManager.ShowRecentItemsFirst: Boolean; begin Result := CanShowRecentItems and MenusShowRecentItemsFirst; end; procedure TdxBarManager.AddDockControl(ADockControl: TdxDockControl); begin FDockControls.Add(ADockControl); FreeNotification(ADockControl); end; procedure TdxBarManager.RemoveDockControl(ADockControl: TdxDockControl); var I: Integer; begin if FBars <> nil then for I := 0 to FBars.Count - 1 do with FBars[I] do begin if DockControl = ADockControl then DockControl := nil; if DockedDockControl = ADockControl then DockedDockControl := nil; if RealDockControl = ADockControl then Visible := False; end; if FDockControls <> nil then FDockControls.Remove(ADockControl); if ADockControl.Main and (FBars <> nil) then FBars.FDockControls[ADockControl.FDockingStyle] := nil; ADockControl.ParentColor := True; end; procedure TdxBarManager.AddGroup(AGroup: TdxBarGroup); begin FGroups.Add(AGroup); AGroup.FBarManager := Self; end; {#DG procedure TdxBarManager.RemoveGroup(AGroup: TdxBarGroup); begin FGroups.Remove(AGroup); end; } function TdxBarManager.CorrectRegistryPath(var APath: string): Boolean; begin Result := APath <> ''; if Result then begin if APath[1] <> '\' then APath := '\' + APath; if APath[Length(APath)] <> '\' then APath := APath + '\'; end; end; function TdxBarManager.GetSavedBarIndex(const ABarCaption: string): Integer; var ABarCount, I: Integer; begin Result := -1; ABarCount := SavedState.ReadInteger( GetBarManagerSection(GetBaseIniSection, skIni), 'BarCount', 0); for I := 0 to ABarCount - 1 do if SavedState.ReadString(TdxBar.GetIniSection(GetBaseIniSection, I), 'Caption', '') = ABarCaption then begin Result := I; Break; end; end; function TdxBarManager.IsDockColorStored: Boolean; begin Result := not FAutoDockColor; end; procedure TdxBarManager.LoadLinkItemNames; var I: Integer; begin for I := 0 to ItemCount - 1 do if Items[I].GetItemLinks <> nil then Items[I].GetItemLinks.LoadItemNames; for I := 0 to Bars.Count - 1 do Bars[I].ItemLinks.LoadItemNames; end; procedure TdxBarManager.ReadBars(AReader: TReader); var AItem: TdxBar; I: Integer; begin AReader.ReadValue; I := 0; while not AReader.EndOfList do begin if AReader.NextValue in [vaInt8, vaInt16, vaInt32] then AReader.ReadInteger; if I < Bars.Count then AItem := Bars[I] else AItem := Bars.Add; Inc(I); AItem.FIsNameLocked := True; try AReader.ReadListBegin; while not AReader.EndOfList do TReaderAccess(AReader).ReadProperty(AItem); AReader.ReadListEnd; finally AItem.FIsNameLocked := False; end; end; AReader.ReadListEnd; end; procedure TdxBarManager.ReadDockControlHeights(Reader: TReader); begin with Reader, FBars do begin ReadListBegin; try FDockControls[dsLeft].Width := ReadInteger; FDockControls[dsRight].Width := ReadInteger; FDockControls[dsTop].Height := ReadInteger; FDockControls[dsBottom].Height := ReadInteger; finally ReadListEnd; end; end; end; procedure TdxBarManager.SaveState; begin if SavedState <> nil then begin Include(FInternalState, bisStateSaving); try SaveBarManager(SavedState, GetBaseIniSection, skIni); finally Exclude(FInternalState, bisStateSaving); end; end; end; procedure TdxBarManager.WriteDockControlHeights(Writer: TWriter); begin with Writer, FBars do begin WriteListBegin; try WriteInteger(FDockControls[dsLeft].Width); WriteInteger(FDockControls[dsRight].Width); WriteInteger(FDockControls[dsTop].Height); WriteInteger(FDockControls[dsBottom].Height); finally WriteListEnd; end; end; end; procedure TdxBarManager.CreateFlatToolbarsBrushes; begin DestroyFlatToolbarsBrushes; FFlatToolbarsBorderBrush := CreateSolidBrush(FlatToolbarsBorderColor); FFlatToolbarsBrush := CreateSolidBrush(FlatToolbarsColor); FFlatToolbarsDownedBrush := CreateSolidBrush(FlatToolbarsDownedColor); FFlatToolbarsDownedSelBrush := CreateSolidBrush(FlatToolbarsDownedSelColor); FFlatToolbarsSelBrush := CreateSolidBrush(FlatToolbarsSelColor); end; procedure TdxBarManager.DestroyFlatToolbarsBrushes; begin DeleteGDIObject(FFlatToolbarsSelBrush); DeleteGDIObject(FFlatToolbarsDownedSelBrush); DeleteGDIObject(FFlatToolbarsDownedBrush); DeleteGDIObject(FFlatToolbarsBrush); DeleteGDIObject(FFlatToolbarsBorderBrush); end; procedure TdxBarManager.CreateThemeToolbarsBrushes; begin DestroyThemeToolbarsBrushes; if FThemeAvailable then begin FThemeToolbarsBrush := CreateSolidBrush(ThemeToolbarColor); // FThemeToolbarsDownedBrush := CreateSolidBrush(); // FThemeToolbarsDownedSelBrush := CreateSolidBrush(); // FThemeToolbarsSelBrush := CreateSolidBrush(); end; end; procedure TdxBarManager.DestroyThemeToolbarsBrushes; begin // if FThemeToolbarsSelBrush <> 0 then DeleteObject(FThemeToolbarsSelBrush); // if FThemeToolbarsDownedSelBrush <> 0 then DeleteObject(FThemeToolbarsDownedSelBrush); // if FThemeToolbarsDownedBrush <> 0 then DeleteObject(FThemeToolbarsDownedBrush); DeleteGDIObject(FThemeToolbarsBrush); end; procedure TdxBarManager.DestroyToolbarsBrushes; begin DestroyThemeToolbarsBrushes; DestroyFlatToolbarsBrushes; ReleaseOffice11Colors; end; procedure TdxBarManager.CreateToolbarsBrushes; begin CreateFlatToolbarsBrushes; CreateThemeToolbarsBrushes; CreateOffice11Colors; ResetBackgrounds; end; procedure TdxBarManager.RecreateToolbarsBrushes; begin CreateFlatToolbarsBrushes; CreateThemeToolbarsBrushes; RefreshOffice11Colors; ResetBackgrounds; end; procedure TdxBarManager.RefreshFloatingBarsShadows; var I: Integer; begin for I := 0 to Bars.Count - 1 do if (Bars[I].DockingStyle = dsNone) and (Bars[I].Control <> nil) then Bars[I].Control.RefreshShadow; end; procedure TdxBarManager.ResetBackgrounds; var I: Integer; begin for I := 0 to DockControlCount - 1 do begin // DockControls[I].ResetBackground; DockControls[I].BarManagerChanged; DockControls[I].UpdateDoubleBuffered; DockControls[I].Invalidate; end; for I := 0 to Bars.Count - 1 do if Bars[I].Control <> nil then begin Bars[I].Control.ResetBackground; Bars[I].Control.UpdateDoubleBuffered; Bars[I].Control.FullInvalidate; end; end; procedure TdxBarManager.InitPainter; begin FThemeAvailable := AreVisualStylesAvailable([totToolBar, totComboBox, totEdit, totWindow, totScrollBar, totRebar, totStatus, totSpin, totProgress]); FreeAndNil(FDefaultPainter); FDefaultPainter := GetPainterClass.Create(0); end; procedure TdxBarManager.InternalStyleChanged; var I: Integer; begin FChangingStyle := True; try InitPainter; for I := 0 to Bars.Count - 1 do with Bars[I] do if Control <> nil then Control.BarManagerStyleChanged; HostBarManagerStyleChanged; ResetBackgrounds; finally FChangingStyle := False; end; end; procedure TdxBarManager.ThemeChanged; begin InternalStyleChanged; end; procedure TdxBarManager.LFChanged(Sender: TcxLookAndFeel; AChangedValues: TcxLookAndFeelValues); begin if not IsDestroying then InternalStyleChanged; end; procedure TdxBarManager.DoActivate(AState, AMinimized: WORD; AHandle, AWndPrevious: HWND); var AControl: TWinControl; AMainForm: TCustomForm; ANeedActivate: Boolean; begin Include(FInternalState, bisFormActivating); try AMainForm := GetBarManagerForm(Self, fkMainOrMDIChild); if IsMDIChild(AMainForm) and (Application.MainForm.ActiveMDIChild <> AMainForm) then Exit; AMainForm := GetMainForm; AControl := FindControl(AWndPrevious); if (AState = WA_INACTIVE) and (AControl is TCustomdxBarControl) and (TCustomdxBarControl(AControl).BarManager.GetMainForm = AMainForm) then Exit; if {(AState = WA_INACTIVE) and }(ActiveBarControl <> nil) and (ActiveBarControl.SelectedControl <> nil) and ActiveBarControl.SelectedControl.IsChildWindow(AWndPrevious) then Exit; ANeedActivate := MainFormActive and not (IsWindowEnabled(AMainForm.Handle) or Designing) or (AState <> WA_INACTIVE) or (AMainForm.Handle = AWndPrevious); ActivateFloatToolbars(ANeedActivate, False, AWndPrevious); if not (bisToolbarsVisibleChanging in FInternalState) and (AState <> WA_INACTIVE) and //ANeedActivate and (dxBarCustomizingForm <> nil) and FIsCustomizing and not IsWindowEnabled(AMainForm.Handle) and not IsChildEx(dxBarCustomizingForm.Handle, AHandle) then SendMessage(dxBarCustomizingForm.Handle, WM_ACTIVATE, MakeWParam(AState, AMinimized), AMainForm.Handle); if (AState = WA_INACTIVE) and (AMainForm.Handle <> AWndPrevious) and (FMouseTrackingBarControl <> nil) then FMouseTrackingBarControl.MouseLeave; finally Exclude(FInternalState, bisFormActivating); end; end; procedure TdxBarManager.DoActivateApp(AActivate: Boolean; AThreadID: DWORD); begin if bisModalActivating in FInternalState then Exit; if not AActivate then begin if MainFormActive and not IsWindowEnabled(GetMainForm.Handle) then Include(FInternalState, bisWasActive); ActivateFloatToolbars(False, False, 0); //#DG if SelectedItem <> nil then SendMessage(SelectedItem.Parent.Handle, WM_MOUSELEAVE, 0, 0); //#DG SelectedItem := nil; end else {TODO} if bisWasActive in FInternalState then begin ActivateFloatToolbars(True, False, 0); Exclude(FInternalState, bisWasActive); end; end; procedure TdxBarManager.DoCreate; var I: Integer; begin if BarRestoringListExists then begin Include(FInternalState, bisHandleCreating); try for I := 0 to DockControlCount - 1 do if CanAllocateHandle(DockControls[I]) then // for BarDockControl DockControls[I].HandleNeeded; ShowBarsFromRestoringList(nil); finally if RestoringListBarCount = 0 then // for BarDockControl DestroyBarRestoringList; Exclude(FInternalState, bisHandleCreating); end; end; end; procedure TdxBarManager.DoModalActivate; begin Include(FInternalState, bisModalActivating); try if not IsInternalWindowsDisabling and (ActiveBarControl <> nil) and ActiveBarControl.HideOnClick then ActiveBarControl.HideAll; finally Exclude(FInternalState, bisModalActivating); end; end; procedure TdxBarManager.DoLockUpdate(ALock: Boolean; ACheckBarsChanges: Boolean); var ABar: TdxBar; ADockControl: TdxDockControl; I, J: Integer; begin try for I := 0 to DockControlCount - 1 do if DockControls[I].Visible and DockControls[I].HandleAllocated then SendMessage(DockControls[I].Handle, WM_SETREDRAW, WPARAM(not ALock), 0); if not ALock then begin if FChangedSubMenuControl <> nil then begin FChangedSubMenuControl.RepaintBar; FChangedSubMenuControl := nil; end; for I := 0 to Bars.Count - 1 do begin ABar := Bars[I]; if ABar.Control <> nil then if ACheckBarsChanges and ((ABar.DockingStyle = dsNone) or ABar.FChanged) then ABar.Control.RecreateControls; end; for I := 0 to Bars.Count - 1 do begin ABar := Bars[I]; if ABar.Control <> nil then if ACheckBarsChanges and ((ABar.DockingStyle = dsNone) or ABar.FChanged) then ABar.Control.RepaintBarEx(False) else begin ABar.Control.FrameChanged; ABar.Control.Repaint; end; end; for I := 0 to DockControlCount - 1 do begin ADockControl := DockControls[I]; for J := ADockControl.RowCount - 1 downto 0 do if TdxDockRow(ADockControl.RowList[J]).FBars.Count = 0 then begin TdxDockRow(ADockControl.RowList[J]).Free; ADockControl.RowList.Delete(J); end; if ADockControl.Visible and ADockControl.HandleAllocated then begin ADockControl.UpdateDock; SendMessage(ADockControl.Handle, WM_NCPAINT, 0, 0); end; end; end; finally for I := 0 to Bars.Count - 1 do Bars[I].FChanged := False; end; end; function TdxBarManager.GetItemLinkWithAccel(AKey: Word; AShift: TShiftState): TdxBarItemLink; function GlobalFindItemWithAccel(ABarManager: TdxBarManager): TdxBarItemLink; var ABar: TdxBar; I: Integer; begin if ABarManager.MainMenuControl <> nil then Result := ABarManager.MainMenuBar.ItemLinks.FindItemWithAccel(AKey, AShift, nil) else Result := nil; if Result = nil then for I := 0 to ABarManager.Bars.Count - 1 do begin ABar := ABarManager.Bars[I]; if ABar.Visible and not ABar.IsMainMenu then begin Result := ABar.ItemLinks.FindItemWithAccel(AKey, AShift, nil); if Result <> nil then Break; end; end; end; var ATempBarManager: TdxBarManager; AWnd: HWND; begin Result := nil; AWnd := Owner.Handle; repeat ATempBarManager := GetBarManagerByHandle(AWnd); if ATempBarManager <> nil then Result := GlobalFindItemWithAccel(ATempBarManager); if not IsChildClassWindow(AWnd) then Break; AWnd := GetParent(AWnd); until Result <> nil; if Result = nil then begin ATempBarManager := Self; repeat ATempBarManager := dxBarManagerList.NextActive(ATempBarManager, True); if ATempBarManager = Self then Break; Result := GlobalFindItemWithAccel(ATempBarManager); until Result <> nil; end; end; function TdxBarManager.HandleShortCut(AShortCut: TShortCut): Boolean; function IsBarManagerShortCut(ABarManager: TdxBarManager; AShortCut: TShortCut): Boolean; var ABar: TdxBar; I: Integer; begin Result := (ABarManager.MainMenuBar <> nil) and (ABarManager.MainMenuBar.IsShortCut(AShortCut)); if not Result then for I := 0 to ABarManager.Bars.Count - 1 do begin ABar := ABarManager.Bars[I]; if ABar.Visible and not ABar.IsMainMenu and (ABar.Control <> nil) and ABar.Control.HandleAllocated and IsWindowVisible(ABar.Control.Handle) then begin Result := ABar.IsShortCut(AShortCut); if Result then Break; end; end; end; var AControl: TWinControl; ATempBarManager: TdxBarManager; AWnd: HWND; begin AControl := FindVCLControl(GetFocus); ATempBarManager := GetBarManagerForComponent(AControl); Result := (ATempBarManager <> nil) and ATempBarManager.PopupMenuLinks.IsShortCut(AControl, AShortCut); if not Result then begin AWnd := Owner.Handle; repeat ATempBarManager := GetBarManagerByHandle(AWnd); Result := (ATempBarManager <> nil) and IsBarManagerShortCut(ATempBarManager, AShortCut); if not IsChildClassWindow(AWnd) then Break; AWnd := GetParent(AWnd); until Result; end; if not Result then begin ATempBarManager := Self; repeat ATempBarManager := dxBarManagerList.NextActive(ATempBarManager, True); if ATempBarManager = Self then Break; Result := IsBarManagerShortCut(ATempBarManager, AShortCut); until Result; end; end; function TdxBarManager.CanDeleteComponent(AComponent: TComponent): Boolean; begin Result := (FdxBarDesignHelper = nil) or FdxBarDesignHelper.CanDeleteComponent(AComponent); end; procedure TdxBarManager.GetSelection(AList: TList); begin if FdxBarDesignHelper <> nil then FdxBarDesignHelper.GetSelection(AList); end; function TdxBarManager.GetSelectionStatus(AComponent: TPersistent): TdxBarSelectionStatus; begin if FdxBarDesignHelper <> nil then Result := FdxBarDesignHelper.GetSelectionStatus(AComponent) else Result := ssUnselected; end; function TdxBarManager.IsComponentSelected(AComponent: TPersistent): Boolean; begin Result := (GetSelectionStatus(AComponent) = ssActiveSelected); end; procedure TdxBarManager.SelectComponent(AComponent: TPersistent; ASelectionOperation: TdxBarSelectionOperation = soExclusive); begin if FdxBarDesignHelper <> nil then FdxBarDesignHelper.SelectComponent(AComponent, ASelectionOperation); end; procedure TdxBarManager.SetSelection(AList: TList); begin if FdxBarDesignHelper <> nil then FdxBarDesignHelper.SetSelection(AList); end; procedure TdxBarManager.ShowDefaultEventHandler(AItem: TdxBarItem); begin if FdxBarDesignHelper <> nil then FdxBarDesignHelper.ShowDefaultEventHandler(AItem); end; function TdxBarManager.UniqueName(const BaseName: string): string; begin if FdxBarDesignHelper <> nil then Result := FdxBarDesignHelper.UniqueName(BaseName) end; procedure TdxBarManager.CreateBarRestoringList; begin if not BarRestoringListExists then FBarRestoringList := TList.Create; end; procedure TdxBarManager.DestroyBarRestoringList; begin FreeAndNil(FBarRestoringList); end; function TdxBarManager.BarRestoringListExists: Boolean; begin Result := FBarRestoringList <> nil; end; procedure TdxBarManager.AddBarToRestoringList(ABar: TdxBar); begin if BarRestoringListExists and (FBarRestoringList.IndexOf(ABar) = -1) then FBarRestoringList.Add(ABar); end; procedure TdxBarManager.RemoveBarFromRestoringList(ABar: TdxBar); begin if BarRestoringListExists then FBarRestoringList.Remove(ABar); end; procedure TdxBarManager.ShowBarsFromRestoringList(ADockControl: TdxBarDockControl); function CanShowBar(ABar: TdxBar): Boolean; begin if ADockControl = nil then Result := (ABar.RealDockControl = nil) or ABar.RealDockControl.HandleAllocated else Result := (ABar.DockControl = ADockControl) and (ABar.DockingStyle <> dsNone); end; var I: Integer; begin for I := RestoringListBarCount - 1 downto 0 do if CanShowBar(RestoringListBars[I]) then RestoringListBars[I].Visible := True; end; function TdxBarManager.GetBarIndexInRestoringList(ABar: TdxBar): Integer; begin if BarRestoringListExists then Result := FBarRestoringList.IndexOf(ABar) else Result := -1; end; procedure TdxBarManager.AssignFont; var NonClientMetrics: TNonClientMetrics; begin NonClientMetrics.cbSize := SizeOf(NonClientMetrics); SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, @NonClientMetrics, 0); if FUseSystemFont then begin FInternalFontChange := True; try Font.Handle := CreateFontIndirect(NonClientMetrics.lfMenuFont); finally FInternalFontChange := False; end; end else if FScaled then Font.Height := NonClientMetrics.lfMenuFont.lfHeight; end; function TdxBarManager.CanReset: Boolean; begin Result := (FReadStateCount > 0) and FAllowReset; end; procedure TdxBarManager.DefineProperties(Filer: TFiler); begin inherited; Filer.DefineProperty('Bars', ReadBars, nil, False); Filer.DefineProperty('DockControlHeights', ReadDockControlHeights, WriteDockControlHeights, True); end; procedure TdxBarManager.DesignerModified; function ComponentIsLoaded(AComponent: TComponent): Boolean; begin Result := (AComponent = nil) or not (csLoading in AComponent.ComponentState); end; function ImagesAreLoaded: Boolean; begin Result := ComponentIsLoaded(HotImages) and ComponentIsLoaded(Images) and ComponentIsLoaded(LargeImages) and ComponentIsLoaded(DisabledImages) and ComponentIsLoaded(DisabledLargeImages); end; begin if not (IsInitializing or IsDestroying) then if not CanModifyDesigner then FDesignerModifiedInvoked := True else begin FModified := True; if Designing and not (csUpdating in ComponentState) and not IsRecreating and ImagesAreLoaded and ([bisBarsLoading, bisHandleCreating] * FInternalState = []) then BarDesignController.DesignerModified(ParentForm); end; end; procedure TdxBarManager.DoBarAfterReset(ABar: TdxBar); begin if Assigned(FOnBarAfterReset) then FOnBarAfterReset(Self, ABar); end; procedure TdxBarManager.DoBarBeforeReset(ABar: TdxBar); begin if Assigned(FOnBarBeforeReset) then FOnBarBeforeReset(Self, ABar); end; procedure TdxBarManager.DoBarClose(ABar: TdxBar); begin if Assigned(FOnBarClose) then FOnBarClose(Self, ABar); end; procedure TdxBarManager.DoBarDockingStyleChanged(ABar: TdxBar); begin if not BarsLoading then begin if Assigned(FOnBarDockingStyleChange) then FOnBarDockingStyleChange(Self, ABar); //#DG DesignerModified; ABar.Changed(True); end; end; procedure TdxBarManager.DoClickItem(AItem: TdxBarItem); begin if Assigned(FOnClickItem) then FOnClickItem(Self, AItem); end; procedure TdxBarManager.DoCloseButtonClick; begin CallNotify(FOnCloseButtonClick, Self); end; function TdxBarManager.DoDocking(ABar: TdxBar; AStyle: TdxBarDockingStyle; ADockControl: TdxDockControl): Boolean; begin Result := not (AStyle in ABar.NotDocking) and (((ADockControl = nil) or ADockControl.Main) and not (AStyle in NotDocking) or (ADockControl <> nil) and not ADockControl.Main and ADockControl.CanDocking(ABar)); if Assigned(FOnDocking) then FOnDocking(ABar, AStyle, ADockControl, Result); end; procedure TdxBarManager.DoItemLinkChange(AItemLink: TdxBarItemLink); begin if Assigned(OnItemLinkChange) and not IsLoading then OnItemLinkChange(Self, AItemLink); end; procedure TdxBarManager.DoHelpButtonClick; begin CallNotify(FOnHelpButtonClick, Self); end; procedure TdxBarManager.DoMergeItemLink( ADstItemLinks, ASrcItemLinks: TdxBarItemLinks; ASrcItemLink: TdxBarItemLink; var AMergeKind: TdxBarItemMergeKind; var AMergeIndex: Integer); begin if Assigned(FOnMergeItemLink) then FOnMergeItemLink(Self, ADstItemLinks, ASrcItemLinks, ASrcItemLink, AMergeKind, AMergeIndex); end; procedure TdxBarManager.DoShowCustomizingPopup(PopupItemLinks: TdxBarItemLinks); begin if Assigned(FOnShowCustomizingPopup) then FOnShowCustomizingPopup(Self, PopupItemLinks); end; procedure TdxBarManager.DoShowToolbarsPopup(PopupItemLinks: TdxBarItemLinks); begin if Assigned(FOnShowToolbarsPopup) then FOnShowToolbarsPopup(Self, PopupItemLinks); end; procedure TdxBarManager.DragAndDrop(AItem: TdxBarItem; AItemLink: TdxBarItemLink); begin DragInfo.BeginDrag(AItem, AItemLink); try DragInfo.HandleDragging; finally DragInfo.EndDrag; end; end; function TdxBarManager.FindDockControl(APath: string): TdxBarDockControl; var ARootName: string; ARoot: TComponent; begin ARootName := Copy(APath, 1, Pos('.', APath) - 1); if ARootName <> '' then begin ARoot := FindGlobalComponent(ARootName); Delete(APath, 1, Length(ARootName) + 1); end else ARoot := Owner;//#DG Result := FindNestedComponent(ARoot, APath) as TdxBarDockControl; end; function TdxBarManager.GetCategoryRealIndex(AIndex: Integer): Integer; var I: Integer; begin if Designing then Result := AIndex else begin Result := -1; for I := 0 to FCategories.Count - 1 do if CategoryVisible[I] then begin Inc(Result); if Result = AIndex then begin Result := I; Exit; end; end; Result := -1; end; end; procedure TdxBarManager.GetChildren(Proc: TGetChildProc; Root: TComponent); var I: Integer; begin for I := 0 to Bars.Count - 1 do if Bars[I].Owner = Root then Proc(Bars[I]); for I := 0 to ItemCount - 1 do if (Items[I].Owner = Root) and (Items[I].Category > -1) then Proc(Items[I]); for I := 0 to GroupCount - 1 do if Groups[I].Owner = Root then Proc(Groups[I]); end; function TdxBarManager.GetChildOwner: TComponent; begin Result := Owner; end; function TdxBarManager.GetPainterClass: TdxBarPainterClass; begin case GetRealPaintStyle of bmsEnhanced: Result := TdxBarEnhancedPainter; bmsFlat: Result := TdxBarFlatPainter; bmsXP: Result := TdxBarXPPainter; bmsOffice11: Result := TdxBarOffice11Painter; else Result := TdxBarStandardPainter; end; end; function TdxBarManager.GetWindowForMouseCapturing: HWND; begin if FIsCustomizing and (dxBarCustomizingForm <> nil) then Result := dxBarCustomizingForm.Handle else if IsWindowVisible(Application.Handle) then Result := Application.Handle else Result := Owner.Handle;//#DG end; procedure TdxBarManager.SetChildOrder(Child: TComponent; Order: Integer); begin inherited; if Child is TdxBarItem then TdxBarItem(Child).Index := Order - Bars.Count; if Child is TdxBarGroup then TdxBarGroup(Child).Index := Order - Bars.Count - ItemCount; end; procedure TdxBarManager.ItemsChanged(Sender: TObject; AComponent: TComponent; AAction: TcxComponentCollectionNotification); begin if AAction = ccnChanged then DesignerModified; end; procedure TdxBarManager.CustomImagesChanged(AChangeProc: TdxBarItemChangeProc); var I: Integer; begin if not IsLoading and not IsDestroying then begin BeginUpdate; try for I := 0 to ItemCount - 1 do AChangeProc(Items[I]); finally EndUpdate; end; end; end; procedure TdxBarManager.DisabledImagesChanged(AItem: TdxBarItem); begin if AItem.ImageIndex > -1 then AItem.GlyphChanged; end; procedure TdxBarManager.DisabledLargeImagesChanged(AItem: TdxBarItem); begin if AItem.UseLargeImages then AItem.LargeGlyphChanged; end; procedure TdxBarManager.HotImagesChanged(AItem: TdxBarItem); begin if AItem.UseHotImages then AItem.HotGlyphChanged; end; procedure TdxBarManager.ImagesChanged(AItem: TdxBarItem); begin if AItem.ImageIndex > -1 then AItem.GlyphChanged; end; function TdxBarManager.IsLargeImagesForLargeIcons: Boolean; begin Result := FImageOptions.IsLargeImagesForLargeIcons; end; procedure TdxBarManager.LargeImagesChanged(AItem: TdxBarItem); begin if AItem.UseLargeImages then AItem.LargeGlyphChanged; end; procedure TdxBarManager.DisableFloatToolBars; var I: Integer; begin FDisabledToolBarsList := TList.Create; for I := 0 to Bars.Count - 1 do if Bars[I].IsFloat then DisableWindow(FDisabledToolBarsList, Bars[I].Control.Handle); end; procedure TdxBarManager.EnableFloatToolBars; begin EnableWindows(FDisabledToolBarsList); FreeAndNil(FDisabledToolBarsList); end; procedure TdxBarManager.ActivateFloatToolbars(AActivate, AForceHiding: Boolean; AActiveWindow: HWND); begin if AActivate <> FMainFormActive then begin FMainFormActive := AActivate; ShowToolbars(AActivate, AForceHiding, AActiveWindow); end; end; function TdxBarManager.IsInternalDockControl( ADockControl: TdxDockControl): Boolean; var ADockingStyle: TdxBarDockedDockingStyle; begin for ADockingStyle := Low(TdxBarDockedDockingStyle) to High(TdxBarDockedDockingStyle) do begin Result := ADockControl = InternalDockControls[ADockingStyle]; if Result then Break; end; end; function TdxBarManager.IsUpdateLocked: Boolean; begin Result := FLockUpdateCount > 0; end; procedure TdxBarManager.Loaded; var I: Integer; begin inherited Loaded; if IsUpdateLocked then Exit; Include(FInternalState, bisAfterLoading); try LoadLinkItemNames; Include(FInternalState, bisBarsLoading); try for I := 0 to ItemCount - 1 do with Items[I] do begin if Items[I] is TCustomdxBarSubItem then TCustomdxBarSubItem(Items[I]).ItemLinks.Loaded(True); Visible := FLoadedVisible; end; for I := 0 to FBars.Count - 1 do with FBars[I] do begin FIsPredefined := True; ItemLinks.Loaded(True); DockControl := FLoadedDockControl; if DockControl = nil then DockingStyle := FLoadedDockingStyle; Visible := FLoadedVisible; end; SaveState; if not Designing then begin if FStoreInRegistry then LoadFromRegistry(FRegistryPath); if FStoreInIniFile then LoadFromIniFile(FIniFileName); end; finally Exclude(FInternalState, bisBarsLoading); end; for I := 0 to FCategories.Count - 1 do if FCategories.Objects[I] <> nil then CategoryItemsVisible[I] := TdxBarCategoryData(FCategories.Objects[I]).LoadedItemsVisible; for I := 0 to DockControlCount - 1 do DockControls[I].UpdateDock; finally Exclude(FInternalState, bisAfterLoading); end; end; procedure TdxBarManager.LockDesignerModified(ALock: Boolean; AInvokeDesignerModifiedOnUnlock: Boolean = True); begin if ALock then begin if FLockDesignerModifiedCount = 0 then FDesignerModifiedInvoked := False; Inc(FLockDesignerModifiedCount); end else begin Dec(FLockDesignerModifiedCount); if (FLockDesignerModifiedCount = 0) and AInvokeDesignerModifiedOnUnlock and FDesignerModifiedInvoked then DesignerModified; end; end; procedure TdxBarManager.Notification(AComponent: TComponent; Operation: TOperation); var I: Integer; begin inherited; if Operation = opRemove then begin if AComponent is TControl then for I := 0 to FPopupMenuLinks.Count - 1 do if FPopupMenuLinks[I].Control = AComponent then FPopupMenuLinks[I].Control := nil; if AComponent is TdxBarPopupMenu then for I := 0 to FPopupMenuLinks.Count - 1 do if FPopupMenuLinks[I].PopupMenu = AComponent then FPopupMenuLinks[I].PopupMenu := nil; end; end; procedure TdxBarManager.ReadState(Reader: TReader); begin inherited; Inc(FReadStateCount); end; procedure TdxBarManager.SetName(const NewName: TComponentName); var I: Integer; OldName, ItemName, NamePrefix: TComponentName; Item: TdxBarItem; begin OldName := Name; inherited SetName(NewName); if Designing and (Name <> OldName) then for I := 0 to FItems.Count - 1 do begin Item := Items[I]; if Item.Owner = Owner then begin ItemName := Item.Name; NamePrefix := ItemName; if Length(NamePrefix) > Length(OldName) then begin SetLength(NamePrefix, Length(OldName)); if CompareText(OldName, NamePrefix) = 0 then begin System.Delete(ItemName, 1, Length(OldName)); System.Insert(NewName, ItemName, 1); try Item.Name := ItemName; except on EComponentError do end; end; end; end; end; end; procedure TdxBarManager.ShowToolbars(Show, ForceHiding: Boolean; ActiveWindow: HWND); function CanHideToolbars: Boolean; begin Result := HideFloatingBarsWhenInactive or ForceHiding; end; procedure InvalidateBarsCaptions; var I: Integer; begin for I := 0 to Bars.Count - 1 do if Bars[I].IsFloat then Bars[I].Control.FrameChanged; end; var I: Integer; begin if bisToolbarsVisibleChanging in FInternalState then Exit; Include(FInternalState, bisToolbarsVisibleChanging); try if not CanHideToolbars then InvalidateBarsCaptions; if not Show then begin if GetParent(ActiveWindow) = GetMainForm.Handle then Exit; if (ActiveBarControl <> nil) and ActiveBarControl.CanDeactivate(Self, ActiveWindow) then //#DG rollback to 302-nd version //#DG while (ActiveBarControl <> nil) and ActiveBarControl.CanDeactivate(Self, ActiveWindow) do ActiveBarControl.HideAll; BarNavigationController.StopKeyboardHandling; if not CanHideToolbars then begin if BarDesignController.QuickControl <> nil then BarDesignController.QuickControl.CloseUp; Exit; end; if (ActiveWindow = 0) or (FindControl(ActiveWindow) is TCustomForm) and ((dxBarCustomizingForm = nil) or (ActiveWindow <> dxBarCustomizingForm.Handle) or not FIsCustomizing) or IsAnotherApplicatonWindow(ActiveWindow) or (ActiveWindow = Application.Handle) then begin for I := 0 to Bars.Count - 1 do if Bars[I].IsFloat and Bars[I].Control.CanHide then Bars[I].Control.Hide; SendMessage(ParentForm.Handle, WM_NCACTIVATE, 0, 0); end; end else if IsOwnerVisible then for I := 0 to Bars.Count - 1 do if Bars[I].IsFloat and Bars[I].Visible then Bars[I].Control.Show; finally Exclude(FInternalState, bisToolbarsVisibleChanging); end; end; function TdxBarManager.IsOwnerVisible: Boolean; var AWnd: HWND; begin Result := Owner.HandleAllocated and IsWindowVisible(Owner.Handle); if Result then begin AWnd := Owner.Handle; while not IsIconic(AWnd) and IsChildClassWindow(AWnd) do AWnd := GetParent(AWnd); Result := not IsIconic(AWnd); end; end; function TdxBarManager.IsUncustomizable: Boolean; var ACustomizingBarManager: TdxBarManager; begin ACustomizingBarManager := dxBarManagerList.GetCustomizingBarManager; Result := (ACustomizingBarManager <> nil) and (Self <> ACustomizingBarManager); end; function TdxBarManager.CanAddComponents: Boolean; begin Result := Owner.ComponentState * [csDesigning, csInline] <> [csDesigning, csInline]; end; function TdxBarManager.GetLightColor(ABtnFaceColorPart, AHighlightColorPart, AWindowColorPart: Integer): COLORREF; begin Result := dxOffice11.GetLightColor(ABtnFaceColorPart, AHighlightColorPart, AWindowColorPart); end; function TdxBarManager.BarByCaption(const ACaption: string): TdxBar; var I: Integer; begin for I := 0 to FBars.Count - 1 do begin Result := FBars[I]; if Result.Caption = ACaption then Exit; end; Result := nil; end; function TdxBarManager.BarByComponentName(const AName: string): TdxBar; var I: Integer; begin Result := nil; for I := 0 to Bars.Count - 1 do if Bars[I].Name = AName then begin Result := Bars[I]; Break; end; end; function TdxBarManager.BarByOldName(const AName: string): TdxBar; var I: Integer; begin Result := nil; for I := 0 to Bars.Count - 1 do if Bars[I].OldName = AName then begin Result := Bars[I]; Break; end; end; //function TdxBarManager.CheckBarName(const AName: string): string; //begin // if BarByNewName(AName) = nil then // Result := AName // else // Result := GetUniqueToolbarName(AName); //end; function TdxBarManager.GetUniqueToolbarCaption(const ABaseName: string): string; var I: Integer; begin I := 0; repeat Inc(I); Result := ABaseName + IntToStr(I); until BarByCaption(Result) = nil; end; function TdxBarManager.GetUniqueToolbarName(const ABaseName: string): string; var I: Integer; begin if not IsLoading and Designing then Result := UniqueName(ABaseName) else begin I := 0; repeat Inc(I); Result := ABaseName + IntToStr(I); until BarByNewName(Result) = nil; end; end; function TdxBarManager.GetAllItemsByCategory(ACategory: Integer; List: TList): Integer; var I: Integer; begin List.Clear; if (0 <= ACategory) and (ACategory < Categories.Count) then for I := 0 to ItemCount - 1 do if Items[I].Category = ACategory then List.Add(Items[I]); Result := List.Count; end; function TdxBarManager.GetCountByCategory(ACategory: Integer): Integer; var I: Integer; begin Result := 0; if (0 <= ACategory) and (ACategory < Categories.Count) then for I := 0 to ItemCount - 1 do with Items[I] do if (Category = ACategory) and (Designing or ActuallyVisible and not Hidden) then Inc(Result); end; function TdxBarManager.GetItemByCategory(ACategory, AIndex: Integer): TdxBarItem; var AList: TList; begin Result := nil; AList := TList.Create; try GetItemsByCategory(ACategory, AList); if (0 <= AIndex) and (AIndex < AList.Count) then Result := TdxBarItem(AList[AIndex]); finally AList.Free; end; end; function TdxBarManager.GetItemByName(const AName: string): TdxBarItem; var I: Integer; begin Result := nil; for I := 0 to ItemCount - 1 do if CompareText(Items[I].Name, AName) = 0 then begin Result := Items[I]; Break; end; end; function TdxBarManager.GetItemsByCategory(ACategory: Integer; List: TList): Integer; var I: Integer; begin if Designing then Result := GetAllItemsByCategory(ACategory, List) else begin List.Clear; if (0 <= ACategory) and (ACategory < Categories.Count) then for I := 0 to ItemCount - 1 do with Items[I] do if (Category = ACategory) and ActuallyVisible and not Hidden then List.Add(Items[I]); Result := List.Count; end; end; function TdxBarManager.GetUniqueItemName(ABarItemClass: TdxBarItemClass): string; var S, S1: string; I, J: Integer; AFound: Boolean; begin S := ABarItemClass.ClassName; Delete(S, 1, 1); if Designing then Result := UniqueName(S) else begin J := 0; repeat Inc(J); S1 := S + IntToStr(J); AFound := False; for I := 0 to ItemCount - 1 do if CompareText(S1, Items[I].Name) = 0 then begin AFound := True; Break; end; until not AFound; Result := S1; end; end; function TdxBarManager.AddButton: TdxBarButton; begin Result := TdxBarButton(AddItem(TdxBarButton)); end; function TdxBarManager.AddItem(AClass: TdxBarItemClass): TdxBarItem; var ACategoryIndex: Integer; begin Result := AClass.Create(Self); ACategoryIndex := Categories.IndexOf(dxSBAR_DEFAULTCATEGORYNAME); if ACategoryIndex = -1 then ACategoryIndex := 0; Result.Category := ACategoryIndex; end; function TdxBarManager.AddSubItem: TdxBarSubItem; begin Result := TdxBarSubItem(AddItem(TdxBarSubItem)); end; function TdxBarManager.AddToolBar(AIsMainMenu: Boolean = False; ANeedEditCaption: Boolean = False): TdxBar; var AWorkArea: TRect; ACaption: string; begin Result := nil; ACaption := GetUniqueToolbarCaption(cxGetResourceString(@dxSBAR_TOOLBARNEWNAME)); if ANeedEditCaption and not dxBarEditName(ACaption, 0, 0, Self, nil) then Exit; BeginUpdate; try Bars.BeginUpdate; // TODO FIX!!! try Result := Bars.Add; Result.Caption := ACaption; AWorkArea := GetWorkArea(Point(Owner.Left, Owner.Top)); Result.FloatLeft := Owner.Left - 50; if Result.FloatLeft < AWorkArea.Left then Result.FloatLeft := Owner.Left + Owner.Width + 10; Result.FloatTop := Owner.Top; if Result.FloatTop < AWorkArea.Top then Result.FloatTop := AWorkArea.Top + 10; Result.DockingStyle := dsTop; if AIsMainMenu then begin Result.Row := 0; Result.IsMainMenu := True; Result.Visible := True; end else begin Result.Row := Result.RealDockControl.RowCount; Result.OneOnRow := True; Result.Visible := True; Result.OneOnRow := False; end; BarDesignController.SelectItem(Result); finally Bars.EndUpdate; end; finally EndUpdate; end; end; procedure TdxBarManager.DeleteToolBar(ABar: TdxBar; AConfirmation: Boolean); begin if ABar = nil then Exit; if not AConfirmation or (dxBarMessageBox(Format(cxGetResourceString(@dxSBAR_WANTTODELETETOOLBAR), [ABar.Caption]), MB_ICONEXCLAMATION or MB_OKCANCEL) = ID_OK) then ABar.Free; end; procedure TdxBarManager.ExchangeItems(Index1, Index2: Integer); begin FItems.Exchange(Index1, Index2); DesignerModified; end; {procedure TdxBarManager.FocusItem(AItem: TdxBarItem); var AdxBarItemLink : TdxBarItemLink; begin AdxBarItemLink := AItem.GetCurItemLink; if AdxBarItemLink = nil then AdxBarItemLink := AItem.GetLinks(0); if (AdxBarItemLink <> nil) then begin if AdxBarItemLink.BarControl = nil then TdxBarSubItem(TdxBarItemLinks(AdxBarItemLink.owner).owner).DropDown; if AdxBarItemLink.FControl <> nil then begin TdxBarWinControl(AdxBarItemLink.FControl).SetFocused(True); AdxBarItemLink.GetBarControl.SetSelectedItem(AdxBarItemLink.FControl); end; end; end;} procedure TdxBarManager.MoveItem(CurIndex, NewIndex: Integer); begin FItems.Move(CurIndex, NewIndex); DesignerModified; end; procedure TdxBarManager.RenameToolBar(ABar: TdxBar); var ACaption: string; begin if ABar = nil then Exit; ACaption := ABar.Caption; if dxBarEditName(ACaption, 0, 1, Self, ABar) then ABar.Caption := ACaption; end; procedure TdxBarManager.ResetToolBar(ABar: TdxBar); begin if ABar <> nil then ABar.ResetWithConfirmation; end; procedure TdxBarManager.Merge(ABarManager: TdxBarManager; ACanCreateNewBar: Boolean = True); var ABar, ANewBar: TdxBar; I: Integer; begin if (ABarManager = nil) or (ABarManager = Self) then raise Exception.Create(cxGetResourceString(@dxSBAR_CANTMERGEBARMANAGER)); for I := 0 to ABarManager.Bars.Count - 1 do begin ABar := ABarManager.Bars[I]; if ABar.MergeData.MergedWith <> nil then raise Exception.Create(cxGetResourceString(@dxSBAR_ONEOFTOOLBARSALREADYMERGED)); if ABar.MergeData.MergedBarList.Count <> 0 then raise Exception.Create(cxGetResourceString(@dxSBAR_ONEOFTOOLBARSHASMERGEDTOOLBARS)); end; for I := 0 to ABarManager.Bars.Count - 1 do begin ABar := ABarManager.Bars[I]; if ABar.Visible and (BarByCaption(ABar.Caption) <> nil) then BarByCaption(ABar.Caption).Merge(ABar); end; if ACanCreateNewBar then for I := 0 to ABarManager.Bars.Count - 1 do begin ABar := ABarManager.Bars[I]; if ABar.Visible and (ABar.MergeData.MergedWith = nil) then begin ANewBar := CreateBarAsByMerging; ANewBar.Caption := ABar.Caption; ANewBar.Merge(ABar); ANewBar.Visible := True; end; end; end; procedure TdxBarManager.Unmerge(ABarManager: TdxBarManager = nil); begin InternalUnmerge(ABarManager, False); end; procedure TdxBarManager.Customizing(Show: Boolean); var APrevBarCount, I: Integer; begin if (FIsCustomizing <> Show) and (not Show or (dxBarCustomizingForm = nil)) then begin // BeginUpdate; //#DG flickers try for I := Bars.Count - 1 downto 0 do if Bars[I].Control <> nil then with Bars[I].Control do begin APrevBarCount := Self.Bars.Count; HideAll; if APrevBarCount = Self.Bars.Count then // HideAll can destroy Bar DestroyControls; end; FIsCustomizing := Show; for I := 0 to Bars.Count - 1 do with Bars[I] do begin ItemLinks.RefreshVisibilityLists; if Control <> nil then Control.CreateControls; end; for I := 0 to ItemCount - 1 do if Items[I] is TCustomdxBarSubItem then TCustomdxBarSubItem(Items[I]).ItemLinks.RefreshVisibilityLists; for I := 0 to FPopupMenus.Count - 1 do TdxBarPopupMenu(FPopupMenus[I]).ItemLinks.RefreshVisibilityLists; finally // EndUpdate(False); end; dxBarCustomizing(Self, Show); for I := 0 to Bars.Count - 1 do with Bars[I] do if Control <> nil then with Control do begin UpdateControlState; RepaintBar; end; end; end; procedure TdxBarManager.HideAll; begin if (ActiveBarControl <> nil) {and (ActiveBarControl.BarManager = Self) }then ActiveBarControl.HideAll; end; procedure TdxBarManager.ResetUsageData; var ABarIndex: Integer; I: Integer; begin BeginUpdate; try for I := 0 to ItemCount - 1 do Items[I].LoadUsageData(SavedState, GetBaseIniSection); for I := 0 to Bars.Count - 1 do begin ABarIndex := GetSavedBarIndex(Bars[I].Caption); if ABarIndex <> -1 then Bars[I].LoadUsageData(SavedState, GetBaseIniSection, ABarIndex); end; finally EndUpdate; end; end; procedure TdxBarManager.ResetUsageDataWithConfirmation; begin if dxBarMessageBox(cxGetResourceString(@dxSBAR_WANTTORESETUSAGEDATA), MB_YESNO or MB_DEFBUTTON2 or MB_ICONEXCLAMATION) = ID_YES then ResetUsageData; end; function GetComponentPath(ABarManagerOwner, AComponent: TComponent): string; begin Result := AComponent.Name; if (Result <> '') and (AComponent.Owner <> ABarManagerOwner) then while (AComponent.Owner <> nil) and (AComponent.Owner.Name <> '') do begin AComponent := AComponent.Owner; Result := AComponent.Name + '.' + Result; end; end; function TdxBarManager.GetBarManagerSection(const ABaseSection: string; AStoringKind: TdxBarStoringKind): string; begin Result := ABaseSection; if AStoringKind = skIni then Result := Result + 'Main'; end; function TdxBarManager.GetBaseIniSection: string; var AOwner: TComponent; begin Result := Name + GetSectionDelimiter(skIni); AOwner := Owner; while (AOwner <> nil) and (AOwner.Name <> '') do begin Result := AOwner.Name + GetSectionDelimiter(skIni) + Result; AOwner := AOwner.Owner; end; end; procedure TdxBarManager.LoadBarManager(ASource: TCustomIniFile; const ASection: string; AStoringKind: TdxBarStoringKind); var ABarCount, AItemCount, I: Integer; ACurrentSection: string; begin ACurrentSection := GetBarManagerSection(ASection, AStoringKind); BeginUpdate; try if CanShowRecentItems then begin MenusShowRecentItemsFirst := ASource.ReadBool(ACurrentSection, 'MenusShowRecentItemsFirst', MenusShowRecentItemsFirst); ShowFullMenusAfterDelay := ASource.ReadBool(ACurrentSection, 'ShowFullMenusAfterDelay', ShowFullMenusAfterDelay); end; LargeIcons := ASource.ReadBool(ACurrentSection, 'LargeIcons', LargeIcons); MenuAnimations := TdxBarMenuAnimations(ASource.ReadInteger(ACurrentSection, 'MenuAnimations', Byte(MenuAnimations))); ShowHint := ASource.ReadBool(ACurrentSection, 'ShowHint', ShowHint); ShowShortCutInHint := ASource.ReadBool(ACurrentSection, 'ShowShortCutInHint', ShowShortCutInHint); ABarCount := ASource.ReadInteger(ACurrentSection, 'BarCount', 0); AItemCount := ASource.ReadInteger(ASection + 'Items', 'ItemCount', -1); if AItemCount > -1 then begin FNewItems := TStringList.Create; for I := 0 to ItemCount - 1 do if not ASource.ReadBool(ASection + 'Items', Items[I].Name, False) then FNewItems.Add(Items[I].Name); end; if ABarCount > 0 then begin for I := 0 to Bars.Count - 1 do begin Bars[I].Visible := False; Bars[I].DockRow := nil; end; for I := 0 to ABarCount - 1 do begin if I >= Bars.Count then Bars.Add; Bars[I].LoadFromIni(ASource, ASection, I, AStoringKind); end; end; for I := 0 to ItemCount - 1 do Items[I].LoadFromIni(ASource, ASection, AStoringKind); if AItemCount > -1 then FreeAndNil(FNewItems); IniFileCollectionCallMethods(ReadIniFileHandlers, ASource, AStoringKind, ASection); finally EndUpdate; end; end; procedure TdxBarManager.SaveBarManager(ADestination: TCustomIniFile; const ASection: string; AStoringKind: TdxBarStoringKind); procedure ClearOldData(ADestination: TCustomIniFile; const ASection: string); var AKeys: TStringList; I: Integer; begin AKeys := TStringList.Create; try ADestination.ReadSections(AKeys); for I := 0 to AKeys.Count - 1 do if Copy(AKeys[I], 1, Length(ASection)) = ASection then ADestination.EraseSection(AKeys[I]); finally AKeys.Free; end; if AStoringKind = skReg then ADestination.EraseSection(ASection); end; function GetBarCount: Integer; var I: Integer; begin Result := 0; for I := 0 to Bars.Count - 1 do if not Bars[I].MergeData.CreatedByMerging then Inc(Result); end; var ACurrentSection: string; I: Integer; begin ClearOldData(ADestination, ASection); ACurrentSection := GetBarManagerSection(ASection, AStoringKind); if CanShowRecentItems then begin ADestination.WriteBool(ACurrentSection, 'MenusShowRecentItemsFirst', MenusShowRecentItemsFirst); ADestination.WriteBool(ACurrentSection, 'ShowFullMenusAfterDelay', ShowFullMenusAfterDelay); end; ADestination.WriteBool(ACurrentSection, 'LargeIcons', LargeIcons); ADestination.WriteInteger(ACurrentSection, 'MenuAnimations', Ord(MenuAnimations)); ADestination.WriteBool(ACurrentSection, 'ShowHint', ShowHint); ADestination.WriteBool(ACurrentSection, 'ShowShortCutInHint', ShowShortCutInHint); ADestination.WriteInteger(ACurrentSection, 'BarCount', GetBarCount); ADestination.WriteInteger(ASection + 'Items', 'ItemCount', ItemCount); for I := 0 to ItemCount - 1 do ADestination.WriteBool(ASection + 'Items', Items[I].Name, True); for I := 0 to Bars.Count - 1 do if not Bars[I].MergeData.CreatedByMerging then Bars[I].SaveToIni(ADestination, ASection, I, AStoringKind); for I := 0 to ItemCount - 1 do Items[I].SaveToIni(ADestination, ASection, AStoringKind); IniFileCollectionCallMethods(WriteIniFileHandlers, ADestination, AStoringKind, ASection); end; function TdxBarManager.CreateBarAsByMerging: TdxBar; begin Result := Bars.Add; Result.MergeData.CreatedByMerging := True; Result.Move(dsTop, DockControls[Integer(dsTop) - 1].RowCount, 0); end; procedure TdxBarManager.InternalUnmerge(ABarManager: TdxBarManager; AForCustomization: Boolean); var ABar: TdxBar; ABarList: TList; I: Integer; begin ABarList := nil; try if AForCustomization then begin ABarManager := nil; ABarList := TList.Create; for I := 0 to Bars.Count - 1 do if (Bars[I].MergeData.MergedWith <> nil) and (Bars[I].MergeData.MergedWith.BarManager = Self) then ABarList.Add(Bars[I]); end; for I := Bars.Count - 1 downto 0 do begin if AForCustomization then begin Bars[I].SaveMergeState; if Bars[I].MergeData.CreatedByMerging then Bars[I].OnDestroy := BarDestroyHandler; end; Bars[I].InternalUnmergeFromBarManager(ABarManager, not AForCustomization); end; if AForCustomization then for I := 0 to ABarList.Count - 1 do begin ABar := TdxBar(ABarList[I]); ABar.SetVisibility(ABar.MergeData.PrevVisible); end; finally FreeAndNil(ABarList); end; end; procedure TdxBarManager.RestoreMergeState; var ABarMergeData: TdxBarMergeData; ANewBar: TdxBar; I: Integer; begin for I := 0 to Bars.Count - 1 do Bars[I].RestoreMergeState; while FCreatedByMergingBarMergeDataList.Count > 0 do begin ABarMergeData := TdxBarMergeData(FCreatedByMergingBarMergeDataList[0]); if ABarMergeData.SavedMergedBarCount > 0 then begin ANewBar := CreateBarAsByMerging; ANewBar.MergeData.Assign(ABarMergeData); ANewBar.Caption := TdxBar(ABarMergeData.SavedMergedBars[0]).Caption; ANewBar.RestoreMergeState; end; FreeAndNil(ABarMergeData); FCreatedByMergingBarMergeDataList.Delete(0); end; end; procedure TdxBarManager.GetActiveSelection(AList: TList); var I: Integer; begin GetSelection(AList); for I := AList.Count - 1 downto 0 do if GetSelectionStatus(TPersistent(AList[I])) <> ssActiveSelected then AList.Delete(I); end; procedure TdxBarManager.BeginMouseTracking(ABarControl: TCustomdxBarControl); var ABounds: TRect; begin if FMouseTrackingBarControl <> ABarControl then begin if FMouseTrackingBarControl <> nil then FMouseTrackingBarControl.MouseLeave; FMouseTrackingBarControl := ABarControl; ABounds := ABarControl.BoundsRect; if ABarControl.DockControl <> nil then begin IntersectRect(ABounds, ABarControl.DockControl.ClientRect, ABounds); ABounds := cxRectOffset(ABounds, ABarControl.DockControl.ClientOrigin); end; cxControls.BeginMouseTracking(nil, ABounds, ABarControl); end; end; procedure TdxBarManager.EndMouseTracking(ABarControl: TCustomdxBarControl); begin if IsMouseTracking(ABarControl) then FMouseTrackingBarControl := nil; cxControls.EndMouseTracking(ABarControl); end; function TdxBarManager.IsMouseTracking(ABarControl: TCustomdxBarControl): Boolean; begin Result := ABarControl = FMouseTrackingBarControl; end; procedure TdxBarManager.LoadFromRegistry(ARegistryPath: string); var Registry: TRegistryIniFile; begin if not CorrectRegistryPath(ARegistryPath) then Exit; Registry := TRegistryIniFile.Create(ARegistryPath); try LoadBarManager(Registry, ARegistryPath, skReg); finally Registry.Free; end; end; procedure TdxBarManager.SaveToRegistry(ARegistryPath: string); var Registry: TRegistryIniFile; begin if not CorrectRegistryPath(ARegistryPath) then Exit; Registry := TRegistryIniFile.Create(ARegistryPath); try SaveBarManager(Registry, ARegistryPath, skReg); finally Registry.Free; end; end; procedure TdxBarManager.LoadFromIniFile(const AFileName: string); var AIniFile: TMemIniFile; ATempList: TStringList; begin if (AFileName = '') and (FIniFileStream = nil) then Exit; AIniFile := TMemIniFile.Create(AFileName); try if FIniFileStream <> nil then begin ATempList := TStringList.Create; try ATempList.LoadFromStream(FIniFileStream); AIniFile.SetStrings(ATempList); finally ATempList.Free; end; end; LoadBarManager(AIniFile, GetBaseIniSection, skIni); finally AIniFile.Free; end; end; procedure TdxBarManager.SaveToIniFile(const AFileName: string); var AIniFile: TMemIniFile; ATempList: TStringList; begin if (AFileName = '') and (FIniFileStream = nil) then Exit; AIniFile := TMemIniFile.Create(AFileName); try SaveBarManager(AIniFile, GetBaseIniSection, skIni); finally if FIniFileStream = nil then AIniFile.UpdateFile else begin ATempList := TStringList.Create; try AIniFile.GetStrings(ATempList); ATempList.SaveToStream(FIniFileStream); finally ATempList.Free; end; end; AIniFile.Free; end; end; procedure TdxBarManager.LoadFromStream(AStream: TStream); begin FIniFileStream := AStream; try LoadFromIniFile(''); finally FIniFileStream := nil; end; end; procedure TdxBarManager.SaveToStream(AStream: TStream); begin FIniFileStream := AStream; try SaveToIniFile(''); finally FIniFileStream := nil; end; end; function TdxBarManager.CreateGroup: TdxBarGroup; begin Result := TdxBarGroup.Create(Owner);//#DG AddGroup(Result); end; function TdxBarManager.CanShowRecentItems: Boolean; begin Result := GetPaintStyle <> bmsStandard; end; function TdxBarManager.GetPaintStyle: TdxBarManagerStyle; const AStyles: array[TcxLookAndFeelKind] of TdxBarManagerStyle = ( bmsEnhanced, bmsStandard, bmsFlat{$IFDEF DXVER500}, bmsOffice11{$ENDIF}); begin if Style = bmsUseLookAndFeel then begin if LookAndFeel.NativeStyle and FThemeAvailable then Result := bmsXP else Result := AStyles[LookAndFeel.Kind]; end else Result := Style; end; function TdxBarManager.GetRealPaintStyle: TdxBarManagerStyle; begin Result := GetPaintStyle; if (Result = bmsXP) and not FThemeAvailable then Result := bmsEnhanced; end; { TdxBarManagerList } destructor TdxBarManagerList.Destroy; begin FinalizationBars; inherited Destroy; end; function TdxBarManagerList.GetBarManager(Index: Integer): TdxBarManager; begin Result := TdxBarManager(inherited GetItem(Index)); end; function TdxBarManagerList.GetCustomizingBarManager: TdxBarManager; var I: Integer; begin Result := nil; for I := 0 to Count - 1 do if BarManagers[I].FIsCustomizing then begin Result := BarManagers[I]; Break; end; end; function TdxBarManagerList.NextActive(ABarManager: TdxBarManager; AGoForward: Boolean): TdxBarManager; function IsBarManagerValid(ABarManager: TdxBarManager; AMainForm: TCustomForm): Boolean; var AForm: TCustomForm; begin Result := IsBarManagerOwner(ABarManager, AMainForm.Handle); if Result then begin AForm := GetBarManagerForm(ABarManager, fkMainOrMDIChild); Result := not IsMDIChild(AForm) or (AForm.Handle = ABarManager.ActiveMDIChild); end; end; var AMainForm: TCustomForm; AIndex, AStartIndex: Integer; begin AMainForm := ABarManager.GetMainForm; AStartIndex := IndexOf(ABarManager); AIndex := AStartIndex; repeat if AGoForward then begin Inc(AIndex); if AIndex = Count then AIndex := 0; end else begin Dec(AIndex); if AIndex < 0 then AIndex := Count - 1; end until (AIndex = AStartIndex) or IsBarManagerValid(BarManagers[AIndex], AMainForm); Result := BarManagers[AIndex]; end; { TdxBarMergeData } constructor TdxBarMergeData.Create; begin inherited Create; FFreeNotificator := TcxFreeNotificator.Create(nil); FFreeNotificator.OnFreeNotification := FreeNotification; FMergedBarList := TList.Create; FSavedMergedBarList := TList.Create; end; destructor TdxBarMergeData.Destroy; begin ClearSavedMergedBarList; FreeAndNil(FSavedMergedBarList); FreeAndNil(FMergedBarList); FreeAndNil(FFreeNotificator); inherited Destroy; end; procedure TdxBarMergeData.Assign(ASource: TdxBarMergeData); procedure AssignList(AList1, AList2: TList); var I: Integer; begin AList1.Clear; for I := 0 to AList2.Count - 1 do AList1.Add(AList2[I]); end; begin CreatedByMerging := ASource.CreatedByMerging; MergedWith := ASource.MergedWith; PrevVisible := ASource.PrevVisible; AssignList(MergedBarList, ASource.MergedBarList); AssignList(FSavedMergedBarList, ASource.FSavedMergedBarList); SetFreeNotifications; end; procedure TdxBarMergeData.ClearSavedMergedBarList; var I: Integer; begin for I := 0 to SavedMergedBarCount - 1 do FreeNotificator.RemoveSender(FSavedMergedBarList[I]); FSavedMergedBarList.Clear; end; procedure TdxBarMergeData.SaveMergedBarList(AList: TList = nil); var I: Integer; begin if AList = nil then AList := FSavedMergedBarList; for I := 0 to MergedBarList.Count - 1 do AList.Add(MergedBarList[I]); if AList = FSavedMergedBarList then SetFreeNotifications; end; procedure TdxBarMergeData.FreeNotification(Sender: TComponent); begin FSavedMergedBarList.Remove(Sender); end; function TdxBarMergeData.GetSavedMergedBar(AIndex: Integer): TdxBar; begin Result := TdxBar(FSavedMergedBarList[AIndex]); end; function TdxBarMergeData.GetSavedMergedBarListCount: Integer; begin Result := FSavedMergedBarList.Count; end; procedure TdxBarMergeData.SetFreeNotifications; var I: Integer; begin for I := 0 to SavedMergedBarCount - 1 do FreeNotificator.AddSender(TComponent(FSavedMergedBarList[I])); end; { TdxBarAccessibilityHelper } function TdxBarAccessibilityHelper.GetFirstSelectableObject: TdxBarAccessibilityHelper; var I: Integer; begin Result := nil; if Visible then if Selectable then Result := Self else for I := 0 to ChildCount - 1 do begin Result := Childs[I].GetFirstSelectableObject; if Result <> nil then Break; end; end; // IcxAccessibilityHelper procedure TdxBarAccessibilityHelper.OwnerObjectDestroyed; begin inherited OwnerObjectDestroyed; if BarNavigationController <> nil then BarNavigationController.UnassignObject(Self); end; // IdxBarAccessibilityHelper function TdxBarAccessibilityHelper.AreKeyTipsSupported( out AKeyTipWindowsManager: IdxBarKeyTipWindowsManager): Boolean; begin if ParentForKeyTip <> nil then Result := ParentForKeyTip.AreKeyTipsSupported(AKeyTipWindowsManager) else Result := False; end; function TdxBarAccessibilityHelper.CanNavigateToChildren(AKey: Word): Boolean; begin Result := True; end; function TdxBarAccessibilityHelper.GetBarHelper: TdxBarAccessibilityHelper; begin Result := Self; end; function TdxBarAccessibilityHelper.GetBarManager: TdxBarManager; begin raise Exception.Create(''); end; function TdxBarAccessibilityHelper.GetDefaultAccessibleObject: IdxBarAccessibilityHelper; begin raise Exception.Create(''); end; function TdxBarAccessibilityHelper.GetNextAccessibleObject( ADirection: TcxAccessibilityNavigationDirection): IdxBarAccessibilityHelper; var AObjects: TList; begin AObjects := TList.Create; try GetChildrenForNavigation(Self, GetRootAccessibleObject.GetBarHelper, GetScreenBounds(cxAccessibleObjectSelfID), ADirection, True, AObjects); Result := dxBar.GetNextAccessibleObject( BarNavigationController.SelectedObject.GetBarHelper, AObjects, ADirection, True); finally AObjects.Free; end; end; function TdxBarAccessibilityHelper.GetRootAccessibleObject: IdxBarAccessibilityHelper; var AObject: TdxBarAccessibilityHelper; begin AObject := Self; while AObject.Parent <> nil do AObject := AObject.Parent; Result := AObject; end; function TdxBarAccessibilityHelper.HandleNavigationKey(var AKey: Word): Boolean; begin Result := False; end; function TdxBarAccessibilityHelper.IsNavigationKey(AKey: Word): Boolean; begin Result := False; end; function TdxBarAccessibilityHelper.IsSelected: Boolean; var ASelectedObject: IdxBarAccessibilityHelper; begin ASelectedObject := BarNavigationController.SelectedObject; Result := (ASelectedObject <> nil) and (ASelectedObject.GetHelper = Self); end; function TdxBarAccessibilityHelper.LogicalNavigationGetNextAccessibleObject( AGoForward: Boolean): IdxBarAccessibilityHelper; begin Result := Parent.LogicalNavigationGetNextChild(Parent.LogicalNavigationGetChildIndex(Self), AGoForward); end; procedure TdxBarAccessibilityHelper.Select(ASetFocus: Boolean); begin BarNavigationController.SelectedObject := Self; BarNavigationController.SelectedObjectParent := Parent; end; procedure TdxBarAccessibilityHelper.Unselect( ANextSelectedObject: IdxBarAccessibilityHelper); begin BarNavigationController.SelectedObject := nil; BarNavigationController.SelectedObjectParent := nil; end; procedure TdxBarAccessibilityHelper.GetChildrenForNavigation( ASelectedObject, AParentObject: TdxBarAccessibilityHelper; const ASelectedObjectScreenBounds: TRect; ADirection: TcxAccessibilityNavigationDirection; AAreOnlyNearObjectsAccepted: Boolean; AObjects: TList); function CheckObject(AObject: TdxBarAccessibilityHelper): Boolean; var R: TRect; begin Result := AObject.Selectable; if not Result then Exit; R := AObject.GetScreenBounds(cxAccessibleObjectSelfID); if AAreOnlyNearObjectsAccepted then if ADirection in [andLeft, andRight] then Result := (R.Bottom > ASelectedObjectScreenBounds.Top) and (R.Top < ASelectedObjectScreenBounds.Bottom) else Result := (R.Right > ASelectedObjectScreenBounds.Left) and (R.Left < ASelectedObjectScreenBounds.Right); if Result then case ADirection of andLeft, andRight: Result := not ((R.Left = ASelectedObjectScreenBounds.Left) and (R.Right = ASelectedObjectScreenBounds.Right)); andUp: Result := R.Bottom <= ASelectedObjectScreenBounds.Top; andDown: Result := R.Top >= ASelectedObjectScreenBounds.Bottom; end; end; var I: Integer; begin if (AParentObject <> ASelectedObject) and AParentObject.Visible then begin if CheckObject(AParentObject) then AObjects.Add(AParentObject); for I := 0 to AParentObject.ChildCount - 1 do GetChildrenForNavigation(ASelectedObject, AParentObject.Childs[I], ASelectedObjectScreenBounds, ADirection, AAreOnlyNearObjectsAccepted, AObjects) end; end; procedure TdxBarAccessibilityHelper.GetChilds(AChilds: TList; AOnlyVisible: Boolean); var AChild: TdxBarAccessibilityHelper; I: Integer; begin if not AOnlyVisible or Visible then for I := 0 to ChildCount - 1 do begin AChild := Childs[I]; if AChild.Selectable then AChilds.Add(AChild) else AChild.GetChilds(AChilds); end; end; function TdxBarAccessibilityHelper.GetKeyTip: string; begin if GetAssignedKeyTip <> '' then Result := GetAssignedKeyTip else Result := GetDefaultKeyTip; if Length(Result) > 3 then SetLength(Result, 3); end; function TdxBarAccessibilityHelper.CreateKeyTipData: TdxBarKeyTipData; var AKeyTipInfo: TdxBarKeyTipInfo; begin GetKeyTipInfo(AKeyTipInfo); Result := TdxBarKeyTipData.Create(AKeyTipInfo); end; procedure TdxBarAccessibilityHelper.GetKeyTipInfo(out AKeyTipInfo: TdxBarKeyTipInfo); begin cxZeroMemory(@AKeyTipInfo, SizeOf(AKeyTipInfo)); AKeyTipInfo.KeyTip := GetKeyTip; AKeyTipInfo.Visible := Visible; AKeyTipInfo.OnExecute := KeyTipHandler; end; procedure TdxBarAccessibilityHelper.GetKeyTipData(AKeyTipsData: TList); begin AKeyTipsData.Add(CreateKeyTipData); end; procedure TdxBarAccessibilityHelper.DoGetKeyTipsData(AKeyTipsData: TList); var AChild: TdxBarAccessibilityHelper; I: Integer; begin if Visible then for I := 0 to ChildCount - 1 do begin AChild := Childs[I]; if AChild.Selectable then AChild.GetKeyTipData(AKeyTipsData) else AChild.DoGetKeyTipsData(AKeyTipsData); end; end; procedure TdxBarAccessibilityHelper.GetKeyTipsData(AKeyTipsData: TList); begin DoGetKeyTipsData(AKeyTipsData); GenerateUniqueKeyTips(AKeyTipsData); end; procedure TdxBarAccessibilityHelper.GenerateUniqueKeyTips(AKeyTipsData: TList); function GetKeyTip(AList: TList; AIndex: Integer): string; // TODO TdxBarKeyTipsDataList begin Result := TdxBarKeyTipData(AList[AIndex]).KeyTip; end; function RemoveCollision(AIndex: Integer): Boolean; function GetSuffix(ATotalCount, AIndex: Integer): string; var I: Integer; begin Result := IntToStr(AIndex + 1); for I := Length(Result) to Length(IntToStr(ATotalCount)) - 1 do Result := '0' + Result; end; procedure InternalRemoveCollision(ACollisions: TdxObjectList); var I: Integer; begin for I := 0 to ACollisions.Count - 1 do TdxBarKeyTipData(ACollisions[I]).KeyTip := GetKeyTip(ACollisions, I) + GetSuffix(ACollisions.Count, I); end; var ACollisions: TdxObjectList; I: Integer; begin ACollisions := TdxObjectList.Create; try for I := 0 to AKeyTipsData.Count - 1 do if GetKeyTip(AKeyTipsData, AIndex) = GetKeyTip(AKeyTipsData, I) then ACollisions.Add(AKeyTipsData[I]); Result := ACollisions.Count > 1; if Result then InternalRemoveCollision(ACollisions) else begin for I := 0 to AKeyTipsData.Count - 1 do if (I <> AIndex) and (Pos(GetKeyTip(AKeyTipsData, AIndex), GetKeyTip(AKeyTipsData, I)) = 1) then begin InternalRemoveCollision(ACollisions); Result := True; Break; end; end; finally ACollisions.Free; end; end; var I: Integer; AHasCollisions: Boolean; begin repeat AHasCollisions := False; for I := 0 to AKeyTipsData.Count - 1 do AHasCollisions := RemoveCollision(I) or AHasCollisions; until not AHasCollisions; end; function TdxBarAccessibilityHelper.GetParentForKeyTip: TdxBarAccessibilityHelper; begin Result := Parent; end; function TdxBarAccessibilityHelper.IsKeyTipContainer: Boolean; begin Result := Selectable; end; procedure TdxBarAccessibilityHelper.KeyTipHandler(Sender: TObject); begin end; procedure TdxBarAccessibilityHelper.KeyTipsEscapeHandler; var ANewKeyTipContainer: IdxBarAccessibilityHelper; begin ANewKeyTipContainer := GetKeyTipContainerParent(Self); if ANewKeyTipContainer = nil then BarNavigationController.StopKeyboardHandling else begin BarNavigationController.SetKeyTipsShowingState(ANewKeyTipContainer, ''); BarNavigationController.ChangeSelectedObject(True, Self); end; end; function TdxBarAccessibilityHelper.LogicalNavigationGetChild( AIndex: Integer): TdxBarAccessibilityHelper; begin Result := Childs[AIndex]; end; function TdxBarAccessibilityHelper.LogicalNavigationGetChildCount: Integer; begin Result := ChildCount; end; function TdxBarAccessibilityHelper.LogicalNavigationGetChildIndex( AChild: TdxBarAccessibilityHelper): Integer; begin Result := GetChildIndex(AChild); end; function TdxBarAccessibilityHelper.LogicalNavigationGetNextChild( AChildIndex: Integer; AGoForward: Boolean): TdxBarAccessibilityHelper; function LogicalNavigationGetFirstChild(AContainer: TdxBarAccessibilityHelper): TdxBarAccessibilityHelper; var AChild: TdxBarAccessibilityHelper; I: Integer; begin Result := nil; if AGoForward then I := 0 else I := AContainer.LogicalNavigationGetChildCount - 1; while (Result = nil) and (I >= 0) and (I < AContainer.LogicalNavigationGetChildCount) do begin AChild := AContainer.LogicalNavigationGetChild(I); if AChild.Selectable then Result := AChild else Result := LogicalNavigationGetFirstChild(AChild); if AGoForward then Inc(I) else Dec(I); end; end; var AChild: TdxBarAccessibilityHelper; begin Result := nil; while Result = nil do begin if AGoForward then Inc(AChildIndex) else Dec(AChildIndex); if (AChildIndex = -1) or (AChildIndex = LogicalNavigationGetChildCount) then begin if Parent = nil then Result := LogicalNavigationGetFirstChild(Self) else Result := Parent.LogicalNavigationGetNextChild( Parent.LogicalNavigationGetChildIndex(Self), AGoForward); Exit; end; AChild := LogicalNavigationGetChild(AChildIndex); if AChild.Selectable then Result := AChild else Result := LogicalNavigationGetFirstChild(AChild); end; end; function TdxBarAccessibilityHelper.InternalGetChild( AIndex: Integer): TdxBarAccessibilityHelper; begin Result := TdxBarAccessibilityHelper(GetChild(AIndex)); end; function TdxBarAccessibilityHelper.InternalGetParent: TdxBarAccessibilityHelper; begin Result := TdxBarAccessibilityHelper(GetParent); end; { TdxBarCaptionButton } constructor TdxBarCaptionButton.Create(Collection: TCollection); begin inherited; FGlyph := dxBarCreateBitmap(GlyphChanged); FNotifyComponent := TcxFreeNotificator.Create(nil); FNotifyComponent.OnFreeNotification := FreeNotification; Enabled := True; end; destructor TdxBarCaptionButton.Destroy; begin AccessibilityHelperOwnerObjectDestroyed(FIAccessibilityHelper); FreeAndNil(FNotifyComponent); FreeAndNil(FGlyph); inherited; end; procedure TdxBarCaptionButton.Assign(Source: TPersistent); begin if Source is TdxBarCaptionButton then begin Enabled := TdxBarCaptionButton(Source).Enabled; Glyph := TdxBarCaptionButton(Source).Glyph; Hint := TdxBarCaptionButton(Source).Hint; KeyTip := TdxBarCaptionButton(Source).KeyTip; Rect := TdxBarCaptionButton(Source).Rect; OnClick := TdxBarCaptionButton(Source).OnClick; end else inherited Assign(Source); end; procedure TdxBarCaptionButton.Click; begin CallNotify(OnClick, Self); end; function TdxBarCaptionButton.GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; begin Result := TdxBarCaptionButtonAccessibilityHelper; end; // IUnknown function TdxBarCaptionButton._AddRef: Integer; begin Result := -1; end; function TdxBarCaptionButton._Release: Integer; begin Result := -1; end; function TdxBarCaptionButton.QueryInterface(const IID: TGUID; out Obj): HResult; const E_NOINTERFACE = HResult($80004002); begin if GetInterface(IID, Obj) then Result := 0 else Result := E_NOINTERFACE; end; // IdxBarHintKeeper function TdxBarCaptionButton.DoHint(var ANeedDeactivate: Boolean; out AHintText: string; out AShortCut: string): Boolean; begin Result := False; ANeedDeactivate := False; AShortCut := ''; AHintText := ''; if State = DXBAR_HOT then begin AHintText := Hint; Result := True; end; end; function TdxBarCaptionButton.CreateHintViewInfo(const AHintText, AShortCut: string): TdxBarCustomHintViewInfo; begin Result := Parent.CreateHintViewInfo(AHintText, AShortCut, ScreenTip); end; function TdxBarCaptionButton.GetEnabled: Boolean; begin Result := State <> DXBAR_DISABLED; end; function TdxBarCaptionButton.GetHintPosition(const ACursorPos: TPoint; AHeight: Integer): TPoint; begin Result := Parent.GetHintPosition(Rect, ACursorPos, AHeight); end; function TdxBarCaptionButton.GetCollection: TdxBarCaptionButtons; begin Result := TdxBarCaptionButtons(inherited Collection); end; function TdxBarCaptionButton.GetIAccessibilityHelper: IdxBarAccessibilityHelper; begin if FIAccessibilityHelper = nil then FIAccessibilityHelper := GetAccessibilityHelper(GetAccessibilityHelperClass.Create(Self)); Result := FIAccessibilityHelper; end; function TdxBarCaptionButton.GetParent: TdxBarControl; begin Result := Collection.Bar.Control; end; procedure TdxBarCaptionButton.GlyphChanged(Sender: TObject); begin Changed(False); end; procedure TdxBarCaptionButton.SetEnabled(Value: Boolean); begin FEnabled := Value; if Value then State := DXBAR_NORMAL else State := DXBAR_DISABLED; end; procedure TdxBarCaptionButton.SetGlyph(Value: TBitmap); begin FGlyph.Assign(Value); end; procedure TdxBarCaptionButton.SetScreenTip(Value: TdxBarScreenTip); begin if FScreenTip <> Value then begin if FScreenTip <> nil then FNotifyComponent.RemoveFreeNotification(FScreenTip); FScreenTip := Value; if FScreenTip <> nil then FNotifyComponent.FreeNotification(FScreenTip); end; end; procedure TdxBarCaptionButton.SetState(Value: Integer); begin if FState <> Value then begin FState := Value; if Parent <> nil then Parent.ActivateHint(FState = DXBAR_HOT, Hint, Self); Changed(False); end; end; procedure TdxBarCaptionButton.SetOnClick(Value: TNotifyEvent); begin FOnClick := Value; Changed(True); end; procedure TdxBarCaptionButton.FreeNotification(AComponent: TComponent); begin FScreenTip := nil; end; { TdxBarCaptionButtons } constructor TdxBarCaptionButtons.Create(ABar: TdxBar); begin inherited Create(TdxBarCaptionButton); FBar := ABar; end; destructor TdxBarCaptionButtons.Destroy; begin AccessibilityHelperOwnerObjectDestroyed(FIAccessibilityHelper); inherited Destroy; end; function TdxBarCaptionButtons.Add: TdxBarCaptionButton; begin BeginUpdate; try Result := TdxBarCaptionButton(inherited Add); finally EndUpdate; end; end; procedure TdxBarCaptionButtons.UpdateButtonStates(const AMousePos: TPoint; AMousePressed: Boolean = False); var I: Integer; begin for I := 0 to Count - 1 do if Items[I].Enabled then if PtInRect(Items[I].Rect, AMousePos) or Items[I].IAccessibilityHelper.IsSelected then if AMousePressed then Items[I].State := DXBAR_PRESSED else Items[I].State := DXBAR_HOT else Items[I].State := DXBAR_NORMAL; end; function TdxBarCaptionButtons.GetOwner: TPersistent; begin Result := FBar; end; procedure TdxBarCaptionButtons.Update(Item: TCollectionItem); begin inherited; OnNotify(Self, Item); end; function TdxBarCaptionButtons.GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; begin Result := TdxBarCaptionButtonsAccessibilityHelper; end; function TdxBarCaptionButtons.GetButtonIndex(const APoint: TPoint): Integer; var I: Integer; begin Result := -1; for I := 0 to Count - 1 do if Items[I].Enabled and PtInRect(Items[I].Rect, APoint) then begin Result := I; Break; end; end; function TdxBarCaptionButtons.GetIAccessibilityHelper: IdxBarAccessibilityHelper; begin if FIAccessibilityHelper = nil then FIAccessibilityHelper := GetAccessibilityHelper(GetAccessibilityHelperClass.Create(Self)); Result := FIAccessibilityHelper; end; function TdxBarCaptionButtons.GetItem(Index: Integer): TdxBarCaptionButton; begin Result := TdxBarCaptionButton(inherited GetItem(Index)); end; function TdxBarCaptionButtons.GetRect: TRect; var I: Integer; begin Result := cxEmptyRect; for I := 0 to Count - 1 do if not IsRectEmpty(Items[I].Rect) then UnionRect(Result, Result, Items[I].Rect); end; procedure TdxBarCaptionButtons.SetItem(Index: Integer; Value: TdxBarCaptionButton); begin inherited SetItem(Index, Value); end; { TdxBar } constructor TdxBar.Create(AOwner: TComponent); begin inherited Create(AOwner); FAlphaBlendValue := 255; FBackgroundBitmap := dxBarCreateBitmap(BitmapChanged); FAllowClose := True; FAllowCustomizing := True; FAllowQuickCustomizing := True; FAllowReset := True; FBorderStyle := bbsSingle; FColor := clDefault; FDockedDockingStyle := dsTop; FEditFont := TFont.Create; FFont := TFont.Create; FFont.OnChange := FontChanged; FFreeNotificationItems := TList.Create; FGlyph := dxBarCreateBitmap(GlyphChanged); FMergeData := TdxBarMergeData.Create; FRotateWhenVertical := True; FShowMark := True; FSizeGrip := True; FCaptionButtons := TdxBarCaptionButtons.Create(Self); FCaptionButtons.OnNotify := CaptionButtonsNotification; end; destructor TdxBar.Destroy; begin DoDestroy; if not BarManager.IsDestroying and Assigned(BarManager.FOnBarDelete) then BarManager.OnBarDelete(BarManager, Self); FreeAndNil(FCaptionButtons); if FMergeData.MergedWith <> nil then FMergeData.MergedWith.Unmerge(Self); Unmerge; FreeAndNil(FMergeData); //#DG BarDesignController.DeselectIfSelected(Self); Visible := False; RemoveFromDockRow(True); MakeFreeNotification; FreeAndNil(FFreeNotificationItems); if BarManager.MainMenuBar = Self then BarManager.FMainMenuBar := nil; FreeAndNil(FItemLinks); FreeAndNil(FGlyph); FreeAndNil(FFont); FreeAndNil(FEditFont); FreeAndNil(FBackgroundBitmap); inherited Destroy; end; procedure TdxBar.Assign(Source: TPersistent); var Bar: TdxBar; begin if Source is TdxBar then begin Bar := TdxBar(Source); AllowClose := Bar.AllowClose; AllowCustomizing := Bar.AllowCustomizing; AllowQuickCustomizing := Bar.AllowQuickCustomizing; AllowReset := Bar.AllowReset; BorderStyle := Bar.BorderStyle; Caption := Bar.Caption; CaptionButtons := Bar.CaptionButtons; DockedDockControl := Bar.DockedDockControl; DockedDockingStyle := Bar.DockedDockingStyle; DockedLeft := Bar.DockedLeft; DockedTop := Bar.DockedTop; FloatLeft := Bar.FloatLeft; FloatTop := Bar.FloatTop; FloatClientWidth := Bar.FloatClientWidth; FloatClientHeight := Bar.FloatClientHeight; Hidden := Bar.Hidden; IsMainMenu := Bar.IsMainMenu; ItemLinks := Bar.ItemLinks; NotDocking := Bar.NotDocking; OneOnRow := Bar.OneOnRow; RotateWhenVertical := Bar.RotateWhenVertical; Row := Bar.Row; ShowMark := Bar.ShowMark; SizeGrip := Bar.SizeGrip; WholeRow := Bar.WholeRow; ChangeDockingStyle(Bar.DockingStyle, Bar.DockControl); UseRecentItems := Bar.UseRecentItems; UseRestSpace := Bar.UseRestSpace; Color := Bar.Color; Font := Bar.Font; UseOwnFont := Bar.UseOwnFont; Visible := Bar.Visible; end else inherited Assign(Source); end; procedure TdxBar.BitmapChanged(Sender: TObject); begin if Control <> nil then Control.RebuildBar; end; procedure TdxBar.DoDestroy; begin //#DG Destroying; CallNotify(FOnDestroy, Self); end; function TdxBar.GetBars: TdxBars; begin if GetBarManager = nil then Result := nil else Result := GetBarManager.Bars; end; function TdxBar.GetControl: TdxBarControl; begin if ItemLinks <> nil then Result := TdxBarControl(ItemLinks.FBarControl) else Result := nil; end; function TdxBar.GetDockControl: TdxBarDockControl; begin if IsAncestorComponentDifferencesDetection(Self) then Result := FLoadedDockControl else Result := FDockControl; end; function TdxBar.GetDockedDockingStyle: TdxBarDockingStyle; begin if FDockedDockControl = nil then Result := FDockedDockingStyle else Result := FDockedDockControl.DockingStyle; end; function TdxBar.GetDockingStyle: TdxBarDockingStyle; begin if IsAncestorComponentDifferencesDetection(Self) then Result := FLoadedDockingStyle else if FDockControl = nil then Result := FDockingStyle else Result := FDockControl.DockingStyle; end; function TdxBar.GetNext: TdxBar; begin if Index + 1 < Bars.Count then Result := Bars[Index + 1] else if Index <> 0 then Result := Bars[0] else Result := nil; end; function TdxBar.GetNotDocking: TdxBarDockingStyles; begin Result := FNotDocking; end; function TdxBar.GetPainter: TdxBarPainter; begin if RealDockControl <> nil then Result := RealDockControl.Painter else Result := BarManager.DefaultPainter; end; function TdxBar.GetRealDockControl: TdxDockControl; begin Result := FDockControl; if (Result = nil) and (FDockingStyle <> dsNone) then Result := Bars.FDockControls[FDockingStyle]; end; function TdxBar.GetRow: Integer; begin if DockRow <> nil then Result := DockRow.DockControl.RowList.IndexOf(DockRow) else Result := FRow; end; function TdxBar.GetUseRecentItems: Boolean; begin Result := FItemLinks.FUseRecentItems; end; function TdxBar.GetVisible: Boolean; begin if IsAncestorComponentDifferencesDetection(Self) then Result := FLoadedVisible else Result := FVisible; end; procedure TdxBar.GlyphChanged(Sender: TObject); begin if Control <> nil then Control.GlyphChanged; end; procedure TdxBar.SetAllowClose(Value: Boolean); begin if FAllowClose <> Value then begin FAllowClose := Value; if (DockingStyle = dsNone) and (Control <> nil) then Control.RepaintBar; Changed(False); end; end; procedure TdxBar.SetAllowQuickCustomizing(Value: Boolean); begin if FAllowQuickCustomizing <> Value then begin FAllowQuickCustomizing := Value; if BarManager.CanShowRecentItems and (Control <> nil) then Control.RepaintBar; end; end; procedure TdxBar.SetAlphaBlendValue(Value: Byte); begin if FAlphaBlendValue <> Value then begin FAlphaBlendValue := Value; if (Control <> nil) and (Control.DockingStyle = dsNone) then Control.SetLayeredAttributes; end; end; procedure TdxBar.SetBackgroundBitmap(Value: TBitmap); var AChanged: Boolean; begin AChanged := not ((Value = nil) and FBackgroundBitmap.Empty); FBackgroundBitmap.Assign(Value); if AChanged then BitmapChanged(nil); end; procedure TdxBar.SetBorderStyle(Value: TdxBarBorderStyle); begin if FBorderStyle <> Value then begin FBorderStyle := Value; if Control <> nil then Control.RebuildBar; end; end; procedure TdxBar.SetCaption(Value: string); begin if FCaption <> Value then begin if BarManager.BarByCaption(Value) <> nil then Exit; FCaption := Value; if Control <> nil then Control.CaptionChanged; // if (Name = '') and not BarManager.IsLoading then // CheckBarName(Value); Changed(False); end; end; procedure TdxBar.SetCaptionButtons(Value: TdxBarCaptionButtons); begin FCaptionButtons.Assign(Value); end; procedure TdxBar.SetColor(Value: TColor); begin if FColor <> Value then begin FColor := Value; if Control <> nil then Control.RebuildBar; end; end; procedure TdxBar.SetDockControl(Value: TdxBarDockControl); var PrevDockingStyle: TdxBarDockingStyle; NeedHiding: Boolean; begin if (Value <> nil) and (Value.BarManager <> BarManager) then Exit; if BarManager.IsLoading then begin FLoadedDockControl := Value; Exit; end; if FDockControl <> Value then begin PrevDockingStyle := DockingStyle; NeedHiding := not FChangingDockingStyle and (Control <> nil); if NeedHiding then if Value = nil then // NeedHiding := (DockingStyle <> dsNone) and (Control.DockControl <> Value) NeedHiding := (DockingStyle <> dsNone) and not ((Control.DockControl <> nil) and Control.DockControl.Main) else NeedHiding := Control.DockControl <> Value; if NeedHiding then Visible := False; FDockControl := Value; ItemLinks.RecentItemCount := -1; if not FChangingDockingStyle then begin FChangingDockingStyle := True; try if Value = nil then DockingStyle := PrevDockingStyle//dsNone else DockingStyle := Value.DockingStyle; finally FChangingDockingStyle := False; end; end; if NeedHiding then Visible := True; if Control <> nil then Control.DockControl := RealDockControl; if not FChangingDockingStyle then BarManager.DoBarDockingStyleChanged(Self); end; end; procedure TdxBar.SetDockedDockControl(Value: TdxBarDockControl); begin if (Value <> nil) and (Value.BarManager <> BarManager) then Exit; if FDockedDockControl <> Value then begin FDockedDockControl := Value; Changed(False); end; end; procedure TdxBar.SetDockedValue(Index: Integer; Value: Integer); var PrevValue: Integer; begin if Value < 0 then Value := 0; PrevValue := 0; case Index of 1: PrevValue := FDockedLeft; 2: PrevValue := FDockedTop; end; if PrevValue <> Value then begin case Index of 1: FDockedLeft := Value; 2: FDockedTop := Value; end; if csUpdating in ComponentState then FNeedUpdateControlPosition := True else UpdateControlPosition; Changed(False); end; end; procedure TdxBar.SetDockingStyle(Value: TdxBarDockingStyle); var ControlExists: Boolean; begin if BarManager.IsLoading then begin FLoadedDockingStyle := Value; Exit; end; if FDockingStyle <> Value then begin ControlExists := not FChangingDockingStyle and (Control <> nil) and (Control.DockingStyle <> Value); if ControlExists then Visible := False; FDockingStyle := Value; if not FChangingDockingStyle then begin FChangingDockingStyle := True; try DockControl := nil; finally FChangingDockingStyle := False; end; end; ItemLinks.RecentItemCount := -1; if ControlExists then begin Visible := True; Control.DockingStyle := Value; end; if not FChangingDockingStyle then BarManager.DoBarDockingStyleChanged(Self); end; end; procedure TdxBar.SetDockRow(Value: TdxDockRow); begin if (FDockRow = Value) or BarManager.IsDestroying then Exit; if FDockRow <> nil then FDockRow.DeleteBar(Self, True); FDockRow := Value; if Value <> nil then FDockRow.AddBar(Self); end; procedure TdxBar.SetFloatValue(Index: Integer; Value: Integer); var PrevValue: Integer; begin PrevValue := 0; case Index of 1: PrevValue := FFloatLeft; 2: PrevValue := FFloatTop; 3: PrevValue := FFloatClientWidth; 4: PrevValue := FFloatClientHeight; end; if PrevValue <> Value then begin case Index of 1: FFloatLeft := Value; 2: FFloatTop := Value; 3: FFloatClientWidth := Value; 4: FFloatClientHeight := Value; end; if csUpdating in ComponentState then FNeedUpdateControlPosition := True else UpdateControlPosition; Changed(False); end; end; procedure TdxBar.SetFont(Value: TFont); begin Font.Assign(Value); end; procedure TdxBar.SetGlyph(Value: TBitmap); begin Glyph.Assign(Value); end; procedure TdxBar.SetHidden(Value: Boolean); begin if FHidden <> Value then begin FHidden := Value; Changed(False); end; end; procedure TdxBar.SetIsMainMenu(Value: Boolean); begin if FIsMainMenu <> Value then begin BarManager.BeginUpdate; try if Value and (BarManager.MainMenuBar <> nil) then BarManager.MainMenuBar.IsMainMenu := False; FIsMainMenu := Value; if Value then begin BarManager.FMainMenuBar := Self; WholeRow := True; MultiLine := True; end else begin BarManager.FMainMenuBar := nil; MultiLine := False; WholeRow := False; end; if BarManager.IsLoading then Exit; if (Control <> nil) and (FDockingStyle <> dsNone) then Control.RepaintBar; Changed(False); finally BarManager.EndUpdate; end; end; end; procedure TdxBar.SetItemLinks(Value: TdxBarItemLinks); begin FItemLinks.Assign(Value); end; procedure TdxBar.SetLockUpdate(Value: Boolean); begin if Value <> FLockUpdate then begin FLockUpdate := Value; if FLockUpdate then BarManager.BeginUpdate else BarManager.EndUpdate; end; end; procedure TdxBar.SetMultiLine(Value: Boolean); begin if (FMultiLine <> Value) and (Value or not IsMainMenu) then begin FMultiLine := Value; if (Control <> nil) and (DockingStyle <> dsNone) then Control.RepaintBar; end; end; procedure TdxBar.SetName(const NewName: TComponentName); begin if FIsNameLocked then FOldName := NewName else inherited SetName(NewName); end; procedure TdxBar.Updated; begin inherited Updated; if FNeedUpdateControlPosition then UpdateControlPosition; end; procedure TdxBar.Updating; begin inherited Updating; FNeedUpdateControlPosition := False; end; procedure TdxBar.SetNotDocking(Value: TdxBarDockingStyles); begin if FNotDocking <> Value then begin FNotDocking := Value; if Control <> nil then Control.RepaintBar; end; end; procedure TdxBar.SetOneOnRow(Value: Boolean); begin if (RealDockControl = nil) or not RealDockControl.IsBarHandleDestroying then FOneOnRow := Value; end; function TdxBar.CreateControl: TdxBarControl; begin Result := GetControlClass.CreateEx(BarManager, Self); Result.UpdateFont; end; function TdxBar.GetControlClass: TdxBarControlClass; begin if RealDockControl <> nil then Result := RealDockControl.GetDockedBarControlClass else Result := TdxBarControl; end; procedure TdxBar.ShowControl; function CanShowBar: Boolean; begin Result := (DockingStyle <> dsNone) or BarManager.IsOwnerVisible and (not BarManager.HideFloatingBarsWhenInactive or BarManager.FIsCustomizing or IsFormActive(BarManager.ParentForm)); end; var P: TPoint; begin if DockingStyle <> dsNone then begin Control.BeginInternal; try Control.ChangeStyleWinTo(DockingStyle, RealDockControl); P := Point(DockedLeft, DockedTop); Windows.ClientToScreen(RealDockControl.Handle, P); Bars.RegInDock(DockingStyle, RealDockControl, Control, P); finally Control.EndInternal; end; end else begin Control.BeginInternal; try Control.ChangeStyleWinTo(DockingStyle, nil); finally Control.EndInternal; end; P := Control.GetTrackSize(DockingStyle); Control.SetBounds(FloatLeft, FloatTop, P.X, P.Y); end; if CanShowBar then ShowWindow(Control.Handle, SW_SHOWNA); BarManager.RemoveBarFromRestoringList(Self); end; class function TdxBar.GetIniSection(const ABaseSection: string; ABarIndex: Integer): string; begin Result := ABaseSection + 'Bar' + IntToStr(ABarIndex); end; procedure TdxBar.LoadFromIni(ASource: TCustomIniFile; const ABaseSection: string; ABarIndex: Integer; AStoringKind: TdxBarStoringKind; AFullLoad: Boolean = True); var ASection: string; S: string; begin ASection := GetIniSection(ABaseSection, ABarIndex); ItemLinks.LoadFromIni(ASource, ASection, AStoringKind); if AFullLoad then try with ASource do begin Caption := ReadString(ASection, 'Caption', Caption); S := ReadString(ASection, 'DockedDockControl', ''); if S <> '' then DockedDockControl := BarManager.FindDockControl(S); DockedDockingStyle := TdxBarDockingStyle(ReadInteger(ASection, 'DockedDockingStyle', Integer(DockedDockingStyle))); DockedLeft := ReadInteger(ASection, 'DockedLeft', DockedLeft); DockedTop := ReadInteger(ASection, 'DockedTop', DockedTop); OneOnRow := ReadBool(ASection, 'OneOnRow', OneOnRow); FloatLeft := ReadInteger(ASection, 'FloatLeft', FloatLeft); FloatTop := ReadInteger(ASection, 'FloatTop', FloatTop); FloatClientWidth := ReadInteger(ASection, 'FloatClientWidth', FloatClientWidth); FloatClientHeight := ReadInteger(ASection, 'FloatClientHeight', FloatClientHeight); S := ReadString(ASection, 'DockControl', ''); if S <> '' then DockControl := BarManager.FindDockControl(S); DockingStyle := TdxBarDockingStyle(ReadInteger(ASection, 'DockingStyle', Integer(DockingStyle))); Row := ReadInteger(ASection, 'Row', Row); Visible := ReadBool(ASection, 'Visible', False); MergeData.MergedWith := nil; end; except Visible := True; end; end; procedure TdxBar.LoadUsageData(ASource: TCustomIniFile; const ABaseSection: string; ABarIndex: Integer); begin ItemLinks.LoadUsageData(ASource, GetIniSection(ABaseSection, ABarIndex)); end; procedure TdxBar.SaveToIni(ADestination: TCustomIniFile; const ABaseSection: string; ABarIndex: Integer; AStoringKind: TdxBarStoringKind); var ASection: string; APath: string; begin ASection := GetIniSection(ABaseSection, ABarIndex); with ADestination do begin WriteString(ASection, 'Caption', Caption); if DockControl <> nil then begin APath := GetComponentPath(BarManager.Owner, DockControl); if APath <> '' then WriteString(ASection, 'DockControl', APath); end; if DockedDockControl <> nil then begin APath := GetComponentPath(BarManager.Owner, DockedDockControl); if APath <> '' then WriteString(ASection, 'DockedDockControl', APath); end; WriteInteger(ASection, 'DockedDockingStyle', Ord(DockedDockingStyle)); WriteInteger(ASection, 'DockedLeft', DockedLeft); WriteInteger(ASection, 'DockedTop', DockedTop); WriteInteger(ASection, 'DockingStyle', Ord(DockingStyle)); WriteInteger(ASection, 'FloatClientHeight', FloatClientHeight); WriteInteger(ASection, 'FloatClientWidth', FloatClientWidth); WriteInteger(ASection, 'FloatLeft', FloatLeft); WriteInteger(ASection, 'FloatTop', FloatTop); WriteBool(ASection, 'OneOnRow', OneOnRow); WriteInteger(ASection, 'Row', Row); if MergeData.MergedWith = nil then WriteBool(ASection, 'Visible', Visible or (BarManager.GetBarIndexInRestoringList(Self) <> -1)) else WriteBool(ASection, 'Visible', MergeData.PrevVisible); end; ItemLinks.SaveToIni(ADestination, ASection, AStoringKind); end; procedure TdxBar.InternalMerge(ABar: TdxBar; ASaveMergingBarVisibility: Boolean); var AIsBarMerged: Boolean; begin if MergeData.MergedWith <> nil then raise Exception.Create(cxGetResourceString(@dxSBAR_CANTMERGEWITHMERGEDTOOLBAR)); if (ABar = Self) or (ABar = nil) then raise Exception.Create(cxGetResourceString(@dxSBAR_CANTMERGETOOLBAR)); if ABar.MergeData.MergedWith = Self then raise Exception.Create(Format(cxGetResourceString(@dxSBAR_TOOLBARSALREADYMERGED), [ABar.Caption, Caption])); if ABar.MergeData.MergedBarList.Count > 0 then raise Exception.Create(Format(cxGetResourceString(@dxSBAR_TOOLBARHASMERGEDTOOLBARS), [ABar.Caption])); AIsBarMerged := ABar.MergeData.MergedWith <> nil; if AIsBarMerged then ABar.MergeData.MergedWith.InternalUnmergeFromBar(ABar, False); FMergingWith := ABar; try ABar.MergeData.MergedWith := Self; MergeData.MergedBarList.Add(ABar); BarManager.BeginUpdate; try ItemLinks.Merge(ABar.ItemLinks); finally BarManager.EndUpdate; end; if not AIsBarMerged and ASaveMergingBarVisibility then ABar.MergeData.PrevVisible := ABar.Visible; ABar.SetVisibility(False); finally FMergingWith := nil; end; end; procedure TdxBar.InternalUnmergeFromBar(ABar: TdxBar; ARestoreMergedBarsVisibility: Boolean); procedure RestoreMergedBar(ABar: TdxBar); begin ABar.MergeData.MergedWith := nil; MergeData.MergedBarList.Remove(ABar); if ARestoreMergedBarsVisibility then ABar.SetVisibility(ABar.MergeData.PrevVisible); end; procedure RestoreMergedBars; var I: Integer; begin if ABar <> nil then RestoreMergedBar(ABar) else for I := MergeData.MergedBarList.Count - 1 downto 0 do RestoreMergedBar(TdxBar(MergeData.MergedBarList[I])); end; begin if ABar = Self then raise Exception.Create(cxGetResourceString(@dxSBAR_CANTUNMERGETOOLBAR)); if (ABar <> nil) and (ABar.MergeData.MergedWith = nil) then Exit; if (ABar <> nil) and (ABar.MergeData.MergedWith <> Self) then raise Exception.Create(Format(cxGetResourceString(@dxSBAR_TOOLBARSARENOTMERGED), [ABar.Caption, Caption])); if MergeData.MergedBarList.Count = 0 then Exit; BarManager.BeginUpdate; try ItemLinks.Unmerge(ABar); finally BarManager.EndUpdate; end; RestoreMergedBars; if (MergeData.MergedBarList.Count = 0) and MergeData.CreatedByMerging then Free; end; procedure TdxBar.InternalUnmergeFromBarManager(ABarManager: TdxBarManager; ARestoreMergedBarsVisibility: Boolean); var ABar: TdxBar; I: Integer; begin for I := MergeData.MergedBarList.Count - 1 downto 0 do begin ABar := MergeData.MergedBarList[I]; if (ABarManager = nil) or (ABar.BarManager = ABarManager) then InternalUnmergeFromBar(ABar, ARestoreMergedBarsVisibility); end; end; procedure TdxBar.RestoreMergeState; var ABar: TdxBar; I: Integer; begin for I := 0 to MergeData.SavedMergedBarCount - 1 do begin ABar := TdxBar(MergeData.SavedMergedBars[I]); InternalMerge(ABar, ABar.BarManager = BarManager); end; MergeData.ClearSavedMergedBarList; end; procedure TdxBar.SaveMergeState; begin MergeData.SaveMergedBarList; end; procedure TdxBar.SetVisibility(Value: Boolean); procedure SetMDIChildRightWindowRect(out APrevBoundsRect: TRect); var AHandle: HWND; AParentForm: TCustomForm; R: TRect; begin AParentForm := TCustomForm(BarManager.Owner); if AParentForm.HandleAllocated then begin AHandle := AParentForm.Handle; APrevBoundsRect := AParentForm.BoundsRect; GetWindowRect(AHandle, R); MapWindowPoints(0, GetParent(AHandle), R, 2); TCustomFormAccess(AParentForm).WindowHandle := 0; AParentForm.BoundsRect := R; TCustomFormAccess(AParentForm).WindowHandle := AHandle; end; end; procedure RestoreMDIChildWindowRect(const APrevBoundsRect: TRect); var AHandle: HWND; AParentForm: TCustomForm; begin AParentForm := TCustomForm(BarManager.Owner); if AParentForm.HandleAllocated then begin AHandle := AParentForm.Handle; TCustomFormAccess(AParentForm).WindowHandle := 0; AParentForm.BoundsRect := APrevBoundsRect; TCustomFormAccess(AParentForm).WindowHandle := AHandle; end; end; function IsMDIChildToolbar: Boolean; begin Result := (BarManager.Owner is TCustomForm) and IsMDIChild(TCustomForm(BarManager.Owner)); end; var APrevBoundsRect: TRect; begin if Value <> Visible then begin if IsMDIChildToolbar then SetMDIChildRightWindowRect(APrevBoundsRect); Visible := Value; if IsMDIChildToolbar then RestoreMDIChildWindowRect(APrevBoundsRect); end; end; procedure TdxBar.CaptionButtonsNotification(Sender: TObject; AItem: TCollectionItem); begin if Control <> nil then Control.UpdateCaptionButtons(TdxBarCaptionButton(AItem)); end; procedure TdxBar.DoChanged; begin FChanged := True; end; procedure TdxBar.SetRotateWhenVertical(Value: Boolean); begin if FRotateWhenVertical <> Value then begin FRotateWhenVertical := Value; if Control <> nil then Control.Perform(CM_FONTCHANGED, 0, 0); end; end; procedure TdxBar.SetRow(Value: Integer); var ADockRow: TdxDockRow; begin if Value < 0 then Value := 0; if (Row = Value) and (DockRow <> nil) then Exit; FRow := Value; if RealDockControl <> nil then begin if FRow > RealDockControl.RowCount - 1 then begin repeat ADockRow := TdxDockRow.Create(RealDockControl); RealDockControl.RowList.Add(ADockRow); until not (BarManager.IsUpdateLocked or BarManager.BarsLoading) or (RealDockControl.RowCount > FRow); SetDockRow(ADockRow); end else SetDockRow(RealDockControl.RowList[FRow]); end; Changed(False); if RealDockControl <> nil then RealDockControl.UpdateDock; end; procedure TdxBar.SetShowMark(Value: Boolean); begin if FShowMark <> Value then begin FShowMark := Value; if Control <> nil then Control.RepaintBar; end; end; procedure TdxBar.SetSizeGrip(Value: Boolean); begin if FSizeGrip <> Value then begin FSizeGrip := Value; if IsStatusBar and (Control <> nil) then Control.RebuildBar; end; end; procedure TdxBar.SetUseOwnFont(Value: Boolean); begin if FUseOwnFont <> Value then begin FUseOwnFont := Value; FInternalFontChange := True; try if FUseOwnFont then FontChanged(nil) else Font := BarManager.Font; finally FInternalFontChange := False; end; end; end; procedure TdxBar.SetUseRecentItems(Value: Boolean); begin if UseRecentItems <> Value then begin FItemLinks.FUseRecentItems := Value; if Control <> nil then Control.RepaintBar; end; end; procedure TdxBar.SetUseRestSpace(Value: Boolean); begin if FUseRestSpace <> Value then begin FUseRestSpace := Value; if Control <> nil then Control.RepaintBar; end; end; procedure TdxBar.SetVisible(Value: Boolean); begin if Value and BarManager.IsDestroying then Exit; if not FVisible and not Value then BarManager.RemoveBarFromRestoringList(Self); if BarManager.IsLoading then begin if FVisible <> Value then FInternallyHidden := False; FLoadedVisible := Value; Exit; end; if FVisible <> Value then begin FInternallyHidden := False; if not Value and (Control <> nil) then Control.SavePos; FVisible := Value; if FVisible then begin FItemLinks.CreateBarControl; ShowControl; end else // Visible = False ItemLinks.DestroyBarControl; Changed(False);//#DG if not BarManager.IsDestroying and Assigned(BarManager.FOnBarVisibleChange) then BarManager.FOnBarVisibleChange(BarManager, Self); end; end; procedure TdxBar.SetWholeRow(Value: Boolean); begin if FWholeRow <> Value then begin FWholeRow := Value; if (Control <> nil) and (DockingStyle <> dsNone) then begin Visible := False; Visible := True; end; end; end; procedure TdxBar.FontChanged(Sender: TObject); begin if not FInternalFontChange then FUseOwnFont := True; if FUseOwnFont then CreateEditFontHandle(Font, FEditFont, False); if Control <> nil then Control.UpdateFont; end; procedure TdxBar.Move(X, Y: Integer); begin DockingStyle := dsNone; FloatLeft := X; FloatTop := Y; end; procedure TdxBar.Move(ADockControl: TdxDockControl; ARow, APosition: Integer); var ADockRow: TdxDockRow; APrevOneOnRow, APrevVisible: Boolean; begin if (RealDockControl = nil) and (ADockControl = nil) or (ADockControl <> nil) and (ADockControl.BarManager <> BarManager) then Exit; if ADockControl = nil then ADockControl := RealDockControl; if (ADockControl = RealDockControl) and (ARow = Row) and (APosition = GetDockedPosition) then Exit; APrevOneOnRow := OneOnRow; APrevVisible := Visible; Visible := False; if BarManager.IsInternalDockControl(ADockControl) then DockingStyle := ADockControl.DockingStyle else FDockControl := TdxBarDockControl(ADockControl); if ARow >= ADockControl.RowCount then begin ADockRow := TdxDockRow.Create(ADockControl); ADockControl.RowList.Add(ADockRow); end; if ADockControl.Vertical then DockedTop := APosition else DockedLeft := APosition; Row := ARow; OneOnRow := APrevOneOnRow; Visible := APrevVisible; RealDockControl.AssignPositions; end; procedure TdxBar.Move(ADockingStyle: TdxBarDockedDockingStyle; ARow, APosition: Integer); begin Move(BarManager.InternalDockControls[ADockingStyle], ARow, APosition); end; procedure TdxBar.Move(ABar: TdxBar; AInsertAfter: Boolean = True); var APosition: Integer; begin if (ABar.RealDockControl = nil) or (ABar.BarManager <> BarManager) or AInsertAfter and (ABar.Control = nil) then Exit; APosition := ABar.GetDockedPosition; if AInsertAfter then if ABar.IsVertical then Inc(APosition, ABar.Control.Height) else Inc(APosition, ABar.Control.Width); OneOnRow := False; Move(ABar.RealDockControl, ABar.Row, APosition); end; procedure TdxBar.UpdateControlPosition; var P: TPoint; begin if (Control <> nil) and not Bars.IsMoving and not Control.FPosSaving then if DockingStyle = dsNone then begin P := Control.GetTrackSize(dsNone); Control.SetBounds(FloatLeft, FloatTop, P.X, P.Y); end else begin if DockRow <> nil then DockRow.DeleteCol(Control); ShowControl; end; end; function TdxBar.IsDockedDockingStyleStored: Boolean; begin Result := FDockedDockControl = nil; end; function TdxBar.IsDockingStyleStored: Boolean; begin Result := FDockControl = nil; end; procedure TdxBar.AddFreeNotification(AItem: TdxBarItem); begin FFreeNotificationItems.Add(AItem); end; procedure TdxBar.RemoveFreeNotification(AItem: TdxBarItem); begin FFreeNotificationItems.Remove(AItem); end; procedure TdxBar.MakeFreeNotification; var I: Integer; begin for I := FFreeNotificationItems.Count - 1 downto 0 do TdxBarItem(FFreeNotificationItems[I]).ObjectNotification(opRemove, Self); end; procedure TdxBar.RemoveFromDockRow(ADestroyEmptyDockRow: Boolean); begin if FDockRow <> nil then FDockRow.DeleteBar(Self, ADestroyEmptyDockRow); FDockRow := nil; end; function TdxBar.BarNCSizeX(AStyle: TdxBarDockingStyle): Integer; begin with Painter.GetToolbarContentOffsets(Self, AStyle, HasSizeGrip) do Result := Left + Right; end; function TdxBar.BarNCSizeY(AStyle: TdxBarDockingStyle): Integer; begin with Painter.GetToolbarContentOffsets(Self, AStyle, HasSizeGrip) do Result := Top + Bottom; end; function TdxBar.CanClose: Boolean; begin Result := FAllowClose and not FIsMainMenu and ((Control = nil) or Control.HasCaption); end; function TdxBar.CanMoving: Boolean; const AllDockingStyles = [Low(TdxBarDockingStyle)..High(TdxBarDockingStyle)]; begin Result := (NotDocking <> AllDockingStyles) and (BarManager.NotDocking <> AllDockingStyles); end; function TdxBar.CanReset: Boolean; begin Result := FIsPredefined and FAllowReset; end; function TdxBar.GetDockedPosition: Integer; begin if IsVertical then Result := DockedTop else Result := DockedLeft; end; function TdxBar.HasSizeGrip: Boolean; var Parent: HWND; R, CR: TRect; function FindForm(AHandle: HWND): TCustomForm; var AControl: TWinControl; begin AControl := FindControl(AHandle); if AControl is TCustomForm then Result := TCustomForm(AControl) else Result := nil; end; function IsBottom(AHandle: HWND): Boolean; begin Parent := GetParent(AHandle); Result := (Parent = 0) or IsMDIChild(FindForm(AHandle)); if not Result then begin GetWindowRect(AHandle, R); MapWindowRect(0, Parent, R); GetClientRect(Parent, CR); Result := (R.Bottom = CR.Bottom) and IsBottom(Parent); end; end; begin Result := IsStatusBar and SizeGrip and not IsZoomed(BarManager.Owner.Handle) and ((Control = nil) or IsBottom(Control.Handle)); end; function TdxBar.IsFloat: Boolean; begin Result := (Control <> nil) and (DockingStyle = dsNone); end; function TdxBar.IsShortCut(AShortCut: TShortCut): Boolean; begin Result := FItemLinks.IsShortCut(AShortCut); end; function TdxBar.IsStatusBar: Boolean; begin Result := (FBorderStyle = bbsNone) and (DockingStyle = dsBottom) and WholeRow; // !!! end; //IdxBarSelectableItem function TdxBar.CanDelete(ADestruction: Boolean = False): Boolean; begin Result := (BarManager.Designing or not IsPredefined and CanClose) and BarManager.CanDeleteComponent(Self); end; procedure TdxBar.DeleteSelection(var AReference: IdxBarSelectableItem; ADestruction: Boolean); begin if CanDelete(ADestruction) then begin AReference := nil; Free; end; end; procedure TdxBar.ExecuteCustomizationAction(ABasicAction: TdxBarCustomizationAction); begin // do nothing end; function TdxBar.GetBarManager: TdxBarManager; begin Result := TdxBarManager(GetParentComponent); end; procedure TdxBar.GetMasterObjects(AList: TdxObjectList); begin AList.Add(BarManager.Owner); end; function TdxBar.GetNextSelectableItem: IdxBarSelectableItem; begin Result := GetNext; end; function TdxBar.GetSelectableParent: TPersistent; function FindSelectableParent(AControl: TWinControl): TWinControl; begin Result := nil; while (AControl <> nil) and (Result = nil) do if GetClass(AControl.ClassName) <> nil then Result := AControl else AControl := AControl.Parent; end; begin Result := FindSelectableParent(DockControl); if Result = nil then Result := BarManager.Owner; end; function TdxBar.GetSelectionStatus: TdxBarSelectionStatus; begin Result := BarManager.GetSelectionStatus(Self); end; function TdxBar.GetSupportedActions: TdxBarCustomizationActions; begin Result := [caDelete]; end; procedure TdxBar.Invalidate; begin if Control <> nil then Control.Invalidate; end; function TdxBar.IsComplex: Boolean; begin Result := False; end; function TdxBar.IsComponentSelected: Boolean; begin Result := BarManager.IsComponentSelected(Self); end; procedure TdxBar.SelectComponent(ASelectionOperation: TdxBarSelectionOperation = soExclusive); begin BarManager.SelectComponent(Self, ASelectionOperation); end; function TdxBar.SelectParentComponent: Boolean; begin BarManager.SelectComponent(GetSelectableParent); Result := True; end; procedure TdxBar.SelectionChanged; begin BarDesignController.SynchronizeLastSelectedItem; Invalidate; end; // IdxBarLinksOwner function TdxBar.CanContainItem(AItem: TdxBarItem; out AErrorText: string): Boolean; begin Result := AItem.CanBeOnToolbar(Self, AErrorText); end; function TdxBar.CreateBarControl: TCustomdxBarControl; begin Result := CreateControl; end; function TdxBar.GetItemLinks: TdxBarItemLinks; begin Result := FItemLinks; end; function TdxBar.GetComponentInstance: TComponent; begin Result := Self; end; function TdxBar.GetPersistentInstance: TPersistent; begin Result := Self; end; procedure TdxBar.ChangeDockingStyle(AStyle: TdxBarDockingStyle; ADockControl: TdxDockControl); begin if (ADockControl <> nil) and ADockControl.Main then ADockControl := nil; if DockingStyle = AStyle then DockControl := TdxBarDockControl(ADockControl) else if DockControl = ADockControl then DockingStyle := AStyle else if ADockControl = nil then DockingStyle := AStyle else DockControl := TdxBarDockControl(ADockControl); end; function TdxBar.GetCollectionFromParent(AParent: TComponent): TcxComponentCollection; begin Result := (AParent as TdxBarManager).Bars; end; function TdxBar.IsVertical: Boolean; begin Result := (DockingStyle in [dsLeft, dsRight]) and RotateWhenVertical; end; procedure TdxBar.Reset; procedure InternalReset(ASource: TCustomIniFile; const ABaseSection: string; ABarIndex: Integer); begin ResettingToolbar := True; try LoadFromIni(ASource, ABaseSection, ABarIndex, skIni, BarManager.UseFullReset); LoadUsageData(ASource, ABaseSection, ABarIndex); ItemLinks.CheckLinks(ASource, ABaseSection); finally ResettingToolbar := False; end; end; var ABarIndex: Integer; APrevVisible: Boolean; begin ABarIndex := BarManager.GetSavedBarIndex(Caption); if ABarIndex <> -1 then begin BarManager.DoBarBeforeReset(Self); BarManager.BeginUpdate; try APrevVisible := Visible; if BarManager.UseFullReset then Visible := False; try InternalReset(BarManager.SavedState, BarManager.GetBaseIniSection, ABarIndex); finally if BarManager.UseFullReset then Visible := APrevVisible; end; finally BarManager.EndUpdate; end; BarManager.DoBarAfterReset(Self); end; end; procedure TdxBar.ResetWithConfirmation; begin if dxBarMessageBox(Format(cxGetResourceString(@dxSBAR_WANTTORESETTOOLBAR), [Caption]), MB_OKCANCEL or MB_ICONEXCLAMATION) = ID_OK then Reset; end; procedure TdxBar.SetParentComponent(AParent: TComponent); begin inherited SetParentComponent(AParent); FItemLinks := TdxBarControlItemLinks.Create(BarManager, Self); Font.OnChange := nil; Font.Assign(BarManager.Font); Font.OnChange := FontChanged; if not BarManager.IsLoading then begin if Assigned(BarManager.OnBarAdd) then BarManager.OnBarAdd(BarManager, Self); Changed(False); end; end; procedure TdxBar.Merge(ABar: TdxBar); begin InternalMerge(ABar, True); end; procedure TdxBar.Unmerge(ABar: TdxBar = nil); begin InternalUnmergeFromBar(ABar, True); end; { TdxBars } constructor TdxBars.Create(ABarManager: TdxBarManager); var ADockingStyle: TdxBarDockingStyle; begin inherited Create(ABarManager, TdxBar); FBarManager := ABarManager; FDockingZoneSize := MinToolbarSize; for ADockingStyle := dsLeft to dsBottom do begin FDockControls[ADockingStyle] := TdxDockControl.CreateEx(nil, FBarManager, ADockingStyle); FDockControls[ADockingStyle].Parent := FBarManager.Owner; end; end; destructor TdxBars.Destroy; var I: TdxBarDockingStyle; begin for I := dsLeft to dsBottom do begin FDockControls[I].Free; FDockControls[I] := nil; end; inherited; end; function TdxBars.GetDockControl(Index: TdxBarDockingStyle): TdxDockControl; begin Result := FDockControls[Index]; end; function TdxBars.GetItem(Index: Integer): TdxBar; begin Result := TdxBar(inherited Items[Index]); end; procedure TdxBars.SetItem(Index: Integer; Value: TdxBar); begin Items[Index].Assign(Value); end; { function TdxBars.GetOwner: TPersistent; begin Result := FBarManager; end; } procedure TdxBars.RegInDock(AStyle: TdxBarDockingStyle; ADockControl: TdxDockControl; ABarControl: TdxBarControl; APos: TPoint); begin if ADockControl <> nil then ADockControl.AddBarControl(ABarControl, APos, True) else if (AStyle <> dsNone) and (FDockControls[AStyle] <> nil) then FDockControls[AStyle].AddBarControl(ABarControl, APos, True); end; procedure TdxBars.UnregFromDock(AStyle: TdxBarDockingStyle; ADockControl: TdxDockControl; ABarControl: TdxBarControl); begin if ADockControl <> nil then ADockControl.DeleteBarControl(ABarControl, nil, True) else if (AStyle <> dsNone) and (FDockControls[AStyle] <> nil) then FDockControls[AStyle].DeleteBarControl(ABarControl, nil, True); end; procedure DockTimerProc(Wnd: HWND; Msg: UINT; idEvent: UINT; Time: DWORD); stdcall; var P: TPoint; begin dxKillTimer(0, FDockTimerID); if FDockBarManager <> nil then with FDockBarManager.Bars do begin P := GetMouseCursorPos; Inc(P.X, FMovingOffset.X); Inc(P.Y, FMovingOffset.Y); FDocking := True; ChangeBarControlPos(FMovingBarControl, P); FDocking := False; FDockBarManager := nil; end; end; procedure TdxBars.ChangeBarControlPos(ABarControl: TdxBarControl; APos: TPoint); var AStyle: TdxBarDockingStyle; ADockControl: TdxDockControl; ASize: TPoint; begin AStyle := GetDockingStyleAtPos(ABarControl.Bar, APos, ADockControl); if not FBarManager.DoDocking(ABarControl.Bar, AStyle, ADockControl) then Exit; if not FDocking and (ABarControl.DockingStyle = dsNone) and (AStyle <> dsNone) then begin dxKillTimer(0, FDockTimerID); FDockBarManager := BarManager; FDockTimerID := SetTimer(0, 0, BarManager.WaitForDockingTime, @DockTimerProc); ADockControl := nil; AStyle := dsNone; end; if AStyle = dsNone then begin Dec(APos.X, FMovingOffset.X); Dec(APos.Y, FMovingOffset.Y); end; if (ABarControl.DockingStyle <> AStyle) or (ABarControl.DockControl <> ADockControl) then begin ABarControl.Hide; if ABarControl.DockingStyle <> dsNone then begin UnregFromDock(ABarControl.DockingStyle, ABarControl.DockControl, ABarControl); ABarControl.ItemLinks.RecentItemCount := -1; end; if AStyle <> dsNone then begin with ABarControl do begin BeginInternal; //!!! try ChangeStyleWinTo(AStyle, ADockControl); finally EndInternal; end; end; RegInDock(AStyle, ADockControl, ABarControl, APos); end else with ABarControl do begin BeginInternal; // for WMSize try ChangeStyleWinTo(AStyle, nil); finally EndInternal; end; ASize := GetTrackSize(AStyle); with GetDragPointOffset(AStyle) do SetWindowPos(Handle, 0, APos.X - X, APos.Y - Y, ASize.X, ASize.Y, SWP_NOZORDER or SWP_NOACTIVATE); end; Windows.ShowWindow(ABarControl.Handle, SW_SHOWNA); end else if ABarControl.DockingStyle <> dsNone then ADockControl.MoveBarControl(ABarControl, APos) else with ABarControl, GetDragPointOffset(AStyle) do SetWindowPos(Handle, 0, APos.X - X, APos.Y - Y, 0, 0, SWP_NOZORDER or SWP_NOSIZE or SWP_NOACTIVATE); end; function TdxBars.GetDockingStyleAtPos(Bar: TdxBar; Pos: TPoint; var DockControl: TdxDockControl): TdxBarDockingStyle; var ADockControl: TdxDockControl; function PtInControlRect(ADockControl: TWinControl; const R: TRect; P: TPoint): Boolean; var AParent: TWinControl; begin Result := PtInRect(R, P); if Result and ADockControl.HandleAllocated and (ADockControl.Parent <> nil) and (ADockControl.Parent.Parent <> nil) then begin AParent := ADockControl.Parent.Parent; P := AParent.ScreenToClient(P); Result := ADockControl.Parent.Handle = ChildWindowFromPointEx(AParent.Handle, P, CWP_SKIPINVISIBLE); end; end; function CheckDockZone(ADockingStyle: TdxBarDockingStyle): Boolean; var I: Integer; begin Result := False; for I := 0 to FBarManager.DockControlCount - 1 do begin ADockControl := FBarManager.DockControls[I]; with ADockControl do if (DockingStyle = ADockingStyle) and (CanFocus or BarManager.Designing) then begin Result := FBarManager.DoDocking(Bar, ADockingStyle, ADockControl) and PtInControlRect(ADockControl, GetDockZoneBounds, Pos); if Result then Break; end; end; if Result then begin DockControl := ADockControl; GetDockingStyleAtPos := ADockingStyle; end; end; begin DockControl := nil; Result := dsNone; if FMoving and (GetAsyncKeyState(VK_CONTROL) < 0) then Exit; if CheckDockZone(dsLeft) then Exit; if CheckDockZone(dsRight) then Exit; if CheckDockZone(dsTop) then Exit; if CheckDockZone(dsBottom) then Exit; if FMoving then begin Dec(Pos.X, FMovingOffset.X); Dec(Pos.Y, FMovingOffset.Y); end; if CheckDockZone(dsLeft) then Exit; if CheckDockZone(dsRight) then Exit; if CheckDockZone(dsTop) then Exit; if CheckDockZone(dsBottom) then Exit; end; procedure TdxBars.Moving(AMovingBarControl: TdxBarControl); var CaptureWnd: HWND; Msg: TMsg; PrevP, CalcP, P: TPoint; begin // --- if not AMovingBarControl.CanMoving then Exit; with AMovingBarControl, Bar do if DockingStyle <> dsNone then GetDockCol.FPos := Point(DockedLeft, DockedTop); FMoving := True; AMovingBarControl.Moving := True; PrevP := GetMouseCursorPos; FMovingBarOriginalDockingStyle := FMovingBarControl.DockingStyle; FMovingOffset := cxNullPoint; FMovingStaticOffset := cxNullPoint; with FMovingBarControl, Bar do if DockingStyle <> dsNone then begin P := GetDockCol.Pos; Windows.ClientToScreen(RealDockControl.Handle, P); RealDockControl.DeleteBarControl(Control, nil, False); CalcP := PrevP; RealDockControl.GetPosForRow(Row, OneOnRow, CalcP); if Control.Vertical then FMovingOffset.X := CalcP.X - PrevP.X else FMovingOffset.Y := CalcP.Y - PrevP.Y; Control.BeginInternal; try RealDockControl.AddBarControl(Control, P, False); finally Control.EndInternal; end; FMovingStaticOffset := Point(Left, Top); Windows.ClientToScreen(RealDockControl.Handle, FMovingStaticOffset); with FMovingStaticOffset do begin X := PrevP.X - X; Y := PrevP.Y - Y; end; end; ProcessPaintMessages; Include(BarDesignController.FDesignStates, dsKeyAlreadyProcessed); CaptureWnd := BarManager.GetWindowForMouseCapturing; SetCapture(CaptureWnd); try while GetCapture = CaptureWnd do begin case Integer(GetMessage(Msg, 0, 0, 0)) of -1: Break; 0: begin PostQuitMessage(Msg.wParam); Break; end; end; with Msg do if ((message = WM_KEYDOWN) or (message = WM_KEYUP)) and (wParam = VK_CONTROL) then begin message := WM_MOUSEMOVE; hwnd := 0; lParam := Windows.LPARAM(PointToSmallPoint(GetMouseCursorPos)); PrevP := cxInvalidPoint; end; case Msg.message of WM_KEYDOWN, WM_KEYUP: if Msg.wParam = VK_ESCAPE then Break; WM_MOUSEMOVE: begin P := SmallPointToPoint(TSmallPoint(Msg.lParam)); ClientToScreen(Msg.hwnd, P); if (P.X <> PrevP.X) or (P.Y <> PrevP.Y) then begin CalcP := P; Inc(CalcP.X, FMovingOffset.X); Inc(CalcP.Y, FMovingOffset.Y); ChangeBarControlPos(FMovingBarControl, CalcP); //ProcessPaintMessages; PrevP := P; end; end; WM_LBUTTONUP: Break; else TranslateMessage(Msg); DispatchMessage(Msg); end; end; finally if dxKillTimer(0, FDockTimerID) then FDockBarManager := nil; if GetCapture = CaptureWnd then ReleaseCapture; AMovingBarControl := FMovingBarControl; FMovingBarControl.Moving := False; if AMovingBarControl.DockingStyle <> dsNone then AMovingBarControl.DockControl.AssignPositions; FMoving := False; Exclude(BarDesignController.FDesignStates, dsKeyAlreadyProcessed); end; end; procedure TdxBars.Repaint; var I: Integer; begin for I := 0 to Count - 1 do with Items[I] do if Control <> nil then Control.RepaintBar; end; procedure TdxBars.SetItemName(AItem: TcxComponentCollectionItem); begin AItem.Name := GetUniqueToolBarName(BarManager.Name + 'Bar'); end; procedure TdxBars.Update(AItem: TcxComponentCollectionItem; AAction: TcxComponentCollectionNotification); begin inherited; if AAction = ccnChanged then BarManager.DesignerModified; //#DG end; function TdxBars.Add: TdxBar; begin Result := TdxBar(inherited Add); end; function TdxBars.GetUniqueToolbarName(const ABaseName: string): string; begin Result := BarManager.GetUniqueToolbarName(ABaseName); end; function TdxBars.Insert(Index: Integer): TdxBar; begin Result := TdxBar(inherited Insert(Index)); end; { TdxBarItemOptions } constructor TdxBarItemOptions.Create(AItemLinks: TdxBarItemLinks); begin inherited Create; FItemLinks := AItemLinks; FShowDescriptions := GetDefaultValue(ioShowDescriptions); FShowShortCuts := GetDefaultValue(ioShowShortCuts); FSize := GetDefaultValue(ioSize); end; procedure TdxBarItemOptions.Assign(Source: TPersistent); begin if Source is TdxBarItemOptions then begin FAssignedValues := TdxBarItemOptions(Source).FAssignedValues; FShowDescriptions := TdxBarItemOptions(Source).FShowDescriptions; FShowShortCuts := TdxBarItemOptions(Source).FShowShortCuts; FSize := TdxBarItemOptions(Source).FSize; end else inherited; end; function TdxBarItemOptions.GetAssignedValues: TdxBarItemOptionValues; begin Result := FAssignedValues; end; function TdxBarItemOptions.GetDefaultValue(AOption: TdxBarItemOptionValue): Variant; begin Result := FItemLinks.GetDefaultValue(AOption); end; function TdxBarItemOptions.GetValue(AOption: TdxBarItemOptionValue): Variant; begin case AOption of ioShowDescriptions: Result := ShowDescriptions; ioShowShortCuts: Result := ShowShortCuts; else {ioSize} Result := Size; end; end; function TdxBarItemOptions.GetShowDescriptions: Boolean; begin if IsShowDescriptionsStored then Result := FShowDescriptions else Result := GetDefaultValue(ioShowDescriptions); end; function TdxBarItemOptions.GetShowShortCuts: Boolean; begin if IsShowShortCutsStored then Result := FShowShortCuts else Result := GetDefaultValue(ioShowShortCuts); end; function TdxBarItemOptions.GetSize: TdxBarMenuItemSize; begin if IsSizeStored then Result := FSize else Result := GetDefaultValue(ioSize); end; procedure TdxBarItemOptions.SetAssignedValues(AValue: TdxBarItemOptionValues); begin FAssignedValues := AValue; { if FAssignedValues <> AValue then begin FAssignedValues := AValue; if not IsValueStored(ioShowDescriptions) then FShowDescriptions := GetDefaultValue(ioShowDescriptions); if not IsValueStored(ioShowShortCuts) then FShowShortCuts := GetDefaultValue(ioShowShortCuts); if not IsValueStored(ioSize) then FSize := GetDefaultValue(ioSize); end; } end; procedure TdxBarItemOptions.SetShowDescriptions(AValue: Boolean); begin FShowDescriptions := AValue; Include(FAssignedValues, ioShowDescriptions); end; procedure TdxBarItemOptions.SetShowShortCuts(AValue: Boolean); begin FShowShortCuts := AValue; Include(FAssignedValues, ioShowShortCuts); end; procedure TdxBarItemOptions.SetSize(AValue: TdxBarMenuItemSize); begin FSize := AValue; Include(FAssignedValues, ioSize); end; function TdxBarItemOptions.IsValueStored(AOption: TdxBarItemOptionValue): Boolean; begin Result := AOption in AssignedValues; end; function TdxBarItemOptions.IsShowDescriptionsStored: Boolean; begin Result := IsValueStored(ioShowDescriptions); end; function TdxBarItemOptions.IsShowShortCutsStored: Boolean; begin Result := IsValueStored(ioShowShortCuts) end; function TdxBarItemOptions.IsSizeStored: Boolean; begin Result := IsValueStored(ioSize); end; { TdxBarItemLink } constructor TdxBarItemLink.Create(Collection: TCollection); begin inherited Create(Collection); FButtonGroup := bgpNone; FLoadedRecentIndex := -1; FLoadedVisible := True; FMostRecentlyUsed := True; FPosition := ipBeginsNewRow; FUseCount := BarManager.FMostRecentlyUsedUseCount; FUserGlyph := dxBarCreateBitmap(OnUserGlyphChanged); FViewLevels := dxBarItemAllViewLevels; FVisible := True; AddToRecentList; if not BarManager.IsLoading and Assigned(BarManager.FOnItemLinkAdd) then BarManager.FOnItemLinkAdd(BarManager, Self); end; destructor TdxBarItemLink.Destroy; var ABarControl: TCustomdxBarControl; begin if not BarManager.IsDestroying and Assigned(BarManager.FOnItemLinkDelete) then BarManager.FOnItemLinkDelete(BarManager, Self); ABarControl := BarControl; if FControl <> nil then begin if (ABarControl <> nil) and not ABarControl.IsDestroying then begin if ABarControl.SelectedControl = FControl then begin BarManager.FSelectedItem := nil; ABarControl.SelectedControl := nil; end; if BarControl.FPrevTrackedLink = Self then BarControl.FPrevTrackedLink := nil; end; DestroyControl; end; // obsolete if BarDesignController <> nil then BarDesignController.DropSelection(Self); if FItem <> nil then FItem.FLinks.Remove(Self); FreeAndNil(FUserGlyph); RemoveFromRecentList; inherited Destroy; { if (ABarControl <> nil) and ABarControl.HandleAllocated and not ABarControl.IsDestroying then begin ABarControl.RepaintBar; if Assigned(AItemLinks.FOnChange) then AItemLinks.FOnChange(AItemLinks); end;} end; function TdxBarItemLink.GetAllowedViewLevels: TdxBarItemViewLevels; begin Result := ViewLevels; end; function TdxBarItemLink.GetAvailableIndex: Integer; begin if Owner = nil then Result := -1 else Result := Owner.AvailableIndexOf(Self); end; function TdxBarItemLink.GetBarControl: TCustomdxBarControl; begin Result := Owner.FBarControl; end; function TdxBarItemLink.GetBeginGroup: Boolean; var AVisibleIndex: Integer; function HiddenBeginGroupExists: Boolean; var I: Integer; begin for I := Owner.VisibleItems[AVisibleIndex - 1].Index + 1 to Index - 1 do begin Result := Owner[I].BeginGroup; if Result then Exit; end; Result := False; end; begin AVisibleIndex := VisibleIndex; Result := FBeginGroup and (AVisibleIndex <> 0) or (AVisibleIndex > 0) and HiddenBeginGroupExists; end; function TdxBarItemLink.GetCanVisibleIndex: Integer; begin if Owner = nil then Result := -1 else Result := Owner.CanVisibleIndexOf(Self); end; function TdxBarItemLink.GetCaption: string; begin if not (udCaption in FUserDefine) and (FItem <> nil) then Result := FItem.Caption else Result := FUserCaption; end; function TdxBarItemLink.GetCollection: TdxBarItemLinks; begin Result := TdxBarItemLinks(inherited Collection); end; function TdxBarItemLink.GetGlyph: TBitmap; begin if not (udGlyph in FUserDefine) and (FItem <> nil) then Result := FItem.Glyph else Result := FUserGlyph; end; function TdxBarItemLink.GetNext: TdxBarItemLink; begin if Collection.Next(Self, True) <> Self then Result := Collection.Next(Self, True) else Result := nil; end; function TdxBarItemLink.GetOwnerValue: TdxBarItemLinks; begin Result := Collection; end; function TdxBarItemLink.GetPaintStyle: TdxBarPaintStyle; begin if not (udPaintStyle in FUserDefine) and (FItem <> nil) then Result := FItem.PaintStyle else Result := FUserPaintStyle; end; function TdxBarItemLink.GetUserDefine: TdxBarUserDefines; begin Result := FUserDefine; end; function TdxBarItemLink.GetVisibleIndex: Integer; begin if Owner = nil then Result := -1 else Result := Owner.VisibleIndexOf(Self); end; function TdxBarItemLink.GetWidth: Integer; begin if udWidth in FUserDefine then Result := FUserWidth else if Item is TdxCustomBarEdit then Result := TdxCustomBarEdit(Item).Width else Result := 0 end; procedure TdxBarItemLink.ReadItemName(AReader: TReader); begin FLoadedItemName := AReader.ReadString; end; procedure TdxBarItemLink.SetBeginGroup(Value: Boolean); begin if FBeginGroup <> Value then begin FBeginGroup := Value; if Control <> nil then Control.BeginGroupChanged; Changed(False); //#DG ItemLinkChanged; end; end; procedure TdxBarItemLink.SetButtonGroup(Value: TdxBarButtonGroupPosition); begin if Value <> FButtonGroup then begin FButtonGroup := Value; Changed(True); end; end; procedure TdxBarItemLink.SetCollection(Value: TdxBarItemLinks); begin inherited Collection := Value; end; procedure TdxBarItemLink.SetItem(Value: TdxBarItem); var AErrorText: string; begin if FItem <> Value then begin Owner.BeginUpdate; try DestroyControl; if FItem <> nil then FItem.FLinks.Remove(Self); FItem := nil; if Value <> nil then begin try if not Owner.CanContainItem(Value, AErrorText) then raise Exception.Create(AErrorText); FItem := Value; FItem.FLinks.Add(Self); Owner.RefreshVisibilityLists; if (Owner.Owner <> nil) and not (csLoading in Owner.Owner.ComponentState) then CheckMostRecentlyUsed; finally if Owner.UpdateCount = 1 then BarManager.DoItemLinkChange(Self); // TdxBarItemLink.SetItem should fire OnItemLinkChange for compatibility with Bars5 end; end else Free; finally Owner.EndUpdate; end; //#DG if (Owner.UpdateCount = 0) and (BarControl <> nil) then BarControl.RepaintBar; end; end; procedure TdxBarItemLink.SetItemRect(Value: TRect); begin FItemRect := Value; if Control <> nil then Control.DoCalculateParts; end; procedure TdxBarItemLink.SetMostRecentlyUsed(Value: Boolean); begin if FMostRecentlyUsed <> Value then begin FMostRecentlyUsed := Value; CheckMostRecentlyUsed; if BarControl <> nil then BarControl.RepaintBar; Changed(False); //#DG //#DG ItemLinkChanged; end; end; procedure TdxBarItemLink.SetPosition(Value: TdxBarItemPosition); begin if Value <> FPosition then begin FPosition := Value; Changed(True); end; end; procedure TdxBarItemLink.ForceSetUserDefine(AValue: TdxBarUserDefine); begin FUserDefine := FUserDefine - [AValue]; UserDefine := UserDefine + [AValue]; end; procedure TdxBarItemLink.SetUserDefine(Value: TdxBarUserDefines); procedure ExcludeProperty(AProperty: TdxBarUserDefine); begin Exclude(FUserDefine, AProperty); case AProperty of udCaption: FUserCaption := ''; udGlyph: FUserGlyph.Assign(nil); udPaintStyle: FUserPaintStyle := psStandard; udWidth: FUserWidth := 0; end; end; function CheckChanges(AProperty: TdxBarUserDefine): Boolean; begin Result := True; if (AProperty in FUserDefine) and not(AProperty in Value) then ExcludeProperty(AProperty) else if not(AProperty in FUserDefine) and (AProperty in Value) then Include(FUserDefine, AProperty) else Result := False; end; procedure PropertyChanged(AProperty: TdxBarUserDefine); begin if Control <> nil then case AProperty of udCaption: Control.CaptionChanged; udGlyph: Control.GlyphChanged; udPaintStyle: Control.PaintStyleChanged; udWidth: Control.WidthChanged; end; end; var AProperty: TdxBarUserDefine; begin if FUserDefine <> Value then begin for AProperty := Low(TdxBarUserDefine) to High(TdxBarUserDefine) do if CheckChanges(AProperty) then PropertyChanged(AProperty); Changed(False); //#DG end; end; procedure TdxBarItemLink.SetUserCaption(const Value: string); begin if FUserCaption <> Value then begin FUserCaption := Value; ForceSetUserDefine(udCaption); end; end; procedure TdxBarItemLink.SetUserGlyph(Value: TBitmap); begin if FUserGlyph <> Value then begin FUserGlyph.Assign(Value); ForceSetUserDefine(udGlyph); end; end; procedure TdxBarItemLink.SetUserPaintStyle(Value: TdxBarPaintStyle); begin if PaintStyle <> Value then begin FUserPaintStyle := Value; ForceSetUserDefine(udPaintStyle); end; end; procedure TdxBarItemLink.SetUserWidth(Value: Integer); begin if Width <> Value then begin FUserWidth := Value; ForceSetUserDefine(udWidth); end; end; procedure TdxBarItemLink.SetViewLevels(Value: TdxBarItemViewLevels); begin if Value <> FViewLevels then begin FViewLevels := Value; Changed(True); end; end; procedure TdxBarItemLink.SetVisible(Value: Boolean); begin if BarManager.IsLoading or Owner.FAssigning then begin FLoadedVisible := Value; Exit; end; if FVisible <> Value then begin FVisible := Value; if not BarManager.Designing then begin Owner.RefreshVisibilityLists; if Value then begin BringToTopInRecentList(False); if BarControl <> nil then begin CreateControl; Control.VisibleChanged; end; end else begin SendToBottomInRecentList; if Control <> nil then begin Control.VisibleChanged; DestroyControl; end; end; end; Changed(False); //#DG //#DG ItemLinkChanged; end; end; procedure TdxBarItemLink.WriteItemName(AWriter: TWriter); begin if Item <> nil then AWriter.WriteString(Item.Name) else AWriter.WriteString(''); end; procedure TdxBarItemLink.AddToRecentList; begin Owner.FRecentItems.Add(Self); end; procedure TdxBarItemLink.RemoveFromRecentList; begin with Owner do if FRecentItems <> nil then FRecentItems.Remove(Self); end; procedure TdxBarItemLink.RestoreRecentIndex; begin RecentIndex := FPrevRecentIndex; end; procedure TdxBarItemLink.SaveRecentIndex; begin FPrevRecentIndex := RecentIndex; end; procedure TdxBarItemLink.InternalBringToTopInRecentList(IncCount: Boolean); begin if (Owner <> nil) and not Owner.CanUseRecentItems then Exit; RecentIndex := 0; if IncCount then Inc(FUseCount); end; procedure TdxBarItemLink.Synchronize(AItemLink: TdxBarItemLink); begin FUseCount := AItemLink.FUseCount; RecentIndex := AItemLink.RecentIndex; end; procedure TdxBarItemLink.CheckMostRecentlyUsed; begin if MostRecentlyUsed then begin FUseCount := BarManager.FMostRecentlyUsedUseCount; BringToTopInRecentList(False); end else begin FUseCount := 0; SendToBottomInRecentList; end end; function TdxBarItemLink.GetRecentIndex: Integer; begin Result := Owner.FRecentItems.IndexOf(Self); end; procedure TdxBarItemLink.SetRecentIndex(Value: Integer); begin if Owner = nil then FPrevRecentIndex := Value else with Owner, FRecentItems do begin if Value >= Count then Value := Count - 1; Move(IndexOf(Self), Value); RefreshVisibilityLists; end; end; function TdxBarItemLink.CanVisible: Boolean; begin Result := Item.ActuallyVisible and Visible; end; function TdxBarItemLink.GetItem: TdxBarItem; begin if (Owner <> nil) and (Owner.Owner <> nil) and (FLoadedItemName <> '') and IsAncestorComponentDifferencesDetection(Owner.Owner) then Result := BarManager.GetItemByName(FLoadedItemName) else Result := FItem; end; function TdxBarItemLink.GetRealItemLink: TdxBarItemLink; begin if FOriginalItemLink <> nil then Result := FOriginalItemLink else Result := Self end; procedure TdxBarItemLink.OnUserGlyphChanged(Sender: TObject); begin UserGlyphChanged; end; procedure TdxBarItemLink.DefineProperties(Filer: TFiler); function NeedWriteItemName: Boolean; var AAncestorItem: TdxBarItem; begin if Filer.Ancestor is TdxBarItemLink then begin AAncestorItem := TdxBarItemLink(Filer.Ancestor).Item; Result := (AAncestorItem = nil) and (Item <> nil) or (AAncestorItem <> nil) and (Item = nil) or (AAncestorItem <> nil) and (AAncestorItem.Name <> Item.Name); end else Result := Item <> nil; end; begin inherited DefineProperties(Filer); Filer.DefineProperty('ItemName', ReadItemName, WriteItemName, NeedWriteItemName); end; procedure TdxBarItemLink.LoadItemName; begin if FLoadedItemName <> '' then begin Item := BarManager.GetItemByName(FLoadedItemName); FLoadedItemName := ''; end; end; class function TdxBarItemLink.GetIniSection(const ABaseSection: string; ALinkIndex: Integer; AStoringKind: TdxBarStoringKind): string; begin Result := ABaseSection + GetSectionDelimiter(AStoringKind) + 'ItemLink' + IntToStr(ALinkIndex); end; procedure TdxBarItemLink.LoadFromIni(ASource: TCustomIniFile; const ABaseSection: string; ALinkIndex: Integer; AStoringKind: TdxBarStoringKind); {$IFNDEF DELPHI6} function ReadBinaryStream(const ASection, AName: string; AValue: TMemoryStream): Integer; var Info: TRegDataInfo; Text: string; Pos: Integer; begin Result := 0; case AStoringKind of skReg: with TRegistryIniFile(ASource) do if RegIniFile.OpenKey(ASection, False) then try if RegIniFile.ValueExists(AName) then begin if RegIniFile.GetDataInfo(AName, Info) then begin if (Info.RegData = rdBinary) or (Info.RegData = rdUnknown) then begin AValue.Size := AValue.Position + Info.DataSize; Result := RegIniFile.ReadBinaryData(AName, Pointer(Integer(AValue.Memory) + AValue.Position)^, AValue.Size); end; end; end; finally RegIniFile.CloseKey; end; skIni: with ASource do begin Text := ReadString(ASection, AName, ''); if Text <> '' then begin Pos := AValue.Position; AValue.SetSize(AValue.Size + Length(Text) div 2); HexToBin(PChar(Text), PChar(Integer(AValue.Memory) + AValue.Position), Length(Text) div 2); AValue.Position := Pos; Result := AValue.Size - Pos; end end; end; end; {$ENDIF} var ASection: string; AStream: TMemoryStream; AViewLevels: TdxBarItemViewLevels; begin ASection := GetIniSection(ABaseSection, ALinkIndex, AStoringKind); if ASource.ReadString(ASection, 'ItemName', '') = '' then Exit; Item := BarManager.GetItemByName(ASource.ReadString(ASection, 'ItemName', '')); if Item = nil then Free else with ASource do begin AStream := TMemoryStream.Create; try BeginGroup := ReadBool(ASection, 'BeginGroup', False); if ReadBinaryStream(ASection, 'UserDefine', AStream) <> 0 then begin AStream.Read(FUserDefine, SizeOf(TdxBarUserDefines)); AStream.Position := 0; end; if udCaption in UserDefine then UserCaption := ReadString(ASection, 'UserCaption', ''); if udPaintStyle in UserDefine then UserPaintStyle := TdxBarPaintStyle(ReadInteger(ASection, 'UserPaintStyle', 0)); if udWidth in UserDefine then UserWidth := ReadInteger(ASection, 'UserWidth', 100); // don't load UserGlyph for IniFile if (AStoringKind = skReg) and (udGlyph in UserDefine) then begin if ReadBinaryStream(ASection, 'UserGlyph', AStream) <> 0 then begin UserGlyph.LoadFromStream(AStream); AStream.Position := 0; end; end; if Collection.Owner is TdxBar then begin // ButtonGroup := TdxBarButtonGroupPosition(ReadInteger(ASection, 'ButtonGroup', Integer(bgpNone))); Position := TdxBarItemPosition(ReadInteger(ASection, 'Position', Integer(dxBarItemDefaultPosition))); if ReadBinaryStream(ASection, 'ViewLevels', AStream) <> 0 then begin AStream.Read(AViewLevels, SizeOf(TdxBarItemViewLevels)); AStream.Position := 0; ViewLevels := AViewLevels; end; FLoadedVisible := ReadBool(ASection, 'Visible', True); end; if BarManager.CanShowRecentItems and TdxBarItemLinks(Collection).FUseRecentItems then begin FLoadedUseCount := ReadInteger(ASection, 'UseCount', 0); FLoadedRecentIndex := ReadInteger(ASection, 'RecentIndex', -1); end; finally AStream.Free; end; end; end; procedure TdxBarItemLink.LoadUsageData(ASource: TCustomIniFile; ABaseSection: string; ALinkIndex: Integer); begin FMostRecentlyUsed := ASource.ReadBool( GetIniSection(ABaseSection, ALinkIndex, skIni), 'MostRecentlyUsed', True); end; procedure TdxBarItemLink.SaveToIni(ADestination: TCustomIniFile; const ABaseSection: string; ALinkIndex: Integer; AStoringKind: TdxBarStoringKind); {$IFNDEF DELPHI6} procedure WriteBinaryStream(const Section, Name: string; AValue: TMemoryStream); var Text: string; begin case AStoringKind of skReg: with TRegistryIniFile(ADestination) do with RegIniFile do begin if OpenKey(Section, True) then try WriteBinaryData(Name, Pointer(Integer(AValue.Memory) + AValue.Position)^, AValue.Size - AValue.Position); finally CloseKey; end; end; skIni: with ADestination do begin SetLength(Text, (AValue.Size - AValue.Position) * 2); if Length(Text) > 0 then BinToHex(PChar(Integer(AValue.Memory) + AValue.Position), PChar(Text), AValue.Size - AValue.Position); WriteString(Section, Name, Text); end; end; end; {$ENDIF} var AStream: TMemoryStream; ASection: string; begin with ADestination do begin ASection := GetIniSection(ABaseSection, ALinkIndex, AStoringKind); AStream := TMemoryStream.Create; try WriteString(ASection, 'ItemName', Item.Name); WriteBool(ASection, 'BeginGroup', BeginGroup); AStream.SetSize(SizeOf(TdxBarUserDefines)); AStream.Write(FUserDefine, SizeOf(TdxBarUserDefines)); AStream.Position := 0; WriteBinaryStream(ASection, 'UserDefine', AStream); if udCaption in UserDefine then WriteString(ASection, 'UserCaption', UserCaption); if udPaintStyle in UserDefine then WriteInteger(ASection, 'UserPaintStyle', Ord(UserPaintStyle)); if udWidth in UserDefine then WriteInteger(ASection, 'UserWidth', UserWidth); // don't save UserGlyph to IniFile if (AStoringKind = skReg) and (udGlyph in UserDefine) then begin UserGlyph.SaveToStream(AStream); AStream.Position := 0; WriteBinaryStream(ASection, 'UserGlyph', AStream); end; if Collection.Owner is TdxBar then begin // WriteInteger(ASection, 'ButtonGroup', Ord(ButtonGroup)); WriteInteger(ASection, 'Position', Ord(Position)); AStream.SetSize(SizeOf(TdxBarItemViewLevels)); AStream.Write(ViewLevels, SizeOf(TdxBarItemViewLevels)); AStream.Position := 0; WriteBinaryStream(ASection, 'ViewLevels', AStream); WriteBool(ASection, 'Visible', Visible); end; if BarManager.CanShowRecentItems and TdxBarItemLinks(Collection).FUseRecentItems then begin WriteInteger(ASection, 'UseCount', FUseCount); WriteInteger(ASection, 'RecentIndex', RecentIndex); end; if BarManager.IsStateSaving then WriteBool(ASection, 'MostRecentlyUsed', MostRecentlyUsed); finally AStream.Free; end; end; end; procedure TdxBarItemLink.InitiateAction; begin if (Item <> nil) and (Item.ActionLink <> nil) then Item.ActionLink.Update; end; function TdxBarItemLink.CanChangePaintStyle: Boolean; begin Result := Item.CanChangePaintStyle; end; function TdxBarItemLink.HasItem(AItem: TdxBarItem): Boolean; begin Result := FItem = AItem; if not Result and (FItem is TCustomdxBarSubItem) then Result := TCustomdxBarSubItem(FItem).ItemLinks.HasItem(AItem); end; function TdxBarItemLink.IsReferencedBy(ALinksOwner: IdxBarLinksOwner): Boolean; var ASelfLinksOwner: IdxBarLinksOwner; begin ASelfLinksOwner := GetLinksOwner(FItem); Result := (ASelfLinksOwner <> nil) and ((ASelfLinksOwner = ALinksOwner) or (ASelfLinksOwner.GetItemLinks <> nil) and (ASelfLinksOwner.GetItemLinks.IsReferencedBy(ALinksOwner))); end; function TdxBarItemLink.IsAccel(Key: Word; Shift: TShiftState): Boolean; var Accel: Char; VK: SHORT; AShift: TShiftState; function GetAccel(S: string): Char; var APos: Integer; begin APos := GetAccelPos(S); if APos = 0 then Result := #0 else begin Result := AnsiLowerCase(S[APos])[1]; if Result <> S[APos] then Shift := Shift - [ssShift]; end; end; begin Accel := GetAccel(Caption); if Accel = #0 then Result := False else if (Accel in ['0'..'9']) and (Key = Ord(Accel)) and (Shift = []) then Result := True else begin VK := VkKeyScan(Accel); if Lo(VK) = Key then begin VK := Hi(VK); AShift := []; if VK and 1 = 1 then Include(AShift, ssShift); if VK and 2 = 2 then Include(AShift, ssCtrl); Result := AShift = Shift; end else Result := False; end; end; procedure TdxBarItemLink.MoveBeginGroupItemIfNeeded; var ANextItemLink: TdxBarItemLink; begin if (Item <> nil) and (CanVisibleIndex < Owner.CanVisibleItemCount - 1) and ((CanVisibleIndex = 0) and Owner.CanVisibleItems[CanVisibleIndex + 1].BeginGroup or BeginGroup and not Owner.CanVisibleItems[CanVisibleIndex + 1].BeginGroup) then begin ANextItemLink := Owner.CanVisibleItems[CanVisibleIndex + 1]; ANextItemLink.BeginGroup := not ANextItemLink.BeginGroup; end; end; function TdxBarItemLink.ScreenToClient(const AScreenPos: TPoint): TPoint; begin Result := AScreenPos; Windows.ScreenToClient(BarControl.Handle, Result); Dec(Result.X, ItemRect.Left); Dec(Result.Y, ItemRect.Top); end; procedure TdxBarItemLink.UserGlyphChanged; begin if Control <> nil then Control.GlyphChanged; end; function TdxBarItemLink.QueryInterface(const IID: TGUID; out Obj): HResult; begin if GetInterface(IID, Obj) then Result := 0 else Result := E_NOINTERFACE; end; function TdxBarItemLink._AddRef: Integer; begin Result := InterlockedIncrement(FRefCount); end; function TdxBarItemLink._Release: Integer; begin Result := InterlockedDecrement(FRefCount); end; function TdxBarItemLink.CanDelete(ADestruction: Boolean = False): Boolean; begin Result := True; end; procedure TdxBarItemLink.DeleteSelection(var AReference: IdxBarSelectableItem; ADestruction: Boolean); begin if CanDelete(ADestruction) then begin AReference := nil; Free; end; end; procedure TdxBarItemLink.ExecuteCustomizationAction(ABasicAction: TdxBarCustomizationAction); begin case ABasicAction of caReset: UserDefine := []; caChangeCaption: Item.Caption := BarDesignController.CustomizingItemLink.Caption; caChangeButtonPaintStyle: UserPaintStyle := BarDesignController.CustomizingItemLink.UserPaintStyle; caChangePosition: Position := BarDesignController.CustomizingItemLink.Position; caChangeViewLevels: ViewLevels := BarDesignController.CustomizingItemLink.ViewLevels; caChangeButtonGroup: ButtonGroup := BarDesignController.CustomizingItemLink.ButtonGroup; caChangeBeginGroup: BeginGroup := BarDesignController.CustomizingItemLink.BeginGroup; caChangeVisible: Visible := BarDesignController.CustomizingItemLink.Visible; caChangeRecentList: MostRecentlyUsed := BarDesignController.CustomizingItemLink.MostRecentlyUsed; end; end; function TdxBarItemLink.GetBarManager: TdxBarManager; begin Result := Owner.BarManager; end; function TdxBarItemLink.GetInstance: TPersistent; begin Result := Self; end; procedure TdxBarItemLink.GetMasterObjects(AList: TdxObjectList); begin AList.Add(BarControl.GetSelectableObject); AList.Add(FItem); end; function TdxBarItemLink.GetNextSelectableItem: IdxBarSelectableItem; begin Result := GetNext; end; function TdxBarItemLink.GetSelectableParent: TPersistent; begin if BarControl <> nil then Result := BarControl.GetSelectableObject else Result := nil; end; function TdxBarItemLink.GetSelectionStatus: TdxBarSelectionStatus; begin Result := BarManager.GetSelectionStatus(Self); end; function TdxBarItemLink.GetSupportedActions: TdxBarCustomizationActions; begin Result := Item.GetSupportedActions; end; procedure TdxBarItemLink.Invalidate; begin RepaintItemControl(Control); end; function TdxBarItemLink.IsComplex: Boolean; begin Result := False; end; function TdxBarItemLink.IsComponentSelected: Boolean; begin Result := BarManager.IsComponentSelected(Self) or BarManager.IsComponentSelected(Item); end; procedure TdxBarItemLink.SelectComponent(ASelectionOperation: TdxBarSelectionOperation = soExclusive); begin if ASelectionOperation = soExclude then BarManager.SelectComponent(Self, ASelectionOperation); BarManager.SelectComponent(Item, ASelectionOperation); end; function TdxBarItemLink.SelectParentComponent: Boolean; begin Result := True; BarManager.FSelectedItem := nil; // otherwise HideAll will be executed BarControl.SetKeySelectedItem(nil); BarManager.SelectComponent(GetSelectableParent); end; procedure TdxBarItemLink.SelectionChanged; begin Item.SelectionChanged; end; procedure TdxBarItemLink.Assign(Source: TPersistent); function IsInheritanceUpdating: Boolean; begin //#DG TODO: LinksOwner Result := (csUpdating in BarManager.ComponentState) or ((Owner.Owner is TdxBarCustomPopupMenu) or (Owner.Owner is TCustomdxBarSubItem) or (Owner.Owner is TdxBar)) and (csUpdating in TComponent(Owner.Owner).ComponentState); end; var Link: TdxBarItemLink; begin if Source is TdxBarItemLink then begin Link := TdxBarItemLink(Source); Data := Link.Data; FUserCaption := Link.FUserCaption; FUserGlyph.Assign(Link.FUserGlyph); FUserPaintStyle := Link.FUserPaintStyle; FUserWidth := Link.FUserWidth; if ResettingToolbar then Item := TdxBarItem(BarManager.Owner.FindComponent(Link.Item.Name)) else begin if Assigned(Link.Item) and IsInheritanceUpdating then Item := BarManager.GetItemByName(Link.Item.Name) else Item := Link.Item; end; UserDefine := Link.UserDefine; BeginGroup := Link.BeginGroup; ButtonGroup := Link.ButtonGroup; Position := Link.Position; ViewLevels := Link.ViewLevels; Visible := Link.Visible; // do not assign MostRecentlyUsed property FCreatedFromMergingWith := FMergingWith; end else inherited Assign(Source); end; procedure TdxBarItemLink.BringToTopInRecentList(IncCount: Boolean); var PrevVisibleIndex: Integer; AParentItem: TdxBarItem; begin if not CanVisible then Exit; PrevVisibleIndex := VisibleIndex; InternalBringToTopInRecentList(IncCount); if CanVisibleIndex > -1 then begin if (PrevVisibleIndex = -1) and (BarControl <> nil) then BarControl.LayoutChanged; AParentItem := nil; with Owner do if Owner is TCustomdxBarSubItem then AParentItem := TCustomdxBarSubItem(Owner) else if Owner is TdxBarCustomPopupMenu then if (BarControl <> nil) and (TdxBarSubMenuControl(BarControl).FDropDownButton <> nil) then AParentItem := TdxBarSubMenuControl(BarControl).FDropDownButton.Item; if AParentItem <> nil then with AParentItem do if (CurItemLink <> nil) and (CurItemLink.RealItemLink <> nil) then CurItemLink.RealItemLink.BringToTopInRecentList(IncCount); end; end; procedure TdxBarItemLink.CreateControl; begin if (FControl = nil) and (Item <> nil) and //#DG (BarControl <> nil) and not BarControl.FDestroyFlag then (BarControl <> nil) and not BarControl.IsDestroying then FControl := Item.GetControlClass(BarControl.IsVertical).Create(Self); end; procedure TdxBarItemLink.DestroyControl; begin FreeAndNil(FControl); end; procedure TdxBarItemLink.SendToBottomInRecentList; var PrevVisibleIndex: Integer; begin PrevVisibleIndex := VisibleIndex; RecentIndex := Owner.FRecentItems.Count - 1; if (PrevVisibleIndex > -1) and (BarControl <> nil) then BarControl.LayoutChanged; end; { TdxBarItemLinks } constructor TdxBarItemLinks.Create(ABarManager: TdxBarManager; ALinksOwner: IdxBarLinksOwner); begin inherited Create(TdxBarItemLink); FBarManager := ABarManager; FLinksOwner := ALinksOwner; FAvailableItems := TList.Create; FCanVisibleItems := TList.Create; FVisibleItems := TList.Create; FRecentItems := TList.Create; FRecentItemCount := -1; FUseRecentItems := True; FItemOptions := TdxBarItemOptions.Create(Self); end; destructor TdxBarItemLinks.Destroy; begin FreeAndNil(FItemOptions); if (FBarControl <> nil) and not FBarControl.IsDestroying then FreeAndNil(FBarControl); FreeAndNil(FRecentItems); FreeAndNil(FVisibleItems); FreeAndNil(FCanVisibleItems); FreeAndNil(FAvailableItems); inherited; end; procedure TdxBarItemLinks.DesignerModified; begin if Owner is TdxBarCustomPopupMenu then TdxBarCustomPopupMenu(Owner).OwnerDesignerModified else BarManager.DesignerModified; end; function TdxBarItemLinks.GetAvailableItem(Index: Integer): TdxBarItemLink; begin Result := TdxBarItemLink(FAvailableItems[Index]); end; function TdxBarItemLinks.GetAvailableItemCount: Integer; begin Result := FAvailableItems.Count; end; function TdxBarItemLinks.GetCanVisibleItem(Index: Integer): TdxBarItemLink; begin Result := TdxBarItemLink(FCanVisibleItems[Index]); end; function TdxBarItemLinks.GetCanVisibleItemCount: Integer; begin Result := FCanVisibleItems.Count; end; function TdxBarItemLinks.GetIndexByItemName(const AItemName: string): Integer; var I: Integer; begin Result := -1; for I := 0 to Count - 1 do if Items[I].Item.Name = AItemName then begin Result := I; Break; end; end; function TdxBarItemLinks.GetItem(Index: Integer): TdxBarItemLink; begin Result := TdxBarItemLink(inherited Items[Index]); end; function TdxBarItemLinks.GetMostRecentItemCount: Integer; var AMinCount, AMaxCount, I, Level: Integer; begin if CanUseRecentItems then begin AMinCount := MaxInt; AMaxCount := 0; for I := 0 to CanVisibleItemCount - 1 do begin AMinCount := Min(AMinCount, CanVisibleItems[I].FUseCount); AMaxCount := Max(AMaxCount, CanVisibleItems[I].FUseCount); end; Level := AMinCount + MulDiv(AMaxCount - AMinCount, 100 - BarManager.MostRecentItemsPercents, 100); Result := 0; for I := CanVisibleItemCount - 1 downto 0 do with TdxBarItemLink(FRecentItems[I]) do if (FUseCount >= Level) and (Owner = Self) then begin Result := I + 1; Break; end; if Result = CanVisibleItemCount then Result := -1; end else Result := -1; end; function TdxBarItemLinks.GetParentLinks: TdxBarItemLinks; begin if (BarControl <> nil) and (BarControl.ParentBar <> nil) then Result := BarControl.ParentBar.ItemLinks else Result := nil; end; function TdxBarItemLinks.GetRealVisibleItemCount: Integer; var R, AItemRect, ResultR: TRect; I: Integer; begin Result := VisibleItemCount; if not IsScrollable then begin R := BarControl.ClientRect; for I := 0 to Result - 1 do begin AItemRect := VisibleItems[I].ItemRect; IntersectRect(ResultR, R, AItemRect); if not EqualRect(AItemRect, ResultR) or IsRectEmpty(AItemRect) then begin Result := I; Break; end; end; end; end; function TdxBarItemLinks.GetItemShowDescriptions: Boolean; begin Result := GetOptionsValue(ioShowDescriptions, Self); end; function TdxBarItemLinks.GetItemShowShortCuts: Boolean; begin Result := GetOptionsValue(ioShowShortCuts, Self); end; function TdxBarItemLinks.GetItemSize: TdxBarMenuItemSize; begin Result := GetOptionsValue(ioSize, Self); end; function TdxBarItemLinks.GetVisibleItem(Index: Integer): TdxBarItemLink; begin Result := TdxBarItemLink(FVisibleItems[Index]); end; function TdxBarItemLinks.GetVisibleItemCount: Integer; begin Result := FVisibleItems.Count; end; procedure TdxBarItemLinks.SetItem(Index: Integer; Value: TdxBarItemLink); begin Items[Index].Assign(Value); end; procedure TdxBarItemLinks.SetItemOptions(AValue: TdxBarItemOptions); begin FItemOptions.Assign(AValue); end; procedure TdxBarItemLinks.SetRecentItemCount(Value: Integer); begin FPrevRecentItemCount := FRecentItemCount; if not CanUseRecentItems then Value := -1; FRecentItemCount := Value; RefreshVisibilityLists; end; function VisibleItemsCompare(Item1, Item2: Pointer): Integer; begin if TdxBarItemLink(Item1).CanVisibleIndex < TdxBarItemLink(Item2).CanVisibleIndex then Result := -1 else if TdxBarItemLink(Item1).CanVisibleIndex > TdxBarItemLink(Item2).CanVisibleIndex then Result := 1 else Result := 0; end; function TdxBarItemLinks.IsUpdateLocked: Boolean; begin Result := UpdateCount > 0; end; procedure TdxBarItemLinks.RefreshVisibilityLists; procedure InternalRefreshVisibilityLists; var AIsDesignTime: Boolean; I: Integer; AItemLink: TdxBarItemLink; AItem: TdxBarItem; begin if FAvailableItems = nil then Exit; FAvailableItems.Clear; FCanVisibleItems.Clear; FVisibleItems.Clear; AIsDesignTime := BarManager.Designing; for I := 0 to Count - 1 do begin AItemLink := Items[I]; AItem := AItemLink.Item; if (AItem <> nil) and ({Item.AlwaysVisible or }AIsDesignTime or AItem.ActuallyVisible) then begin FAvailableItems.Add(AItemLink); if {Item.AlwaysVisible or }AIsDesignTime or AItemLink.Visible then begin FCanVisibleItems.Add(AItemLink); if {Item.AlwaysVisible or }AIsDesignTime or (RecentItemCount = -1) then FVisibleItems.Add(AItemLink); end; end; end; if not AIsDesignTime and (RecentItemCount > 0) then begin for I := 0 to FRecentItems.Count - 1 do if CanVisibleIndexOf(FRecentItems[I]) <> -1 then begin FVisibleItems.Add(FRecentItems[I]); if FVisibleItems.Count = RecentItemCount then Break; end; FVisibleItems.Sort(VisibleItemsCompare); end; end; procedure RefreshSeparatorsVisibility; function IsSeparator(ALink: TObject): Boolean; begin Result := TdxBarItemLink(ALink).Item is TdxBarSeparator; end; procedure HideSeparator(ALink: TdxBarItemLink); begin FCanVisibleItems.Remove(Alink); FVisibleItems.Remove(ALink); end; var I: Integer; APrevIsSeparator, ACurrentIsSeparator: Boolean; begin APrevIsSeparator := True; for I := FVisibleItems.Count - 1 downto 0 do begin ACurrentIsSeparator := IsSeparator(FVisibleItems[I]); if ACurrentIsSeparator and APrevIsSeparator then HideSeparator(FVisibleItems[I]); APrevIsSeparator := ACurrentIsSeparator; end; end; begin InternalRefreshVisibilityLists; if not BarManager.IsCustomizing and not IsUpdateLocked then RefreshSeparatorsVisibility; end; procedure TdxBarItemLinks.RestoreRecentItemCount; begin FRecentItemCount := FPrevRecentItemCount; RefreshVisibilityLists; end; procedure TdxBarItemLinks.Loaded(CheckVisible: Boolean); var J, I: Integer; begin for J := Count - 1 downto 0 do with Items[J] do if Item = nil then //Free else CheckMostRecentlyUsed; if CheckVisible then for J := Count - 1 downto 0 do with Items[J] do Visible := FLoadedVisible; for I := 0 to Count - 1 do for J := 0 to Count - 1 do with Items[J] do if FLoadedRecentIndex = I then begin FUseCount := FLoadedUseCount; RecentIndex := FLoadedRecentIndex; FLoadedRecentIndex := -1; end; if FBarControl <> nil then FBarControl.CreateControls; end; procedure TdxBarItemLinks.CheckVisibleIntegrity; var I, J: Integer; ItemLink: TdxBarItemLink; begin for I := 0 to FRecentItems.Count - 1 do begin ItemLink := TdxBarItemLink(FRecentItems[I]); if ItemLink.CanVisibleIndex = -1 then Break; end; for J := I + 1 to FRecentItems.Count - 1 do begin ItemLink := TdxBarItemLink(FRecentItems[J]); if ItemLink.CanVisibleIndex > -1 then begin ItemLink.RecentIndex := I; Inc(I); end; end; end; procedure TdxBarItemLinks.EmptyItemRects; var I: Integer; begin for I := 0 to Count - 1 do SetRectEmpty(Items[I].FItemRect); end; function TdxBarItemLinks.CanUseRecentItems: Boolean; begin Result := BarManager.CanShowRecentItems and FUseRecentItems and ((ParentLinks = nil) or (ParentLinks.CanUseRecentItems)); end; procedure TdxBarItemLinks.InitiateActions; var I: Integer; begin for I := 0 to Count - 1 do Items[I].InitiateAction; end; function TdxBarItemLinks.IsShortCut(AShortCut: TShortCut): Boolean; var I: Integer; AItemLink: TdxBarItemLink; begin Result := False; if AShortCut = 0 then Exit; InitiateActions; for I := 0 to AvailableItemCount - 1 do begin AItemLink := AvailableItems[I]; if not AItemLink.Item.Enabled then Continue; if AItemLink.Item is TCustomdxBarSubItem then Result := TCustomdxBarSubItem(AItemLink.Item).IsShortCut(AShortCut) else begin if not AItemLink.Item.CanClicked then Continue; Result := AItemLink.Item.ShortCut = AShortCut; if Result then AItemLink.Item.Click else if AItemLink.Item is TdxBarButton then with TdxBarButton(AItemLink.Item) do if (bstDropDown in FInternalStates) and (DropDownMenu <> nil) then Result := DropDownMenu.IsShortCut(AShortCut); end; if Result then Break; end; end; function TdxBarItemLinks.IsScrollable: Boolean; begin Result := not (Owner is TdxBar); end; function TdxBarItemLinks.FindItemWithAccel(AKey: Word; AShift: TShiftState; ACurrentLink: TdxBarItemLink): TdxBarItemLink; begin AShift := AShift - [ssAlt]; Result := DoFindItemWithAccel(AKey, AShift, ACurrentLink); end; function TdxBarItemLinks.First: TdxBarItemLink; var I: Integer; begin for I := 0 to RealVisibleItemCount - 1 do begin Result := VisibleItems[I]; if Result.Control.CanSelect then Exit; end; Result := nil; end; function TdxBarItemLinks.Last: TdxBarItemLink; var I: Integer; begin for I := RealVisibleItemCount - 1 downto 0 do begin Result := VisibleItems[I]; if Result.Control.CanSelect then Exit; end; Result := nil; end; function TdxBarItemLinks.Next(Current: TdxBarItemLink; AAnyone: Boolean = False): TdxBarItemLink; var CurrentIndex, I, ACount: Integer; begin if Current = nil then Result := First else begin CurrentIndex := Current.VisibleIndex; I := CurrentIndex; ACount := RealVisibleItemCount; repeat Inc(I); if I > ACount - 1 then I := 0; Result := VisibleItems[I]; if AAnyone or Result.Control.CanSelect then Exit; until I = CurrentIndex; Result := nil; end; end; function TdxBarItemLinks.Prev(Current: TdxBarItemLink; AAnyone: Boolean = False): TdxBarItemLink; var CurrentIndex, I: Integer; begin if Current = nil then Result := Last else begin CurrentIndex := Current.VisibleIndex; I := CurrentIndex; repeat Dec(I); if I = -1 then I := RealVisibleItemCount - 1; Result := VisibleItems[I]; if AAnyone or Result.Control.CanSelect then Exit; until I = CurrentIndex; Result := nil; end; end; procedure TdxBarItemLinks.CheckLinks(ASource: TCustomIniFile; const ABaseSection: string); var I: Integer; begin for I := 0 to Count - 1 do Items[I].Item.CheckLinks(ASource, ABaseSection); end; procedure TdxBarItemLinks.LoadFromIni(ASource: TCustomIniFile; const ASection: string; AStoringKind: TdxBarStoringKind); var I, ACount, ANewItemLinkCount: Integer; begin BeginUpdate; //#DG try ANewItemLinkCount := 0; if (BarManager.FNewItems = nil) or (BarManager.FNewItems.Count = 0) then Clear else for I := Count - 1 downto 0 do if BarManager.FNewItems.IndexOf(Items[I].Item.Name) < 0 then Delete(I) else begin Items[I].FCreatedFromMergingWith := nil; Inc(ANewItemLinkCount); if I > 0 then Items[I].FPrevItemName := Items[I - 1].Item.Name; end; try ACount := ASource.ReadInteger(ASection, 'ItemLinkCount', 0); for I := ACount - 1 downto 0 do Insert(0).LoadFromIni(ASource, ASection, I, AStoringKind); for I := Count - ANewItemLinkCount to Count - 1 do if Items[I].FPrevItemName = '' then Move(I, 0) else if GetIndexByItemName(Items[I].FPrevItemName) > 0 then Move(I, GetIndexByItemName(Items[I].FPrevItemName) + 1); RefreshVisibilityLists; finally Loaded(True); end; finally EndUpdate; end; end; procedure TdxBarItemLinks.LoadUsageData(ASource: TCustomIniFile; ASection: string); var ALinkCount, I: Integer; begin // TODO search by unique ID, check merging ALinkCount := ASource.ReadInteger(ASection, 'ItemLinkCount', 0); for I := 0 to Count - 1 do if I < ALinkCount then Items[I].LoadUsageData(ASource, ASection, I); Loaded(False); CheckVisibleIntegrity; end; procedure TdxBarItemLinks.SaveToIni(ADestination: TCustomIniFile; const ASection: string; AStoringKind: TdxBarStoringKind); var I, ACount: Integer; begin ACount := 0; for I := 0 to Count - 1 do if (Items[I].Item <> nil) and (Items[I].Item.Name <> '') and (Items[I].FCreatedFromMergingWith = nil) then begin Items[I].SaveToIni(ADestination, ASection, ACount, AStoringKind); Inc(ACount); end; ADestination.WriteInteger(ASection, 'ItemLinkCount', ACount); end; procedure TdxBarItemLinks.Merge(AItemLinks: TdxBarItemLinks); procedure CheckMergeOperationParameters(AMergingLink: TdxBarItemLink; var AKind: TdxBarItemMergeKind; var ALinkIndex: Integer); begin if ALinkIndex < 0 then AKind := mkNone; if (AKind = mkMergeByCaption) and ((ALinkIndex >= Count) or not Items[ALinkIndex].Item.CanMergeWith(AMergingLink.Item)) then AKind := mkNone; if (AKind = mkAdd) and (ALinkIndex > Count) then AKind := mkNone; end; procedure GetMergeOperationParameters(AMergingLink: TdxBarItemLink; out AKind: TdxBarItemMergeKind; out ALinkIndex: Integer); var AItem: TdxBarItem; I: Integer; begin ALinkIndex := -1; AKind := AMergingLink.Item.MergeKind; if AKind <> mkNone then begin if AMergingLink.Item.MergeKind = mkMergeByCaption then for I := 0 to Count - 1 do if (Items[I].Item.MergeKind = mkMergeByCaption) and (Items[I].Caption = AMergingLink.Caption) and // TODO Accel chars Items[I].Item.CanMergeWith(AMergingLink.Item) then ALinkIndex := I; if ALinkIndex <> -1 then AKind := mkMergeByCaption else begin for I := 0 to Count - 1 do begin AItem := Items[I].Item; if AItem.MergeOrder <= AMergingLink.Item.MergeOrder then if (ALinkIndex = -1) or (AItem.MergeOrder >= Items[ALinkIndex].Item.MergeOrder) then ALinkIndex := I; end; Inc(ALinkIndex); AKind := mkAdd; end; end; BarManager.DoMergeItemLink(Self, AItemLinks, AMergingLink, AKind, ALinkIndex); CheckMergeOperationParameters(AMergingLink, AKind, ALinkIndex); end; var AItemLink: TdxBarItemLink; AMergeKind: TdxBarItemMergeKind; AMergeLinkIndex, I: Integer; begin for I := 0 to AItemLinks.Count - 1 do begin GetMergeOperationParameters(AItemLinks[I], AMergeKind, AMergeLinkIndex); if AMergeKind = mkMergeByCaption then Items[AMergeLinkIndex].Item.GetItemLinks.Merge( AItemLinks[I].Item.GetItemLinks) else if AMergeKind = mkAdd then begin AItemLink := Insert(AMergeLinkIndex); AItemLink.Assign(AItemLinks[I]); end; end; end; procedure TdxBarItemLinks.Unmerge(ABar: TdxBar); var AItemLink: TdxBarItemLink; I: Integer; begin for I := Count - 1 downto 0 do begin AItemLink := Items[I]; if (AItemLink.FCreatedFromMergingWith <> nil) and ((ABar = nil) or (AItemLink.FCreatedFromMergingWith = ABar)) then AItemLink.Free else if AItemLink.Item.GetItemLinks <> nil then AItemLink.Item.GetItemLinks.Unmerge(ABar); end; end; function TdxBarItemLinks.AddItem(AItemClass: TdxBarItemClass; AOwner: TComponent): TdxBarItemLink; begin Result := Add; try if AOwner = nil then AOwner := BarManager; Result.Item := AItemClass.Create(AOwner); except Result.Item.Free; Result.Item := nil; raise; end; end; function TdxBarItemLinks.GetOwner: TPersistent; begin Result := GetOwnerComponent; end; function TdxBarItemLinks.GetOwnerComponent: TComponent; begin if FLinksOwner <> nil then Result := FLinksOwner.GetInstance else Result := nil; end; procedure TdxBarItemLinks.LoadItemNames; var I: Integer; begin for I := 0 to Count - 1 do Items[I].LoadItemName; end; procedure TdxBarItemLinks.Update(Item: TCollectionItem); begin { #DG if (Owner is TComponent) and not (Owner is TdxBar) and (csDestroying in TComponent(Owner).ComponentState) then Exit; } if Item = nil then RefreshVisibilityLists; if csDestroying in Owner.ComponentState then Exit; inherited Update(Item); if not Internal then DesignerModified; //#DG if Item <> nil then BarManager.DoItemLinkChange(TdxBarItemLink(Item)) else begin if (BarControl <> nil) and BarControl.Enabled then // #DG Enabled - why??? BarControl.RepaintBar; CallNotify(OnChange, Self); end; end; function TdxBarItemLinks.GetDefaultValue(AOption: TdxBarItemOptionValue): Variant; begin case AOption of ioShowDescriptions: Result := False; ioShowShortCuts: Result := True; else {ioSize} Result := misNormal; end; end; function TdxBarItemLinks.GetOptionsValue(AOption: TdxBarItemOptionValue; AItemLinks: TdxBarItemLinks): Variant; begin if not ItemOptions.IsValueStored(AOption) and (GetParentLinks <> nil) then Result := GetParentLinks.GetOptionsValue(AOption, AItemLinks) else Result := ItemOptions.GetValue(AOption); end; function TdxBarItemLinks.Add: TdxBarItemLink; begin Result := TdxBarItemLink(inherited Add); end; function TdxBarItemLinks.Add(AItem: TdxBarItem): TdxBarItemLink; begin BeginUpdate; try Result := Add; Result.Item := AItem; finally EndUpdate; end; end; function TdxBarItemLinks.AddItem(AItemClass: TdxBarItemClass): TdxBarItemLink; begin Result := Add(BarManager.AddItem(AItemClass)); end; function TdxBarItemLinks.AddButton: TdxBarItemLink; begin Result := Add(BarManager.AddButton); end; function TdxBarItemLinks.AddSubItem: TdxBarItemLink; begin Result := Add(BarManager.AddSubItem); end; procedure TdxBarItemLinks.Assign(Source: TPersistent); var ContainsMDISystemMenu: Boolean; SystemMenuSubItem: TSystemMenuSubItem; I: Integer; begin ContainsMDISystemMenu := (Count <> 0) and (Items[0].Item is TSystemMenuSubItem); if ContainsMDISystemMenu then SystemMenuSubItem := TSystemMenuSubItem(Items[0].Item) else SystemMenuSubItem := nil; FAssigning := True; try inherited Assign(Source); finally FAssigning := False; for I := 0 to Count - 1 do with Items[I] do Visible := FLoadedVisible; if ContainsMDISystemMenu then with Add do begin Item := SystemMenuSubItem; Index := 0; end; end; end; function TdxBarItemLinks.AvailableIndexOf(Value: TdxBarItemLink): Integer; begin Result := FAvailableItems.IndexOf(Value); end; function TdxBarItemLinks.CanContainItem(AItem: TdxBarItem; out AErrorText: string): Boolean; begin Result := FLinksOwner.CanContainItem(AItem, AErrorText); end; function TdxBarItemLinks.CanVisibleIndexOf(Value: TdxBarItemLink): Integer; begin Result := FCanVisibleItems.IndexOf(Value); end; procedure TdxBarItemLinks.CreateBarControl; begin FBarControl := FLinksOwner.CreateBarControl; FBarControl.FItemLinks := Self; end; procedure TdxBarItemLinks.DestroyBarControl; begin FreeAndNil(FBarControl); end; procedure TdxBarItemLinks.FreeForeignItems(ForeignBarManager: TdxBarManager); var I: Integer; begin if Owner is TdxBar then TdxBar(Owner).BarManager.BeginUpdate; for I := 0 to Count - 1 do if (ForeignBarManager <> nil) and (Items[I].BarManager = ForeignBarManager) or (ForeignBarManager = nil) and (Items[I].BarManager <> BarManager) then begin Items[I].Free; Items[I] := nil; end; if Owner is TdxBar then TdxBar(Owner).BarManager.EndUpdate; end; function TdxBarItemLinks.HasItem(AItem: TdxBarItem): Boolean; var I: Integer; begin Result := False; for I := 0 to Count - 1 do if Items[I].HasItem(AItem) then begin Result := True; Break; end; end; function TdxBarItemLinks.IsControlExists(AItem: TdxBarItemControl): Boolean; var I: Integer; begin Result := False; for I := 0 to Count - 1 do if Items[I].Control = AItem then begin Result := True; Break; end; end; function TdxBarItemLinks.IsReferencedBy(ALinksOwner: IdxBarLinksOwner): Boolean; var I: Integer; begin Result := Self = ALinksOwner.GetItemLinks; if not Result then for I := 0 to Count - 1 do if Items[I].IsReferencedBy(ALinksOwner) then begin Result := True; Break; end; end; function TdxBarItemLinks.IndexOf(Value: TdxBarItemLink): Integer; begin if (Value <> nil) and (Value.Collection = Self) then Result := Value.Index else Result := -1; end; function TdxBarItemLinks.Insert(AIndex: Integer): TdxBarItemLink; begin Result := TdxBarItemLink(inherited Insert(AIndex)); end; procedure TdxBarItemLinks.Move(ACurIndex, ANewIndex: Integer); begin BeginUpdate; try if (ACurIndex < Count) and (ACurIndex > -1) and (ANewIndex < Count) and (ANewIndex > -1) and (ACurIndex <> ANewIndex) then Items[ACurIndex].SetIndex(ANewIndex); finally EndUpdate; end; if BarControl <> nil then BarControl.RepaintBar; end; function TdxBarItemLinks.VisibleIndexOf(Value: TdxBarItemLink): Integer; begin Result := FVisibleItems.IndexOf(Value); end; { TdxBarControlItemLinks } function TdxBarControlItemLinks.DoFindItemWithAccel(AKey: Word; AShift: TShiftState; ACurrentLink: TdxBarItemLink): TdxBarItemLink; begin if IsWindowVisible(BarControl.Handle) then begin Result := ACurrentLink; repeat Result := Next(Result); if Result = nil then Break; if Result.Item.HasAccel(Result) and Result.IsAccel(AKey, AShift) then Exit; if Result = ACurrentLink then Break; if ACurrentLink = nil then ACurrentLink := Result; until False; end; Result := nil; end; { TdxBarSubMenuControlItemLinks } function TdxBarSubMenuControlItemLinks.DoFindItemWithAccel(AKey: Word; AShift: TShiftState; ACurrentLink: TdxBarItemLink): TdxBarItemLink; begin if CanVisibleItemCount = 0 then begin Result := nil; Exit; end; if ACurrentLink = nil then ACurrentLink := CanVisibleItems[0]; Result := ACurrentLink; repeat if Result = CanVisibleItems[CanVisibleItemCount - 1] then Result := CanVisibleItems[0] else Result := CanVisibleItems[Result.CanVisibleIndex + 1]; if Result.Item.HasAccel(Result) and Result.IsAccel(AKey, AShift) then Exit; until Result = ACurrentLink; Result := nil; end; function TdxBarSubMenuControlItemLinks.IsScrollable: Boolean; begin Result := True; end; { TdxBarPopupMenu } constructor TdxBarCustomPopupMenu.Create(AOwner: TComponent); begin inherited Create(AOwner); if dxBarManagerList.Count = 0 then raise Exception.Create(cxGetResourceString(@dxSBAR_NOBARMANAGERS)); FBackgroundBitmap := TBitmap.Create; BarManager := GetBarManagerByComponent(AOwner); if FBarManager = nil then BarManager := TdxBarManager(dxBarManagerList[0]); FEditFont := TFont.Create; FFont := TFont.Create; FFont.Assign(BarManager.Font); FFont.OnChange := FontChanged; FItemLinks := GetItemLinksClass.Create(FBarManager, Self); UseRecentItems := False; FShowAnimation := True; FUseOwnMessageLoop := True; end; destructor TdxBarCustomPopupMenu.Destroy; begin //#DG Destroying; //#DG BarDesignController.DeselectIfSelected(Self); FreeAndNil(FItemLinks); FreeAndNil(FFont); FreeAndNil(FEditFont); FreeAndNil(FBackgroundBitmap); inherited Destroy; end; function TdxBarCustomPopupMenu.GetItemOptions: TdxBarItemOptions; begin Result := FItemLinks.ItemOptions; end; function TdxBarCustomPopupMenu.GetSubMenuControl: TdxBarSubMenuControl; begin Result := TdxBarSubMenuControl(FItemLinks.BarControl); end; function TdxBarCustomPopupMenu.GetUseRecentItems: Boolean; begin Result := FItemLinks.FUseRecentItems; end; procedure TdxBarCustomPopupMenu.SetBackgroundBitmap(Value: TBitmap); begin FBackgroundBitmap.Assign(Value); end; procedure TdxBarCustomPopupMenu.SetBarManager(Value: TdxBarManager); begin if (FBarManager <> Value) and (Value <> nil) then begin if FBarManager <> nil then FBarManager.FPopupMenus.Remove(Self); FBarManager := Value; if FItemLinks <> nil then FItemLinks.FBarManager := Value; FBarManager.FPopupMenus.Add(Self); end; end; procedure TdxBarCustomPopupMenu.SetBarSize(Value: Integer); begin if Value < 0 then Value := 0; FBarSize := Value; end; procedure TdxBarCustomPopupMenu.SetFont(Value: TFont); begin Font.Assign(Value); end; procedure TdxBarCustomPopupMenu.SetItemLinks(Value: TdxBarItemLinks); begin FItemLinks.Assign(Value); end; procedure TdxBarCustomPopupMenu.SetItemOptions(Value: TdxBarItemOptions); begin FItemLinks.ItemOptions := Value; end; procedure TdxBarCustomPopupMenu.SetUseOwnFont(Value: Boolean); begin if FUseOwnFont <> Value then begin FUseOwnFont := Value; FInternalFontChange := True; try if FUseOwnFont then FontChanged(nil) else Font := BarManager.Font; finally FInternalFontChange := False; end; end; end; procedure TdxBarCustomPopupMenu.SetUseRecentItems(Value: Boolean); begin FItemLinks.FUseRecentItems := Value; end; procedure TdxBarCustomPopupMenu.FontChanged(Sender: TObject); begin if not FInternalFontChange then FUseOwnFont := True; if FUseOwnFont then CreateEditFontHandle(Font, FEditFont, False); end; procedure TdxBarCustomPopupMenu.SubMenuCloseUp(Sender: TObject); begin FPopupMenuVisible := False; CallNotify(FOnCloseUp, Self); end; procedure TdxBarCustomPopupMenu.SubMenuPopup(Sender: TObject); begin FPopupMenuVisible := True; CallNotify(FOnPopup, Self); end; procedure TdxBarCustomPopupMenu.OwnerDesignerModified; begin if [csDesigning, csLoading, csDestroying, csUpdating] * ComponentState = [csDesigning] then BarDesignController.DesignerModified(GetComponentForm(Self)); end; function TdxBarCustomPopupMenu.GetEnabled: Boolean; begin Result := True; end; procedure TdxBarCustomPopupMenu.SetEnabled(Value: Boolean); begin end; procedure TdxBarCustomPopupMenu.SetVisible(Value: TdxBarItemVisible); begin end; function TdxBarCustomPopupMenu.GetControlClass: TCustomdxBarControlClass; begin Result := TdxBarSubMenuControl; end; function TdxBarCustomPopupMenu.GetItemLinksClass: TdxBarItemLinksClass; begin Result := TdxBarSubMenuControlItemLinks; end; function TdxBarCustomPopupMenu.IsShortCut(AShortCut: TShortCut): Boolean; begin Result := FItemLinks.IsShortCut(AShortCut); end; function TdxBarCustomPopupMenu.IsShortCutKey(var Message: TWMKey): Boolean; const AltMask = $20000000; var AShortCut: TShortCut; begin AShortCut := Byte(Message.CharCode); if AShortCut = 0 then Result := False else begin if GetKeyState(VK_SHIFT) < 0 then Inc(AShortCut, scShift); if GetKeyState(VK_CONTROL) < 0 then Inc(AShortCut, scCtrl); if Message.KeyData and AltMask <> 0 then Inc(AShortCut, scAlt); Result := IsShortCut(AShortCut); end; end; procedure TdxBarCustomPopupMenu.Loaded; begin inherited Loaded; BarDesignController.LockDesignerModified; try FItemLinks.LoadItemNames; FItemLinks.Loaded(True); finally BarDesignController.UnLockDesignerModified; end; end; // IdxBarLinksOwner function TdxBarCustomPopupMenu.CanContainItem(AItem: TdxBarItem; out AErrorText: string): Boolean; begin Result := (GetOwnedLinks(AItem) = nil) or not GetOwnedLinks(AItem).IsReferencedBy(Self); if not Result then AErrorText := cxGetResourceString(@dxSBAR_RECURSIVEMENUS); end; function TdxBarCustomPopupMenu.CreateBarControl: TCustomdxBarControl; begin Result := GetControlClass.Create(BarManager); end; function TdxBarCustomPopupMenu.GetItemLinks: TdxBarItemLinks; begin Result := FItemLinks; end; // IdxBarSubMenuOwner function TdxBarCustomPopupMenu.GetBarSize: Integer; begin Result := FBarSize; end; procedure TdxBarCustomPopupMenu.DoPaintBar(Canvas: TCanvas; const R: TRect); begin if Assigned(FOnPaintBar) then FOnPaintBar(Self, Canvas, R); end; procedure TdxBarCustomPopupMenu.Popup(X, Y: Integer); var Msg: TMsg; begin if FItemLinks.BarControl <> nil then Exit; dxBar.SendCancelMode; if GetCapture <> 0 then begin SendMessage(GetCapture, CM_CANCELMODE, 0, 0); ReleaseCapture; end; FItemLinks.CreateBarControl; FItemLinks.BarControl.Left := X; FItemLinks.BarControl.Top := Y; with TdxBarSubMenuControl(FItemLinks.BarControl) do begin if FOwnerItemControl <> nil then FOwnerItemControl.Parent.ChildBar := FItemLinks.BarControl; if Self.FOwnerBounds <> nil then OwnerBounds := Self.FOwnerBounds^; FOwnerControl := Self.FOwnerControl; OwnerWidth := Self.FOwnerWidth; OwnerHeight := Self.FOwnerHeight; if Self.Owner is TWinControl then ParentWnd := TWinControl(Self.Owner).Handle; OnCloseUp := SubMenuCloseUp; OnPopup := SubMenuPopup; FShowAnimation := Self.FShowAnimation; try Show; except HideAll; raise; end; if FUseOwnMessageLoop then repeat case Integer(GetMessage(Msg, 0, 0, 0)) of -1: Break; 0: begin PostQuitMessage(Msg.wParam); Break; end; end; if not FPopupMenuVisible then with Msg do PostMessage(hwnd, message, wParam, lParam) else if Msg.message = WM_COMMAND then // do nothing else begin TranslateMessage(Msg); DispatchMessage(Msg); end; until not FPopupMenuVisible; end; end; procedure TdxBarCustomPopupMenu.PopupEx(X, Y, AOwnerWidth, AOwnerHeight: Integer; AShowAnimation: Boolean; AOwnerBounds: PRect; AUseOwnMessageLoop: Boolean = True; AOwnerControl: TWinControl = nil); begin FOwnerWidth := AOwnerWidth; FOwnerHeight := AOwnerHeight; FShowAnimation := AShowAnimation; FOwnerBounds := AOwnerBounds; FOwnerControl := AOwnerControl; FUseOwnMessageLoop := AUseOwnMessageLoop; Popup(X, Y); FUseOwnMessageLoop := True; FOwnerControl := nil; FOwnerWidth := 0; FOwnerHeight := 0; FShowAnimation := True; end; procedure TdxBarCustomPopupMenu.PopupFromCursorPos; begin with GetMouseCursorPos do Popup(X, Y); end; { TdxBarApplicationMenu } type TdxExtraMenuDockControl = class(TdxBarDockControl) protected procedure CalcRowToolbarPositions(ARowIndex: Integer; AClientSize: Integer); override; function GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; override; function GetDockedBarControlClass: TdxBarControlClass; override; public constructor Create(AOwner: TComponent); override; end; { TdxExtraMenuDockControlAccessibilityHelper } TdxExtraMenuDockControlAccessibilityHelper = class(TdxDockControlAccessibilityHelper) protected function GetParent: TcxAccessibilityHelper; override; end; TdxBarExtraMenuControl = class(TdxBarControl) private FIsControlsCreated: Boolean; function GetBasicControl: TCustomdxBarControl; procedure WMNCCalcSize(var Message: TWMNCCalcSize); message WM_NCCALCSIZE; protected procedure CalcControlsPositions; override; procedure CalcItemsRect; override; function CanMoving: Boolean; override; function CanProcessMouseMessage: Boolean; override; function CanShowPopupMenuOnMouseClick(AMousePressed: Boolean): Boolean; override; procedure DoCreateControls; override; procedure DoDestroyControls; override; procedure DoDrawBeginGroup(const ASeparatorRect: TRect; AHorz: Boolean); override; procedure DoNCPaint(DC: HDC); override; procedure DoHideAll; override; procedure DrawContentBackground; override; function FindLinkWithAccel(AKey: Word; AShift: TShiftState; ACurrentLink: TdxBarItemLink; out ADuplicate: Boolean): TdxBarItemLink; override; function GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; override; function GetBehaviorOptions: TdxBarBehaviorOptions; override; function GetPainter: TdxBarPainter; override; function GetViewInfoClass: TCustomdxBarControlViewInfoClass; override; procedure HideAllByEscape; override; procedure LayoutChanged; override; procedure SetAccelSelectedItem(AItemControl: TdxBarItemControl; ADuplicate: Boolean); override; property BasicControl: TCustomdxBarControl read GetBasicControl; public destructor Destroy; override; end; TdxBarExtraMenuControlViewInfo = class(TdxBarControlViewInfo) protected procedure DoCalcSeparatorInfo(AItemLink: TdxBarItemLink; const AItemRect: TRect); override; end; { TdxBarExtraMenuControlAccessibilityHelper } TdxBarExtraMenuControlAccessibilityHelper = class(TdxBarControlAccessibilityHelper) protected procedure DoGetKeyTipsData(AKeyTipsData: TList); override; function GetNextAccessibleObject(AItemControl: TdxBarItemControl; ADirection: TcxAccessibilityNavigationDirection): IdxBarAccessibilityHelper; override; function HandleNavigationKey(var AKey: Word): Boolean; override; end; TdxBarApplicationMenuControl = class(TdxBarSubMenuControl) private FButtonsViewInfo: TdxBarApplicationMenuButtonsViewInfo; FBar: TdxBar; FDockControl: TdxBarDockControl; FTotalItemLinks: TdxBarItemLinks; FCaptionItemsRect: TRect; FExtraPaneRect: TRect; FExtraPaneSize: Integer; function GetApplicationMenu: TdxBarApplicationMenu; function GetButtonLinks: TdxBarItemLinks; function GetExtraPaneItemLinks: TdxBarItemLinks; function GetTotalItemLinks: TdxBarItemLinks; function NeedExtraPane: Boolean; property ApplicationMenu: TdxBarApplicationMenu read GetApplicationMenu; property TotalItemLinks: TdxBarItemLinks read GetTotalItemLinks; protected function CalcChildBarBounds(out ARect: TRect): Boolean; override; procedure CalcItemRects(APaintStyle: TdxBarPaintType; ATopIndex: Integer); override; procedure CalcItemsRect; override; procedure DoCalcSize(out ASize: TSize); override; procedure CreateWnd; override; procedure DestroyWindowHandle; override; function GetViewInfoClass: TCustomdxBarControlViewInfoClass; override; procedure DoNCPaint(DC: HDC; const ARect: TRect); override; procedure DoShow; override; procedure DrawContent; override; procedure DrawContentArea; procedure DoFillBackgroundEx(ACanvas: TcxCanvas; const ARect: TRect; ABrush: HBRUSH; AColor: TColor; AIsClientArea: Boolean); override; function DoFindLinkWithAccel(AKey: Word; AShift: TShiftState; ACurrentLink: TdxBarItemLink): TdxBarItemLink; override; function FindLinkWithAccel(AKey: Word; AShift: TShiftState; ACurrentLink: TdxBarItemLink; out ADuplicate: Boolean): TdxBarItemLink; override; function GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; override; function GetBehaviorOptions: TdxBarBehaviorOptions; override; function GetItemsRectOffset: TRect; override; function IsControlExists(ABarItemControl: TdxBarItemControl): Boolean; override; procedure SetAccelSelectedItem(AItemControl: TdxBarItemControl; ADuplicate: Boolean); override; procedure SetControlVisible(AControl: TdxBarItemControl); override; procedure ShowExtraMenuControl; property ButtonLinks: TdxBarItemLinks read GetButtonLinks; property ExtraMenuControlDockControl: TdxBarDockControl read FDockControl; property ExtraPaneItemLinks: TdxBarItemLinks read GetExtraPaneItemLinks; public constructor Create(AOwner: TComponent); override; destructor Destroy; override; end; TdxBarApplicationMenuControlViewInfo = class(TdxBarSubMenuControlViewInfo) private function GetBarControl: TdxBarApplicationMenuControl; public procedure Calculate; override; property BarControl: TdxBarApplicationMenuControl read GetBarControl; end; { TdxBarApplicationMenuControlAccessibilityHelper } TdxBarApplicationMenuControlAccessibilityHelper = class(TdxBarSubMenuControlAccessibilityHelper) private function GetBarControl: TdxBarApplicationMenuControl; function GetNextLinks(ACurrentLinks: TdxBarItemLinks): TdxBarItemLinks; function GetPreviousLinks(ACurrentLinks: TdxBarItemLinks): TdxBarItemLinks; function InternalGetNextItemLink(ACurrentLinks: TdxBarItemLinks; ASelectedLink: TdxBarItemLink; AUpKey: Boolean; AFirstVisibleIndex: Integer = 0): TdxBarItemLink; procedure PopulateNavigationList(AList: TList); protected function GetChild(AIndex: Integer): TcxAccessibilityHelper; override; function GetChildCount: Integer; override; function GetChildIndex(AChild: TcxAccessibilityHelper): Integer; override; procedure GetItemControlKeyTipPosition(AItemControl: TdxBarItemControl; out ABasePoint: TPoint; out AHorzAlign: TAlignment; out AVertAlign: TcxAlignmentVert); override; function GetNextAccessibleObject(AItemControl: TdxBarItemControl; ADirection: TcxAccessibilityNavigationDirection): IdxBarAccessibilityHelper; override; function GetNextItemLink(ACurrentLinks: TdxBarItemLinks; ASelectedLink: TdxBarItemLink; AUpKey: Boolean): TdxBarItemLink; override; function GetParentForKeyTip: TdxBarAccessibilityHelper; override; property BarControl: TdxBarApplicationMenuControl read GetBarControl; end; TdxBarApplicationMenuControlDesignHelper = class(TCustomdxBarControlDesignHelper); TdxBarApplicationMenuItemLinks = class(TdxBarSubMenuControlItemLinks) private function GetInternalDefaultValue(AOption: TdxBarItemOptionValue; AItemLinks: TdxBarItemLinks): Variant; protected function GetDefaultValue(AOption: TdxBarItemOptionValue): Variant; override; function GetOptionsValue(AOption: TdxBarItemOptionValue; AItemLinks: TdxBarItemLinks): Variant; override; end; { TdxExtraMenuDockControl } constructor TdxExtraMenuDockControl.Create(AOwner: TComponent); begin inherited; AllowDocking := False; end; procedure TdxExtraMenuDockControl.CalcRowToolbarPositions(ARowIndex: Integer; AClientSize: Integer); var AToolbar: TdxBarControl; R: TRect; begin R := ClientRect; AToolbar := Rows[0].Cols[0].BarControl; if (AToolbar.Left <> R.Left) or (AToolbar.Top <> R.Top) or (AToolbar.Width <> cxRectWidth(R)) or (AToolbar.Height <> cxRectHeight(R)) then begin if AToolbar.HandleAllocated then begin SetWindowPos(AToolbar.Handle, 0, R.Left, R.Top, cxRectWidth(R), cxRectHeight(R), SWP_NOZORDER or SWP_NOACTIVATE); SendMessage(AToolbar.Handle, WM_NCPAINT, 0, 0); end else AToolbar.SetBounds(R.Left, R.Top, cxRectWidth(R), cxRectHeight(R)); end; end; function TdxExtraMenuDockControl.GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; begin Result := TdxExtraMenuDockControlAccessibilityHelper; end; function TdxExtraMenuDockControl.GetDockedBarControlClass: TdxBarControlClass; begin Result := TdxBarExtraMenuControl; end; { TdxExtraMenuDockControlAccessibilityHelper } function TdxExtraMenuDockControlAccessibilityHelper.GetParent: TcxAccessibilityHelper; begin Result := TdxBarApplicationMenuControl(DockControl.Parent).IAccessibilityHelper.GetBarHelper; end; { TdxBarExtraMenuControl } destructor TdxBarExtraMenuControl.Destroy; begin inherited; end; procedure TdxBarExtraMenuControl.CalcControlsPositions; begin if not FIsControlsCreated then CreateControls; inherited; CalcItemRects(ptMenu); end; procedure TdxBarExtraMenuControl.CalcItemsRect; begin inherited; FItemsRect.Left := FItemsRect.Left + MenuSeparatorSize; end; function TdxBarExtraMenuControl.CanMoving: Boolean; begin Result := False; end; function TdxBarExtraMenuControl.CanProcessMouseMessage: Boolean; begin Result := inherited CanProcessMouseMessage or TdxBarApplicationMenuControl(BasicControl).CanProcessMouseMessage; end; function TdxBarExtraMenuControl.CanShowPopupMenuOnMouseClick(AMousePressed: Boolean): Boolean; begin Result := False; end; procedure TdxBarExtraMenuControl.DoCreateControls; begin FIsControlsCreated := True; if not IsCustomizing then ExpandContainerItems; inherited DoCreateControls; end; procedure TdxBarExtraMenuControl.DoDestroyControls; begin inherited DoDestroyControls; if not IsCustomizing then CollapseContainerItems; FIsControlsCreated := False; end; procedure TdxBarExtraMenuControl.DoDrawBeginGroup(const ASeparatorRect: TRect; AHorz: Boolean); begin Painter.ExtraMenuControlDrawBeginGroup(Self, Canvas, ASeparatorRect, ToolbarBrush, AHorz); end; procedure TdxBarExtraMenuControl.DoNCPaint(DC: HDC); begin // do nothing end; procedure TdxBarExtraMenuControl.DoHideAll; begin inherited; BasicControl.HideAll; end; procedure TdxBarExtraMenuControl.DrawContentBackground; begin Painter.ExtraMenuControlDrawBackground(Self, Canvas, ClientRect, ToolbarBrush, clNone); end; function TdxBarExtraMenuControl.FindLinkWithAccel(AKey: Word; AShift: TShiftState; ACurrentLink: TdxBarItemLink; out ADuplicate: Boolean): TdxBarItemLink; begin Result := BasicControl.FindLinkWithAccel(AKey, AShift, ACurrentLink, ADuplicate); end; function TdxBarExtraMenuControl.GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; begin Result := TdxBarExtraMenuControlAccessibilityHelper; end; function TdxBarExtraMenuControl.GetBehaviorOptions: TdxBarBehaviorOptions; begin Result := BasicControl.BehaviorOptions; end; function TdxBarExtraMenuControl.GetPainter: TdxBarPainter; begin Result := BasicControl.Painter; end; function TdxBarExtraMenuControl.GetViewInfoClass: TCustomdxBarControlViewInfoClass; begin Result := TdxBarExtraMenuControlViewInfo; end; procedure TdxBarExtraMenuControl.HideAllByEscape; begin TdxBarApplicationMenuControl(BasicControl).HideByEscape; end; procedure TdxBarExtraMenuControl.LayoutChanged; begin // do nothing; end; procedure TdxBarExtraMenuControl.SetAccelSelectedItem(AItemControl: TdxBarItemControl; ADuplicate: Boolean); begin BasicControl.SetAccelSelectedItem(AItemControl, ADuplicate); end; function TdxBarExtraMenuControl.GetBasicControl: TCustomdxBarControl; begin Result := TCustomdxBarControl(DockControl.Parent); end; procedure TdxBarExtraMenuControl.WMNCCalcSize(var Message: TWMNCCalcSize); begin if Message.CalcValidRects then Message.Result := 0 else inherited; end; { TdxBarExtraMenuControlViewInfo } procedure TdxBarExtraMenuControlViewInfo.DoCalcSeparatorInfo(AItemLink: TdxBarItemLink; const AItemRect: TRect); var R: TRect; begin R := Rect(AItemRect.Left, AItemRect.Top - BarControl.BeginGroupSize, AItemRect.Right, AItemRect.Top); AddSeparatorInfo(R, skHorizontal, AItemLink.Control); end; { TdxBarExtraMenuControlAccessibilityHelper } procedure TdxBarExtraMenuControlAccessibilityHelper.DoGetKeyTipsData( AKeyTipsData: TList); begin end; function TdxBarExtraMenuControlAccessibilityHelper.GetNextAccessibleObject( AItemControl: TdxBarItemControl; ADirection: TcxAccessibilityNavigationDirection): IdxBarAccessibilityHelper; function BasicControlObject: TdxBarApplicationMenuControlAccessibilityHelper; begin Result := TdxBarApplicationMenuControlAccessibilityHelper( TdxBarExtraMenuControl(BarControl).BasicControl.IAccessibilityHelper.GetHelper); end; begin Result := BasicControlObject.GetNextAccessibleObject(AItemControl, ADirection); end; function TdxBarExtraMenuControlAccessibilityHelper.HandleNavigationKey(var AKey: Word): Boolean; var AShift: TShiftState; begin Result := False; AShift := InternalGetShiftState; if AKey = VK_TAB then if AShift = [] then AKey := VK_DOWN else AKey := VK_UP else Result := inherited HandleNavigationKey(AKey); end; { TdxBarApplicationMenuControl } constructor TdxBarApplicationMenuControl.Create(AOwner: TComponent); begin inherited; // to prohibit FBar from appearing in the Object TreeView if NeedExtraPane then begin FDockControl := TdxExtraMenuDockControl.Create(AOwner); FDockControl.Align := dalNone; FDockControl.BarManager := BarManager; FDockControl.Parent := Self; BarManager.Bars.BeginUpdate; try FBar := BarManager.Bars.Add; FBar.AllowQuickCustomizing := False; FBar.AllowCustomizing := False; FBar.NotDocking := [dsNone]; FBar.Hidden := True; FBar.Font := Font; FBar.UseOwnFont := False; finally BarManager.Bars.EndUpdate(False); end; end; end; destructor TdxBarApplicationMenuControl.Destroy; begin FreeAndNil(FTotalItemLinks); FreeAndNil(FBar); FreeAndNil(FDockControl); inherited; end; procedure TdxBarApplicationMenuControl.CalcItemRects(APaintStyle: TdxBarPaintType; ATopIndex: Integer); begin inherited CalcItemRects(APaintStyle, ATopIndex); if FButtonsViewInfo <> nil then FButtonsViewInfo.Calculate(FCaptionItemsRect); end; procedure TdxBarApplicationMenuControl.CalcItemsRect; begin inherited CalcItemsRect; FCaptionItemsRect := FItemsRect; FCaptionItemsRect.Top := FItemsRect.Bottom; FCaptionItemsRect.Bottom := ContentRect.Bottom; FCaptionItemsRect := cxRectInflate(FCaptionItemsRect, 0, -4, 1, -1); if NeedExtraPane then begin FExtraPaneRect := FItemsRect; Dec(FItemsRect.Right, FExtraPaneSize); FExtraPaneRect.Left := FItemsRect.Right; end; end; function TdxBarApplicationMenuControl.CalcChildBarBounds(out ARect: TRect): Boolean; begin Result := NeedExtraPane; if Result then begin ARect := FExtraPaneRect; MapWindowRect(Handle, 0, ARect); end; end; procedure TdxBarApplicationMenuControl.CreateWnd; begin if not IsCustomizing then begin FreeAndNil(FButtonsViewInfo); FButtonsViewInfo := TdxBarApplicationMenuButtonsViewInfo.Create(ApplicationMenu.Buttons, Self, BarManager); end; inherited CreateWnd; end; procedure TdxBarApplicationMenuControl.DestroyWindowHandle; begin inherited DestroyWindowHandle; FreeAndNil(FButtonsViewInfo); end; procedure TdxBarApplicationMenuControl.DoCalcSize(out ASize: TSize); begin inherited; if NeedExtraPane then begin if ApplicationMenu.ExtraPaneSize <> 0 then FExtraPaneSize := MulDiv(ApplicationMenu.ExtraPaneSize, TextSize, Painter.SubMenuControlNormalItemHeight) else FExtraPaneSize := Round(ASize.cx * ApplicationMenu.ExtraPaneWidthRatio); Inc(ASize.cx, FExtraPaneSize); end; end; function TdxBarApplicationMenuControl.GetViewInfoClass: TCustomdxBarControlViewInfoClass; begin Result := TdxBarApplicationMenuControlViewInfo; end; procedure TdxBarApplicationMenuControl.DoNCPaint(DC: HDC; const ARect: TRect); begin Painter.ApplicationMenuDrawBorder(Self, DC, ARect); end; procedure TdxBarApplicationMenuControl.DoShow; begin HandleNeeded; CalcControlsPositions; ShowExtraMenuControl; inherited; end; procedure TdxBarApplicationMenuControl.DrawContent; begin inherited; DrawContentArea; end; procedure TdxBarApplicationMenuControl.DrawContentArea; var AItemsArea: TRect; begin UnionRect(AItemsArea, ItemsRect, FExtraPaneRect); UnionRect(AItemsArea, AItemsArea, BarRect); Canvas.SaveClipRegion; try Canvas.SetClipRegion(TcxRegion.Create(ContentRect), roIntersect); Painter.ApplicationMenuDrawContentArea(Self, Canvas, ContentRect, AItemsArea); finally Canvas.RestoreClipRegion; end; end; procedure TdxBarApplicationMenuControl.DoFillBackgroundEx(ACanvas: TcxCanvas; const ARect: TRect; ABrush: HBRUSH; AColor: TColor; AIsClientArea: Boolean); begin inherited; DrawContentArea; end; function TdxBarApplicationMenuControl.DoFindLinkWithAccel(AKey: Word; AShift: TShiftState; ACurrentLink: TdxBarItemLink): TdxBarItemLink; begin Result := TotalItemLinks.FindItemWithAccel(AKey, AShift, ACurrentLink); end; function TdxBarApplicationMenuControl.FindLinkWithAccel(AKey: Word; AShift: TShiftState; ACurrentLink: TdxBarItemLink; out ADuplicate: Boolean): TdxBarItemLink; procedure PopulateTotalItemLinks; procedure InternalAssign(AItemLinks: TdxBarItemLinks); var I: Integer; ALink: TdxBarItemLink; begin if AItemLinks <> nil then for I := 0 to AItemLinks.Count - 1 do begin ALink := TotalItemLinks.Add; ALink.Assign(AItemLinks[I]); ALink.Data := Integer(AItemLinks[I]); end; end; begin TotalItemLinks.BeginUpdate; try TotalItemLinks.Clear; InternalAssign(ItemLinks); InternalAssign(ExtraPaneItemLinks); InternalAssign(ButtonLinks); finally TotalItemLinks.EndUpdate; end; end; function ImportCurrentLink(ACurrentLink: TdxBarItemLink): TdxBarItemLink; var I: Integer; begin Result := nil; if ACurrentLink <> nil then for I := 0 to TotalItemLinks.Count - 1 do if TotalItemLinks[I].Data = Integer(ACurrentLink) then begin Result := TotalItemLinks[I]; Break; end; end; function ExportCurrentLink(ACurrentLink: TdxBarItemLink): TdxBarItemLink; begin if ACurrentLink <> nil then Result := TdxBarItemLink(ACurrentLink.Data) else Result := nil; end; begin PopulateTotalItemLinks; Result := ExportCurrentLink(inherited FindLinkWithAccel(AKey, AShift, ImportCurrentLink(ACurrentLink), ADuplicate)); end; function TdxBarApplicationMenuControl.GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; begin Result := TdxBarApplicationMenuControlAccessibilityHelper; end; function TdxBarApplicationMenuControl.GetBehaviorOptions: TdxBarBehaviorOptions; begin Result := [bboAllowSelectWindowItemsWithoutFocusing, bboAllowShowHints, bboClickItemsBySpaceKey, bboExtendItemWhenAlignedToClient, bboUnmoved]; end; function TdxBarApplicationMenuControl.GetItemsRectOffset: TRect; function Scale(const ARect: TRect; ARatio: Double): TRect; begin Result.Left := Round(ARect.Left * ARatio); Result.Top := Round(ARect.Top * ARatio); Result.Right := Round(ARect.Right * ARatio); Result.Bottom := Round(ARect.Bottom * ARatio); end; var AFrameSizes: TRect; begin Result := inherited GetItemsRectOffset; AFrameSizes := Scale(Painter.ApplicationMenuGetFrameSizes, Ratio); Result.Left := Result.Left + AFrameSizes.Left; Result.Top := Result.Top + AFrameSizes.Top; Result.Right := Result.Right + AFrameSizes.Right; Result.Bottom := Result.Bottom + AFrameSizes.Bottom; end; function TdxBarApplicationMenuControl.IsControlExists(ABarItemControl: TdxBarItemControl): Boolean; begin Result := inherited IsControlExists(ABarItemControl) or ((FButtonsViewInfo <> nil) and (ButtonLinks.IsControlExists(ABarItemControl))); end; procedure TdxBarApplicationMenuControl.SetAccelSelectedItem(AItemControl: TdxBarItemControl; ADuplicate: Boolean); begin if BarNavigationController.SelectedObject <> nil then BarNavigationController.SelectedObject.Unselect(AItemControl.IAccessibilityHelper); AItemControl.IAccessibilityHelper.Select(True); if not ADuplicate then SendMessage(AItemControl.Parent.Handle, WM_KEYDOWN, VK_RETURN, 0); end; procedure TdxBarApplicationMenuControl.SetControlVisible(AControl: TdxBarItemControl); begin if AControl.GetPaintType = ptMenu then inherited SetControlVisible(AControl); end; procedure TdxBarApplicationMenuControl.ShowExtraMenuControl; begin if NeedExtraPane then begin ExtraPaneItemLinks.Add(ApplicationMenu.ExtraPaneListItem); FBar.DockControl := FDockControl; FBar.BorderStyle := bbsNone; FBar.Visible := True; SetWindowPos(FDockControl.Handle, 0, FExtraPaneRect.Left, FExtraPaneRect.Top, cxRectWidth(FExtraPaneRect), cxRectHeight(FExtraPaneRect), SWP_NOZORDER or SWP_NOACTIVATE or SWP_SHOWWINDOW); end; end; function TdxBarApplicationMenuControl.GetApplicationMenu: TdxBarApplicationMenu; begin Result := TdxBarApplicationMenu(ItemLinks.Owner); end; function TdxBarApplicationMenuControl.GetButtonLinks: TdxBarItemLinks; begin if FButtonsViewInfo <> nil then Result := FButtonsViewInfo.ItemLinks else Result := nil; end; function TdxBarApplicationMenuControl.GetExtraPaneItemLinks: TdxBarItemLinks; begin if NeedExtraPane then Result := FBar.ItemLinks else Result := nil; end; function TdxBarApplicationMenuControl.GetTotalItemLinks: TdxBarItemLinks; begin if FTotalItemLinks = nil then FTotalItemLinks := TdxBarSubMenuControlItemLinks.Create(BarManager, ApplicationMenu); Result := FTotalItemLinks; end; function TdxBarApplicationMenuControl.NeedExtraPane: Boolean; begin // see constructor Result := not IsCustomizing; end; { TdxBarApplicationMenuControlViewInfo } function TdxBarApplicationMenuControlViewInfo.GetBarControl: TdxBarApplicationMenuControl; begin Result := TdxBarApplicationMenuControl(inherited GetBarControl); end; procedure TdxBarApplicationMenuControlViewInfo.Calculate; var I: Integer; AControl: TdxBarItemControl; ALinks: TdxBarItemLinks; AVisibleItemRect: TRect; begin inherited Calculate; if (ItemControlCount > 0) and (BarControl.FButtonsViewInfo <> nil) then begin ALinks := BarControl.ButtonLinks; for I := 0 to ALinks.VisibleItemCount - 1 do begin AControl := ALinks.VisibleItems[I].Control; AVisibleItemRect := BarControl.GetItemRect(AControl); if not IsRectEmpty(AVisibleItemRect) then begin AddItemControlViewInfo(AControl.ViewInfo); IdxBarItemControlViewInfo(AControl.ViewInfo).SetBounds(AVisibleItemRect); end; end; end; end; { TdxBarApplicationMenuControlAccessibilityHelper } function TdxBarApplicationMenuControlAccessibilityHelper.GetChild( AIndex: Integer): TcxAccessibilityHelper; begin if AIndex = ChildCount - 1 then Result := BarControl.ExtraMenuControlDockControl.IAccessibilityHelper.GetHelper else Result := inherited GetChild(AIndex); end; function TdxBarApplicationMenuControlAccessibilityHelper.GetChildCount: Integer; begin Result := inherited GetChildCount + 1; end; function TdxBarApplicationMenuControlAccessibilityHelper.GetChildIndex( AChild: TcxAccessibilityHelper): Integer; begin if AChild = BarControl.ExtraMenuControlDockControl.IAccessibilityHelper.GetHelper then Result := inherited GetChildCount else Result := inherited GetChildIndex(AChild); end; procedure TdxBarApplicationMenuControlAccessibilityHelper.GetItemControlKeyTipPosition( AItemControl: TdxBarItemControl; out ABasePoint: TPoint; out AHorzAlign: TAlignment; out AVertAlign: TcxAlignmentVert); begin if BarControl.ButtonLinks.IndexOf(AItemControl.ItemLink) <> -1 then begin ABasePoint := cxRectCenter(GetItemControlScreenBounds(AItemControl)); AHorzAlign := taCenter; AVertAlign := vaBottom; end else inherited GetItemControlKeyTipPosition(AItemControl, ABasePoint, AHorzAlign, AVertAlign); end; function TdxBarApplicationMenuControlAccessibilityHelper.GetNextAccessibleObject( AItemControl: TdxBarItemControl; ADirection: TcxAccessibilityNavigationDirection): IdxBarAccessibilityHelper; function GetScreenBoundsForNavigation: TRect; begin if (BarControl.ItemLinks.IsControlExists(AItemControl)) then begin Result := AItemControl.ItemBounds; Result.Top := BarControl.ItemsRect.Top; if BarControl.ExtraPaneItemLinks.RealVisibleItemCount > 1 then Result.Bottom := BarControl.ItemsRect.Bottom else Result.Bottom := BarControl.ContentRect.Bottom; Result.TopLeft := BarControl.ClientToScreen(Result.TopLeft); Result.BottomRight := BarControl.ClientToScreen(Result.BottomRight); end else Result := AItemControl.IAccessibilityHelper.GetBarHelper.GetScreenBounds(cxAccessibleObjectSelfID); end; var AObjects: TList; AItemLink: TdxBarItemLink; ASelectedLink: TdxBarItemLink; begin if ADirection in [andUp, andDown] then begin ASelectedLink := BarControl.FBar.Control.SelectedLink; if ASelectedLink = nil then AItemLink := BarControl.ItemLinks.First else AItemLink := InternalGetNextItemLink(BarControl.ExtraPaneItemLinks, ASelectedLink, ADirection = andUp, 1); if AItemLink <> nil then Result := AItemLink.Control.IAccessibilityHelper; end else begin AObjects := TList.Create; try GetChildrenForNavigation(AItemControl.IAccessibilityHelper.GetBarHelper, Self, GetScreenBoundsForNavigation, ADirection, True, AObjects); Result := dxBar.GetNextAccessibleObject( AItemControl.IAccessibilityHelper.GetBarHelper, AObjects, ADirection, True); finally AObjects.Free; end; end; end; function TdxBarApplicationMenuControlAccessibilityHelper.GetNextItemLink(ACurrentLinks: TdxBarItemLinks; ASelectedLink: TdxBarItemLink; AUpKey: Boolean): TdxBarItemLink; begin if BarControl.ButtonLinks.IsControlExists(ASelectedLink.Control) then ACurrentLinks := BarControl.ButtonLinks; Result := InternalGetNextItemLink(ACurrentLinks, ASelectedLink, AUpKey); end; function TdxBarApplicationMenuControlAccessibilityHelper.GetParentForKeyTip: TdxBarAccessibilityHelper; var AIAccessibleObject: IdxBarAccessibleObject; begin if Supports(BarControl.RealOwnerControl, IdxBarAccessibleObject, AIAccessibleObject) then Result := AIAccessibleObject.GetAccessibilityHelper.GetBarHelper else Result := nil; end; function TdxBarApplicationMenuControlAccessibilityHelper.GetBarControl: TdxBarApplicationMenuControl; begin Result := TdxBarApplicationMenuControl(FOwnerObject); end; function TdxBarApplicationMenuControlAccessibilityHelper.GetNextLinks(ACurrentLinks: TdxBarItemLinks): TdxBarItemLinks; var AIndex: Integer; AList: TList; begin AList := TList.Create; try PopulateNavigationList(AList); AIndex := AList.IndexOf(ACurrentLinks); if AIndex < AList.Count - 1 then Inc(AIndex) else AIndex := 0; Result := TdxBarItemLinks(AList[AIndex]) finally AList.Free; end; end; function TdxBarApplicationMenuControlAccessibilityHelper.GetPreviousLinks(ACurrentLinks: TdxBarItemLinks): TdxBarItemLinks; var AIndex: Integer; AList: TList; begin AList := TList.Create; try PopulateNavigationList(AList); AIndex := AList.IndexOf(ACurrentLinks); if AIndex > 0 then Dec(AIndex) else AIndex := AList.Count - 1; Result := TdxBarItemLinks(AList[AIndex]) finally AList.Free; end; end; function TdxBarApplicationMenuControlAccessibilityHelper.InternalGetNextItemLink(ACurrentLinks: TdxBarItemLinks; ASelectedLink: TdxBarItemLink; AUpKey: Boolean; AFirstVisibleIndex: Integer = 0): TdxBarItemLink; begin if AUpKey then if ASelectedLink.VisibleIndex = AFirstVisibleIndex then Result := GetPreviousLinks(ACurrentLinks).Last else Result := ACurrentLinks.Prev(ASelectedLink) else if ASelectedLink.VisibleIndex = ACurrentLinks.RealVisibleItemCount - 1 then Result := GetNextLinks(ACurrentLinks).First else Result := ACurrentLinks.Next(ASelectedLink); end; procedure TdxBarApplicationMenuControlAccessibilityHelper.PopulateNavigationList(AList: TList); begin if BarControl.ItemLinks.RealVisibleItemCount > 0 then AList.Add(BarControl.ItemLinks); if BarControl.ExtraPaneItemLinks.RealVisibleItemCount > 1 then AList.Add(BarControl.ExtraPaneItemLinks); if BarControl.ButtonLinks.RealVisibleItemCount > 0 then AList.Add(BarControl.ButtonLinks); end; { TdxBarApplicationMenuItemLinks } function TdxBarApplicationMenuItemLinks.GetDefaultValue(AOption: TdxBarItemOptionValue): Variant; begin Result := GetInternalDefaultValue(AOption, nil); end; function TdxBarApplicationMenuItemLinks.GetOptionsValue(AOption: TdxBarItemOptionValue; AItemLinks: TdxBarItemLinks): Variant; begin if not ItemOptions.IsValueStored(AOption) and (GetParentLinks = nil) then Result := GetInternalDefaultValue(AOption, AItemLinks) else Result := inherited GetOptionsValue(AOption, AItemLinks); end; function TdxBarApplicationMenuItemLinks.GetInternalDefaultValue(AOption: TdxBarItemOptionValue; AItemLinks: TdxBarItemLinks): Variant; begin case AOption of ioShowDescriptions: Result := AItemLinks <> Self; ioShowShortCuts: Result := False; else {ioSize} Result := misLarge; end; end; { TdxExtraPaneItem } procedure TdxBarExtraPaneItem.Assign(Source: TPersistent); begin if Source is TdxBarExtraPaneItem then begin Text := TdxBarExtraPaneItem(Source).Text; Data := TdxBarExtraPaneItem(Source).Data; end else inherited; end; procedure TdxBarExtraPaneItem.SetText(const Value: string); begin if FText <> Value then begin FText := Value; Changed(False); end; end; { TdxExtraPaneItems } constructor TdxBarExtraPaneItems.Create(AApplicationMenu: TdxBarApplicationMenu); begin inherited Create(TdxBarExtraPaneItem); FApplicationMenu := AApplicationMenu; end; function TdxBarExtraPaneItems.Add: TdxBarExtraPaneItem; begin Result := TdxBarExtraPaneItem(inherited Add); end; function TdxBarExtraPaneItems.IndexOf(const AItemText: string): Integer; var I: Integer; begin Result := -1; for I := 0 to Count - 1 do if Items[I].Text = AItemText then begin Result := I; Break; end; end; function TdxBarExtraPaneItems.Insert(AIndex: Integer): TdxBarExtraPaneItem; begin Result := TdxBarExtraPaneItem(inherited Insert(AIndex)); end; function TdxBarExtraPaneItems.GetOwner: TPersistent; begin Result := FApplicationMenu; end; function TdxBarExtraPaneItems.GetItem(Index: Integer): TdxBarExtraPaneItem; begin Result := TdxBarExtraPaneItem(inherited GetItem(Index)); end; procedure TdxBarExtraPaneItems.SetItem(Index: Integer; Value: TdxBarExtraPaneItem); begin inherited SetItem(Index, Value); end; { TdxBarApplicationMenuButton } constructor TdxBarApplicationMenuButton.Create(Collection: TCollection); begin inherited Create(Collection); FInternalItem := TdxBarApplicationMenuButtonItem.Create(Self); end; destructor TdxBarApplicationMenuButton.Destroy; begin FreeAndNil(FInternalItem); inherited Destroy; end; procedure TdxBarApplicationMenuButton.Assign(Source: TPersistent); var ASource: TdxBarApplicationMenuButton; begin if Source is TdxBarApplicationMenuButton then begin ASource := TdxBarApplicationMenuButton(Source); Width := ASource.Width; Item := ASource.Item; end else inherited Assign(Source); end; procedure TdxBarApplicationMenuButton.Update; begin if FItem <> nil then InternalItem.Assign(FItem); end; function TdxBarApplicationMenuButton.GetCollection: TdxBarApplicationMenuButtons; begin Result := TdxBarApplicationMenuButtons(inherited Collection); end; function TdxBarApplicationMenuButton.GetWidth: Integer; begin Result := FInternalItem.Width; end; procedure TdxBarApplicationMenuButton.SetItem(Value: TdxBarButton); begin if FItem <> Value then begin if FItem <> nil then FItem.RemoveFreeNotification(FInternalItem); FItem := Value; if FItem <> nil then FItem.FreeNotification(FInternalItem); end; end; procedure TdxBarApplicationMenuButton.SetWidth(Value: Integer); begin FInternalItem.Width := Value; end; { TdxBarApplicationMenuButtons } constructor TdxBarApplicationMenuButtons.Create(AApplicationMenu: TdxBarApplicationMenu); begin inherited Create(TdxBarApplicationMenuButton); FApplicationMenu := AApplicationMenu; { with Add do begin Caption := 'E&xit Word'; //Glyph.LoadFromResourceName('Exit'); end; with Add do begin Caption := 'Word Opt&ions'; //Glyph.LoadFromResourceName('Options'); end;} end; function TdxBarApplicationMenuButtons.Add: TdxBarApplicationMenuButton; begin Result := TdxBarApplicationMenuButton(inherited Add); end; function TdxBarApplicationMenuButtons.Insert(AIndex: Integer): TdxBarApplicationMenuButton; begin Result := TdxBarApplicationMenuButton(inherited Insert(AIndex)); end; function TdxBarApplicationMenuButtons.GetOwner: TPersistent; begin Result := FApplicationMenu; end; procedure TdxBarApplicationMenuButtons.Update(Item: TCollectionItem); var I: Integer; begin for I := 0 to Count -1 do Items[I].Update; end; function TdxBarApplicationMenuButtons.GetItem(Index: Integer): TdxBarApplicationMenuButton; begin Result := TdxBarApplicationMenuButton(inherited GetItem(Index)); end; procedure TdxBarApplicationMenuButtons.SetItem(Index: Integer; Value: TdxBarApplicationMenuButton); begin inherited SetItem(Index, Value); end; { TdxBarApplicationMenuButtonItemLinks } function TdxBarApplicationMenuButtonItemLinks.IsScrollable: Boolean; begin Result := False; end; { TdxBarApplicationMenuButtonsViewInfo } constructor TdxBarApplicationMenuButtonsViewInfo.Create(ApplicationMenuButtons: TdxBarApplicationMenuButtons; ABarControl: TCustomdxBarControl; ABarManager: TdxBarManager); begin inherited Create; FApplicationMenuButtons := ApplicationMenuButtons; ApplicationMenuButtons.Update(nil); FItemLinks := TdxBarApplicationMenuButtonItemLinks.Create(ABarManager, ApplicationMenuButtons.FApplicationMenu); FItemLinks.BarControl := ABarControl; PopulateItemLinks; end; destructor TdxBarApplicationMenuButtonsViewInfo.Destroy; begin FItemLinks.BarControl := nil; FreeAndNil(FItemLinks); inherited Destroy; end; procedure TdxBarApplicationMenuButtonsViewInfo.Calculate(ARect: TRect); const ApplicationMenuButtonsControlOffset = 6; // !!! var I: Integer; AItemLink: TdxBarItemLink; AItemRect: TRect; AOffsetItemBounds: Integer; begin FItemLinks.EmptyItemRects; AItemRect := ARect; for I := 0 to FItemLinks.VisibleItemCount - 1 do begin AItemLink := FItemLinks.VisibleItems[I]; AItemLink.DestroyControl; AItemLink.CreateControl; AItemRect.Right := AItemRect.Left + AItemLink.Control.Width; if AItemRect.Right > ARect.Right then Break; AItemLink.ItemRect := AItemRect; AItemRect.Left := AItemRect.Right + ApplicationMenuButtonsControlOffset; end; if FItemLinks.RealVisibleItemCount > 0 then AOffsetItemBounds := ARect.Right - FItemLinks.VisibleItems[FItemLinks.RealVisibleItemCount - 1].ItemRect.Right else AOffsetItemBounds := 0; for I := 0 to FItemLinks.RealVisibleItemCount - 1 do begin AItemLink := FItemLinks.VisibleItems[I]; AItemLink.ItemRect := cxRectOffsetHorz(AItemLink.ItemRect, AOffsetItemBounds); end; end; procedure TdxBarApplicationMenuButtonsViewInfo.PopulateItemLinks; var I: Integer; begin for I := 0 to FApplicationMenuButtons.Count - 1 do FItemLinks.Add(FApplicationMenuButtons[I].InternalItem); end; { TdxBarApplicationMenu } constructor TdxBarApplicationMenu.Create(AOwner: TComponent); begin inherited; FExtraPaneWidthRatio := dxBarExtraPaneWidthRatio; BarManager.LockDesignerModified(True); try FExtraPaneListItem := TdxBarExtraPaneListItem.Create(BarManager); FExtraPaneListItem.Caption := dxBarExtraPaneHeader; FExtraPaneListItem.OnClick := ExtraPaneItemClick; FExtraPaneItems := TdxBarExtraPaneItems.Create(Self); finally BarManager.LockDesignerModified(False, False); end; FButtons := TdxBarApplicationMenuButtons.Create(Self); end; destructor TdxBarApplicationMenu.Destroy; begin FreeAndNil(FButtons); FreeAndNil(FExtraPaneItems); FreeAndNil(FExtraPaneListItem); inherited; end; function TdxBarApplicationMenu.GetControlClass: TCustomdxBarControlClass; begin Result := TdxBarApplicationMenuControl; end; function TdxBarApplicationMenu.GetItemLinksClass: TdxBarItemLinksClass; begin Result := TdxBarApplicationMenuItemLinks; end; function TdxBarApplicationMenu.GetExtraPaneHeader: string; begin Result := FExtraPaneListItem.Caption; end; function TdxBarApplicationMenu.GetExtraPaneListItem: TdxBarExtraPaneListItem; var I: Integer; begin FExtraPaneListItem.Items.BeginUpdate; try FExtraPaneListItem.Items.Clear; for I := 0 to FExtraPaneItems.Count - 1 do FExtraPaneListItem.Items.Add(FExtraPaneItems[I].Text); finally FExtraPaneListItem.Items.EndUpdate; end; Result := FExtraPaneListItem; end; procedure TdxBarApplicationMenu.SetButtons(AValue: TdxBarApplicationMenuButtons); begin Buttons.Assign(AValue); end; procedure TdxBarApplicationMenu.SetExtraPaneItems(AValue: TdxBarExtraPaneItems); begin FExtraPaneItems.Assign(AValue); end; procedure TdxBarApplicationMenu.SetExtraPaneHeader(AValue: string); begin FExtraPaneListItem.Caption := AValue; end; procedure TdxBarApplicationMenu.ExtraPaneItemClick(Sender: TObject); begin if Assigned(OnExtraPaneItemClick) then OnExtraPaneItemClick(Self, FExtraPaneListItem.ItemIndex); end; function TdxBarApplicationMenu.IsExtraPaneHeaderStored: Boolean; begin Result := ExtraPaneHeader <> dxBarExtraPaneHeader; end; function TdxBarApplicationMenu.IsExtraPaneWidthRatioStored: Boolean; begin Result := FExtraPaneWidthRatio <> dxBarExtraPaneWidthRatio; end; { TdxDockControl } constructor TdxDockControl.Create(AOwner: TComponent); begin inherited Create(AOwner); FBackgroundBitmap := dxBarCreateBitmap(BitmapChanged); FBackgroundTempBitmap := TBitmap.Create; ParentColor := True; FAllowDocking := True; FRowMarginSize := InsertZone; FRowList := TList.Create; end; constructor TdxDockControl.CreateEx(AOwner: TComponent; ABarManager: TdxBarManager; ADockStyle: TdxBarDockingStyle); const Styles: array[dsLeft..dsBottom] of TAlign = (alLeft, alTop, alRight, alBottom); begin Create(AOwner); Align := Styles[ADockStyle]; ControlStyle := [csDoubleClicks, csNoDesignVisible]; if ADockStyle = dsTop then ControlStyle := ControlStyle + [csActionClient]; FDockingStyle := ADockStyle; BarManager := ABarManager; end; destructor TdxDockControl.Destroy; begin //#DG Destroying; AccessibilityHelperOwnerObjectDestroyed(FIAccessibilityHelper); BarManager := nil; while RowCount <> 0 do begin while Rows[0].ColCount <> 0 do Rows[0].DeleteCol(0); Rows[0].Free; RowList.Delete(0); end; FreeAndNil(FRowList); FreeAndNil(FBackgroundTempBitmap); FreeAndNil(FBackgroundBitmap); inherited Destroy; end; procedure TdxDockControl.BitmapChanged(Sender: TObject); begin Invalidate; UpdateDoubleBuffered; RepaintBarControls; end; function TdxDockControl.GetBars: TdxBars; begin if FBarManager = nil then Result := nil else Result := FBarManager.Bars; end; function TdxDockControl.GetDockingStyle: TdxBarDockingStyle; const Styles: array[TAlign] of TdxBarDockingStyle = (dsTop, dsTop, dsBottom, dsLeft, dsRight, dsTop{$IFDEF DELPHI6}, dsTop{$ENDIF}); begin Result := Styles[Align]; end; function TdxDockControl.GetHorizontal: Boolean; begin Result := DockingStyle in [dsTop, dsBottom]; end; function TdxDockControl.GetIAccessibilityHelper: IdxBarAccessibilityHelper; begin if FIAccessibilityHelper = nil then FIAccessibilityHelper := GetAccessibilityHelper(GetAccessibilityHelperClass.Create(Self)); Result := FIAccessibilityHelper; end; function TdxDockControl.GetIsDesigning: Boolean; begin Result := csDesigning in ComponentState; end; function TdxDockControl.GetIsLoading: Boolean; begin Result := csLoading in ComponentState; end; function TdxDockControl.GetMain: Boolean; begin Result := FDockingStyle <> dsNone; end; function TdxDockControl.GetRow(Index: Integer): TdxDockRow; begin Result := FRowList[Index]; end; function TdxDockControl.GetRowCount: Integer; begin Result := FRowList.Count; end; function TdxDockControl.GetTopLeft: Boolean; begin Result := DockingStyle in [dsLeft, dsTop]; end; function TdxDockControl.GetVertical: Boolean; begin Result := DockingStyle in [dsLeft, dsRight]; end; procedure TdxDockControl.SetBarManager(Value: TdxBarManager); begin if FBarManager <> Value then begin if FBarManager <> nil then FBarManager.RemoveDockControl(Self); FBarManager := Value; if FBarManager <> nil then FBarManager.AddDockControl(Self); BarManagerChanged; end; end; procedure TdxDockControl.SetBackgroundBitmap(Value: TBitmap); var AChanged: Boolean; begin AChanged := not ((Value = nil) and FBackgroundBitmap.Empty); FBackgroundBitmap.Assign(Value); if AChanged then BitmapChanged(nil); end; procedure TdxDockControl.WMDestroy(var Message: TMessage); begin if FBarManager <> nil then FBarManager.CreateBarRestoringList; inherited; end; procedure TdxDockControl.WMEraseBkgnd(var Message: TWMEraseBkgnd); var R: TRect; begin R := ClientRect; FillBackground(Message.DC, R, R, 0, Color); Message.Result := 1; end; procedure TdxDockControl.WMGetObject(var Message: TMessage); begin // if CanReturnAccessibleObject(Message) then // Message.Result := WMGetObjectResultFromIAccessibilityHelper(Message, IAccessibilityHelper) // else inherited; end; procedure TdxDockControl.WMLButtonDblClk(var Message: TWMLButtonDblClk); begin if (FBarManager <> nil) and FBarManager.CanCustomize then FBarManager.Customizing(True); Message.Result := 0; end; procedure TdxDockControl.WMMouseActivate(var Message: TWMMouseActivate); begin inherited; if (FBarManager <> nil) and not IsDesigning and (GetParentPopupWindow(Self, True) = nil) then begin Message.Result := MA_NOACTIVATE; dxSetZOrder(MainForm.Handle, HWND_TOP, True); end; end; procedure TdxDockControl.WMNCCalcSize(var Message: TWMNCCalcSize); begin inherited; if SunkenBorder then InflateRect(Message.CalcSize_Params.rgrc[0], -1, -1); end; procedure TdxDockControl.WMNCPaint(var Message: TWMNCPaint); var R: TRect; DC: HDC; begin inherited; if SunkenBorder then begin GetWindowRect(Handle, R); OffsetRect(R, -R.Left, -R.Top); DC := GetWindowDC(Handle); DrawEdge(DC, R, BDR_SUNKENOUTER, BF_RECT); ReleaseDC(Handle, DC); end; end; procedure TdxDockControl.WMSize(var Message: TWMSize); begin ResetBackground; inherited; end; procedure TdxDockControl.WMRButtonDown(var Message: TWMRButtonDown); begin inherited; if (FBarManager <> nil) and not FBarManager.IsCustomizing then ShowCustomizePopup; end; procedure TdxDockControl.WMWindowPosChanged(var Message: TWMWindowPosChanged); var I, J: Integer; begin inherited; if (BarManager <> nil) and (Message.WindowPos^.flags and (SWP_NOMOVE or SWP_NOSIZE) <> SWP_NOMOVE or SWP_NOSIZE) then begin Inc(BarManager.FLockUpdateCount); try if DockingStyle = dsBottom then for I := 0 to RowCount - 1 do for J := 0 to Rows[I].ColCount - 1 do with Rows[I].Cols[J].BarControl do if Bar.IsStatusBar then RebuildBar; finally Dec(BarManager.FLockUpdateCount); end; if IsTransparent then RepaintBarControls; end; end; procedure TdxDockControl.CMSysColorChange(var Message: TMessage); begin inherited; if IsWin95Or98 and Main and (DockingStyle = dsLeft) then BarManager.OwnerWndProc(0, WM_SYSCOLORCHANGE, 0, 0); end; procedure TdxDockControl.AlignControls(AControl: TControl; var Rect: TRect); begin if (FBarManager <> nil) and not FBarManager.IsLoading then UpdateDock; end; procedure TdxDockControl.CreateParams(var Params: TCreateParams); begin inherited CreateParams(Params); with Params do begin Style := WS_CHILD or WS_CLIPCHILDREN or WS_CLIPSIBLINGS; ExStyle := 0; WindowClass.Style := CS_DBLCLKS; end; end; procedure TdxDockControl.Notification(AComponent: TComponent; Operation: TOperation); begin inherited; if (Operation = opRemove) and (AComponent = BarManager) then BarManager := nil; end; procedure TdxDockControl.RequestAlign; begin if not (csDestroyingHandle in ControlState) then inherited; end; procedure TdxDockControl.AddBarControl(ABarControl: TdxBarControl; APos: TPoint; Update: Boolean); var Ins: Boolean; ARow, ACol, I: Integer; DockRow: TdxDockRow; DockCol: TdxDockCol; begin if BarManager = nil then Exit; Ins := False; ARow := 0; if ABarControl <> nil then begin if not ABarControl.InternallyLocked then ARow := GetRowAtPos(APos, Ins) else if ABarControl.Bar <> nil then begin if IsMultiRow then ARow := ABarControl.Bar.Row else ARow := 0; Ins := ABarControl.Bar.OneOnRow; end; if (ABarControl.Bar <> nil) and ABarControl.Bar.WholeRow then Ins := True; end; if ABarControl.InternallyLocked and (BarManager.BarsLoading or BarManager.IsHandleCreating) and (ARow > FRowList.Count - 1) then for I := FRowList.Count to ARow do FRowList.Insert(I, TdxDockRow.Create(Self)) else begin if ARow > FRowList.Count - 1 + Byte(Ins) then begin //Ins := True; ARow := FRowList.Count - Byte(not Ins){!}; end; if ARow < 0 then ARow := 0; end; if ARow >= FRowList.Count then Ins := True; if not Ins then for I := 0 to Rows[ARow].ColCount - 1 do with Rows[ARow].Cols[I] do if BarControl.Bar.WholeRow and (BarControl <> ABarControl) then begin Ins := True; Break; end; // if (ABarControl <> nil) and (ABarControl.DockControl = Self) and // (ABarControl.Bar <> nil) and (ABarControl.Bar.DockRow <> nil) and // (RowList.IndexOf(ABarControl.Bar.DockRow) = ARow) then // Ins := False; if Ins then begin if ABarControl.InternallyLocked and (BarManager.BarsLoading or BarManager.IsHandleCreating) then DockRow := Rows[ARow] else begin DockRow := TdxDockRow.Create(Self); FRowList.Insert(ARow, DockRow); end; DockCol := DockRow.AddCol(ABarControl); ABarControl.FBar.SetDockRow(DockRow); end else begin DockCol := TdxDockCol.Create(TdxDockRow(FRowList[ARow]), ABarControl); ACol := GetColAtPos(ARow, APos); GetColAtPos(ARow, APos); Rows[ARow].ColList.Insert(ACol, DockCol); Rows[ARow].UpdateOneOnRows; ABarControl.FBar.SetDockRow(Rows[ARow]); end; if not ABarControl.InternallyLocked then begin with Bars, FMovingOffset do if FMoving then begin Dec(APos.X, X); Dec(APos.Y, Y); end; with ABarControl, GetDragPointOffset(DockingStyle) do begin Dec(APos.X, X); Dec(APos.Y, Y); end; end; Windows.ScreenToClient(Handle, APos); case Horizontal of True: if APos.X < 0 then APos.X := 0; False: if APos.Y < 0 then APos.Y := 0; end; DockCol.FPos := APos; if Update then begin if not {Bars.}ABarControl.FMoving then with ABarControl do begin Left := APos.X; Top := APos.Y; end; UpdateDock; if not BarManager.BarsLoading and not BarManager.IsHandleCreating then DockCol.AssignPosition; end; end; procedure TdxDockControl.DeleteBarControl(ABarControl: TdxBarControl; ADockCol: TObject; Update: Boolean); var I, J: Integer; procedure DeleteCol; begin Rows[I].DeleteCol(J); if Update then UpdateDock; end; var ADockRow: TdxDockRow; begin if BarManager = nil then Exit; for I := 0 to RowCount - 1 do begin ADockRow := Rows[I]; if ADockCol <> nil then begin J := ADockRow.ColList.IndexOf(ADockCol); if J > -1 then begin DeleteCol; Exit; end; end else for J := 0 to ADockRow.ColCount - 1 do if ADockRow.Cols[J].BarControl = ABarControl then begin DeleteCol; Exit; end; end; end; procedure TdxDockControl.MoveBarControl(ABarControl: TdxBarControl; APos: TPoint); var DockCol: Pointer; begin if FBarManager = nil then Exit; DockCol := Rows[ABarControl.GetRow].Cols[ABarControl.GetCol]; DeleteBarControl(ABarControl, DockCol, False); AddBarControl(ABarControl, APos, True); if IsTransparent then begin ResetBackground; RepaintBarControls; end; end; procedure TdxDockControl.AssignPositions; var I, J: Integer; begin for I := 0 to RowCount - 1 do with Rows[I] do for J := 0 to ColCount - 1 do Cols[J].AssignPosition; end; procedure TdxDockControl.BarManagerChanged; begin ResetBackground; end; procedure TdxDockControl.CalcLayout; var AClientSize, I: Integer; begin if Vertical then AClientSize := ClientHeight else AClientSize := ClientWidth; for I := 0 to RowCount - 1 do if Rows[I].Visible then CalcRowToolbarPositions(I, AClientSize); end; procedure TdxDockControl.CalcRowToolbarPositions(ARowIndex: Integer; AClientSize: Integer); function GetMinSize(ABarControl: TdxBarControl): Integer; begin if Vertical then Result := ABarControl.GetMinHeight(DockingStyle) else Result := ABarControl.GetMinWidth(DockingStyle); end; function GetMaxSizeX(ABarControl: TdxBarControl): Integer; begin if Vertical then Result := ABarControl.GetMaxHeight(DockingStyle) else Result := ABarControl.GetMaxWidth(DockingStyle); end; function GetMaxSizeY(ABarControl: TdxBarControl): Integer; begin if Vertical then Result := ABarControl.GetMaxWidth(DockingStyle) else Result := ABarControl.GetMaxHeight(DockingStyle); end; function NCSizeX(ABarControl: TdxBarControl): Integer; begin if Vertical then Result := ABarControl.Bar.BarNCSizeY(DockingStyle) else Result := ABarControl.Bar.BarNCSizeX(DockingStyle); end; function NCSizeY(ABarControl: TdxBarControl): Integer; begin if Vertical then Result := ABarControl.Bar.BarNCSizeX(DockingStyle) else Result := ABarControl.Bar.BarNCSizeY(DockingStyle); end; function GetFullSize(ABarControl: TdxBarControl; ASize: Integer): TPoint; var ATemp: Integer; begin Dec(ASize, NCSizeX(ABarControl)); if ABarControl.FTruncated and not Painter.BarAllowQuickCustomizing then Dec(ASize, Painter.MarkSizeX); if Vertical then begin Result := ABarControl.GetSizeForHeight(DockingStyle, ASize); ATemp := Result.X; Result.X := Result.Y; Result.Y := ATemp; end else Result := ABarControl.GetSizeForWidth(DockingStyle, ASize); end; var ABarControl, ATempBarControl: TdxBarControl; AFixedSize, ALenMax, AMargin, AMaxHeight, AMaxSize, AMinSize, APos, ARestSize, ARowLen, ASize, ATemp, J, K: Integer; ACol, ATempCol: TdxDockCol; ARow: TdxDockRow; AVertical: Boolean; R: TRect; begin ARow := Rows[ARowIndex]; AVertical := Vertical; ALenMax := 0; for J := 0 to ARow.ColCount - 1 do begin ABarControl := ARow.Cols[J].BarControl; ABarControl.FTruncated := False; ABarControl.ItemLinks.RecentItemCount := -1; ABarControl.FMinSize := GetMinSize(ABarControl) + NCSizeX(ABarControl); ABarControl.FMaxSize := GetMaxSizeX(ABarControl) + NCSizeX(ABarControl); if not ABarControl.MarkExists and (ABarControl.FMinSize <> ABarControl.FMaxSize) then Inc(ABarControl.FMinSize, Painter.MarkSizeX); Inc(ALenMax, ABarControl.FMaxSize); end; R := GetRectForRow(ARowIndex); if AVertical then begin ATemp := R.Left; R.Left := R.Top; R.Top := ATemp; end; ARowLen := AClientSize; AMaxHeight := 0; if (ARow.ColCount > 0) and ARow.Cols[0].BarControl.Bar.WholeRow then begin ABarControl := ARow.Cols[0].BarControl; ABarControl.NewLeft := R.Left; ABarControl.NewTop := R.Top; ABarControl.NewWidth := ARowLen; if ABarControl.NewWidth < ABarControl.FMinSize then ABarControl.NewWidth := ABarControl.FMinSize; ABarControl.FTruncated := not ABarControl.MultiLine and (ABarControl.NewWidth < ABarControl.FMaxSize); ABarControl.NewHeight := GetFullSize(ABarControl, ABarControl.NewWidth).Y + NCSizeY(ABarControl); if ABarControl.NewHeight > AMaxHeight then AMaxHeight := ABarControl.NewHeight; end else if ALenMax <= ARowLen then begin AMargin := ARowLen; for J := ARow.ColCount - 1 downto 0 do begin ACol := ARow.Cols[J]; ABarControl := ACol.BarControl; ABarControl.NewTop := R.Top; ABarControl.NewWidth := ABarControl.FMaxSize; if ABarControl.MultiLine then ABarControl.NewHeight := GetFullSize(ABarControl, ABarControl.NewWidth).Y else ABarControl.NewHeight := GetMaxSizeY(ABarControl); Inc(ABarControl.NewHeight, NCSizeY(ABarControl)); if ABarControl.NewHeight > AMaxHeight then AMaxHeight := ABarControl.NewHeight; if AVertical then APos := ACol.Pos.Y else APos := ACol.Pos.X; if APos + ABarControl.NewWidth <= AMargin then ABarControl.NewLeft := APos else ABarControl.NewLeft := AMargin - ABarControl.NewWidth; AFixedSize := 0; for K := 0 to J - 1 do Inc(AFixedSize, ARow.Cols[K].BarControl.FMaxSize); if ABarControl.NewLeft < AFixedSize then ABarControl.NewLeft := AFixedSize; AMargin := ABarControl.NewLeft; end; end else begin ASize := ARowLen; for J := ARow.ColCount - 1 downto 0 do begin ACol := ARow.Cols[J]; ABarControl := ACol.BarControl; if AVertical then AFixedSize := ACol.Pos.Y else AFixedSize := ACol.Pos.X; AMinSize := 0; AMaxSize := 0; for K := J - 1 downto 0 do begin Inc(AMinSize, ARow.Cols[K].BarControl.FMinSize); Inc(AMaxSize, ARow.Cols[K].BarControl.FMaxSize); end; if AFixedSize < AMinSize then AFixedSize := AMinSize; if AFixedSize > AMaxSize then AFixedSize := AMaxSize; if (J > 0) and (ARow.Cols[J - 1].BarControl = Bars.FMovingBarControl) then begin ATempCol := ARow.Cols[J - 1]; ATempBarControl := ATempCol.BarControl; if AVertical then K := ATempCol.Pos.Y else K := ATempCol.Pos.X; if K < AMinSize - ATempBarControl.FMinSize then K := AMinSize - ATempBarControl.FMinSize; Inc(K, ATempBarControl.FMaxSize); if K < AFixedSize then begin if AVertical then ACol.FPos.Y := K else ACol.FPos.X := K; AFixedSize := K; end; end; ARestSize := ASize - AFixedSize; if ARestSize >= ABarControl.FMaxSize then begin ABarControl.NewWidth := ABarControl.FMaxSize; if ABarControl.MultiLine then ABarControl.NewHeight := GetFullSize(ABarControl, ABarControl.NewWidth).Y else ABarControl.NewHeight := GetMaxSizeY(ABarControl); end else begin ABarControl.FTruncated := not ABarControl.MultiLine and (ABarControl.FMinSize <> ABarControl.FMaxSize); if ARestSize <= ABarControl.FMinSize then ABarControl.NewWidth := ABarControl.FMinSize else ABarControl.NewWidth := ARestSize; ABarControl.NewHeight := GetFullSize(ABarControl, ABarControl.NewWidth).Y; end; if (J = 0) and (ASize > ABarControl.NewWidth) then ABarControl.NewWidth := ASize; ABarControl.NewLeft := ASize - ABarControl.NewWidth; if ABarControl.NewLeft < AMinSize then ABarControl.NewLeft := AMinSize; if ABarControl.NewLeft > AMaxSize then ABarControl.NewLeft := AMaxSize; ABarControl.NewTop := R.Top; Inc(ABarControl.NewHeight, NCSizeY(ABarControl)); if ABarControl.NewHeight > AMaxHeight then AMaxHeight := ABarControl.NewHeight; Dec(ASize, ABarControl.NewWidth); end; end; for J := 0 to ARow.ColCount - 1 do begin ABarControl := ARow.Cols[J].BarControl; if ABarControl.Bar.UseRestSpace then begin if J = 0 then ABarControl.NewLeft := 0 else begin ATempBarControl := ARow.Cols[J - 1].BarControl; ABarControl.NewLeft := ATempBarControl.NewLeft + ATempBarControl.NewWidth; end; if J = ARow.ColCount - 1 then ABarControl.NewWidth := AClientSize - ABarControl.NewLeft else ABarControl.NewWidth := ARow.Cols[J + 1].BarControl.NewLeft - ABarControl.NewLeft; if ABarControl.NewWidth < ABarControl.FMinSize then ABarControl.NewWidth := ABarControl.FMinSize; end; end; for J := 0 to ARow.ColCount - 1 do begin ABarControl := ARow.Cols[J].BarControl; if ABarControl.FTruncated and (J = ARow.ColCount - 1) then begin ABarControl.NewWidth := AClientSize - ABarControl.NewLeft; if ABarControl.NewWidth < ABarControl.FMinSize then ABarControl.NewWidth := ABarControl.FMinSize; end; ABarControl.NewHeight := AMaxHeight; // for the RecentItemCount calculating GetFullSize(ABarControl, ABarControl.NewWidth); if AVertical then begin ATemp := ABarControl.NewLeft; ABarControl.NewLeft := ABarControl.NewTop; ABarControl.NewTop := ATemp; ATemp := ABarControl.NewWidth; ABarControl.NewWidth := ABarControl.NewHeight; ABarControl.NewHeight := ATemp; end; if (ABarControl.Left <> ABarControl.NewLeft) or (ABarControl.Top <> ABarControl.NewTop) or (ABarControl.Width <> ABarControl.NewWidth) or (ABarControl.Height <> ABarControl.NewHeight) then SetWindowPos(ABarControl.Handle, 0, ABarControl.NewLeft, ABarControl.NewTop, ABarControl.NewWidth, ABarControl.NewHeight, SWP_NOZORDER or SWP_NOACTIVATE); ABarControl.CalcLayout; end; end; function TdxDockControl.CanDocking(Bar: TdxBar): Boolean; begin Result := FAllowDocking; end; procedure TdxDockControl.ColorChanged; begin if (FBarManager = nil) or FBarManager.AutoDockColor then ParentColor := True else Color := FBarManager.DockColor; end; function TdxDockControl.GetDockZoneBounds: TRect; begin Result := BoundsRect; InflateRect(Result, Bars.DockingZoneSize, Byte(Horizontal) * Bars.DockingZoneSize); MapWindowRect(GetParent(Handle), 0, Result); end; procedure TdxDockControl.GetDockZoneMargins(Row, ZoneNumber: Integer; var M1, M2: Integer); var IM1, IM2: Integer; begin M1 := 0; M2 := 0; if Row = -1 then if TopLeft then begin M1 := -Bars.DockingZoneSize; M2 := 0; end else begin if DockingStyle = dsRight then M1 := ClientWidth else M1 := ClientHeight; M1 := M1 - GetClientSize - Bars.DockingZoneSize; M2 := M1 + Bars.DockingZoneSize; end else if Row = FRowList.Count then if TopLeft then begin M1 := GetClientSize; M2 := M1 + Bars.DockingZoneSize; end else begin if DockingStyle = dsRight then M1 := ClientWidth else M1 := ClientHeight; M2 := M1 + Bars.DockingZoneSize; end else with GetRectForRow(Row) do if Horizontal then begin M1 := Top; M2 := Bottom; end else begin M1 := Left; M2 := Right; end; case DockingStyle of dsLeft, dsTop: IM1 := M1 + (Bars.DockingZoneSize - InsertZone div 2) div 2; dsRight, dsBottom: IM1 := M2 - (Bars.DockingZoneSize - InsertZone div 2) div 2 - InsertZone div 2; else IM1 := 0; end; IM2 := IM1 + InsertZone div 2; case ZoneNumber of 0: M2 := IM1; 1: begin M1 := IM1; M2 := IM2; end; 2: M1 := IM2; end; end; function TdxDockControl.GetRectForRow(ARow: Integer): TRect; var I: Integer; Origin, Size: Integer; function GetRowHeight(ARow: Integer): Integer; var J: Integer; begin Result := 0; if not Rows[ARow].Visible then Exit; for J := 0 to Rows[ARow].ColCount - 1 do with TdxDockCol(Rows[ARow].Cols[J]).BarControl do case Self.DockingStyle of dsLeft, dsRight: if Result < Width then Result := Width; dsTop, dsBottom: if Result < Height then Result := Height; end; end; begin SetRectEmpty(Result); if (ARow < 0) or (ARow > FRowList.Count - 1) then Exit; Size := 0; if not Bars.FMoving or (DockingStyle in [dsLeft, dsTop]) then begin Origin := 0; for I := 0 to ARow do begin Inc(Origin, Size); Size := GetRowHeight(I); end; end else begin if DockingStyle = dsRight then Origin := ClientWidth else Origin := ClientHeight; for I := FRowList.Count - 1 downto ARow do begin Size := GetRowHeight(I); Dec(Origin, Size); end; end; case DockingStyle of dsLeft, dsRight: Result := Bounds(Origin, 0, Size, ClientHeight); dsTop, dsBottom: Result := Bounds(0, Origin, ClientWidth, Size); end; end; function TdxDockControl.GetClientSize: Integer; var I: Integer; R: TRect; begin Result := 0; case DockingStyle of dsLeft, dsRight: for I := 0 to FRowList.Count - 1 do begin R := GetRectForRow(I); Inc(Result, R.Right - R.Left); end; dsTop, dsBottom: for I := 0 to FRowList.Count - 1 do begin R := GetRectForRow(I); Inc(Result, R.Bottom - R.Top); end; end; end; function TdxDockControl.GetSize: Integer; begin Result := GetClientSize; if (Result > 0) and SunkenBorder then Inc(Result, 2); end; function TdxDockControl.GetRowAtPos(APos: TPoint; var Insert: Boolean): Integer; var I, J, Z, M1, M2: Integer; Found: Boolean; begin if FRowList.Count = 0 then begin Result := 0; Insert := True; Exit; end; Result := -1; Insert := False; Windows.ScreenToClient(Handle, APos); if Vertical then Z := APos.X else Z := APos.Y; Found := False; for I := -1 to FRowList.Count - 1 do begin for J := 0 to 2 do begin GetDockZoneMargins(I, J, M1, M2); if (M1 <= Z) and (Z < M2) then begin Result := I + Byte(J > 0); Insert := J = 1; Found := True; Break; end; end; if Found then Break; end; if Result = -1 then begin Insert := True; if Z >= GetClientSize then Result := FRowList.Count else Result := 0; end else if Result >= RowCount then Insert := True; end; function TdxDockControl.GetColAtPos(ARow: Integer; APos: TPoint): Integer; var I: Integer; begin Result := 0; if (FRowList[ARow] = nil) or (Rows[ARow].ColCount = 0) then Exit; Windows.ScreenToClient(Handle, APos); if Bars.FMoving and not Bars.FMovingBarControl.InternallyLocked then with Bars.FMovingBarControl.GetDragPointOffset(DockingStyle) do case DockingStyle of dsLeft, dsRight: Dec(APos.Y, Y); dsTop, dsBottom: Dec(APos.X, X); end; with Rows[ARow] do begin for I := 0 to ColCount - 1 do with Cols[I], BarControl.Bar do case DockingStyle of dsLeft, dsRight: if APos.Y <= DockedTop then begin Result := I; Exit; end; dsTop, dsBottom: if APos.X <= DockedLeft then begin Result := I; Exit; end; end; Result := ColCount; end; end; procedure TdxDockControl.GetPosForRow(Row: Integer; OneOnRow: Boolean; var P: TPoint); var M1, M2, Temp: Integer; begin if OneOnRow and (Row = FRowList.Count) then OneOnRow := False; if OneOnRow then GetDockZoneMargins(Row - 1, 1, M1, M2) else begin GetDockZoneMargins(Row - 1, 2, M1, Temp); GetDockZoneMargins(Row, 0, Temp, M2); if Temp - M1 > M2 - Temp then M1 := Temp - (M2 - Temp); end; Temp := (M1 + M2) div 2; Windows.ScreenToClient(Handle, P); if Vertical then P.X := Temp else P.Y := Temp; Windows.ClientToScreen(Handle, P); end; function TdxDockControl.GetSunkenBorder: Boolean; begin if BarManager = nil then Result := False else Result := BarManager.SunkenBorder; end; function TdxDockControl.GetMainForm: TCustomForm; begin Result := GetControlForm(Self, fkMain); if (Result = nil) and (BarManager <> nil) then // Result.HandleAllocated? Result := BarManager.GetMainForm; end; function TdxDockControl.GetMasterForm: TCustomForm; begin Result := GetControlForm(Self, fkMainOrMDIChild); if (Result = nil) and (BarManager <> nil) then // Result.HandleAllocated? Result := BarManager.MasterForm; end; function TdxDockControl.GetParentForm: TCustomForm; begin Result := GetControlForm(Self, fkAny); if (Result = nil) and (BarManager <> nil) then // Result.HandleAllocated? Result := BarManager.ParentForm; end; function TdxDockControl.IsMultiRow: Boolean; begin Result := True; end; procedure TdxDockControl.NCChanged; var I, J: Integer; begin if not HandleAllocated then Exit; SetWindowPos(Handle, 0, 0, 0, 0, 0, SWP_NOZORDER or SWP_NOMOVE or SWP_NOSIZE or SWP_NOACTIVATE or SWP_FRAMECHANGED); for I := 0 to RowCount - 1 do for J := 0 to Rows[I].ColCount - 1 do Rows[I].Cols[J].BarControl.FrameChanged{RebuildBar}; UpdateDock; end; procedure TdxDockControl.PaintBarControls; begin if (RowList = nil) or (BarManager = nil) or BarManager.BarsLoading or BarManager.IsDestroying then Exit; if not BarManager.Designing and HandleAllocated then dxSetZOrder(Handle, HWND_TOP); DisableAlign; try CalcLayout; finally EnableAlign; end; Repaint; end; procedure TdxDockControl.SetSize; function Appropriate(var Variable; Value: TObject): Boolean; begin TObject(Variable) := TObject(Value); Result := True; end; function IsCurrentDockControl(AParentBar: TCustomdxBarControl): Boolean; begin Result := (AParentBar <> nil) and not ((AParentBar is TdxBarControl) and (Self is TdxBarDockControl) and not (TdxBarControl(AParentBar).DockControl is TdxBarDockControl) or (AParentBar.BarManager <> BarManager) and (Forms.GetParentForm(Self) <> nil)); end; var ASize, PrevSize: Integer; AParentBar: TCustomdxBarControl; begin ASize := GetSize; PrevSize := 0; case DockingStyle of dsLeft, dsRight: begin PrevSize := Width; if DockingStyle = dsRight then begin Parent.DisableAlign; Left := Left - (ASize - Width); end; Width := ASize; if DockingStyle = dsRight then Parent.EnableAlign; end; dsTop, dsBottom: begin PrevSize := Height; if DockingStyle = dsBottom then begin Parent.DisableAlign; Top := Top - (ASize - Height); end; Height := ASize; if DockingStyle = dsBottom then Parent.EnableAlign; end; end; if Visible and (ASize <> PrevSize) and (ActiveBarControl <> nil) and Appropriate(AParentBar, GetParentBarForBar(ActiveBarControl)) and not (AParentBar is TdxbarQuickControl) and (ActiveBarControl.Handle <> GetCapture) and IsCurrentDockControl(AParentBar) then ActiveBarControl.HideAll; end; procedure TdxDockControl.ShowCustomizePopup; begin BarDesignController.ShowToolbarsPopup(FBarManager, Painter); end; procedure TdxDockControl.UpdateDock; begin if (BarManager <> nil) and not BarManager.IsUpdateLocked and not BarManager.IsDestroying then begin PaintBarControls; SetSize; end; end; function TdxDockControl.GetDockedBarControlClass: TdxBarControlClass; begin Result := TdxBarControl; end; function TdxDockControl.GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; begin Result := TdxDockControlAccessibilityHelper; end; function TdxDockControl.GetPainter: TdxBarPainter; begin Result := BarManager.DefaultPainter; end; procedure TdxDockControl.FillBackground(DC: HDC; const ADestR, ASourceR: TRect; ABrush: HBRUSH; AColor: TColor); var CR: TRect; begin if not BackgroundBitmap.Empty or (BarManager = nil) then FillBackgroundRect(DC, ADestR, ASourceR, ABrush, AColor, BackgroundBitmap) else begin if not BarManager.Backgrounds.Bar.Empty then FillBackgroundRect(DC, ADestR, ASourceR, ABrush, AColor, BarManager.Backgrounds.Bar) else begin CR := ClientRect; if not IsRectEmpty(CR) then Painter.DockControlFillBackground(Self, DC, ADestR, ASourceR, CR, ABrush, AColor) end; end; end; function TdxDockControl.IsBackgroundBitmap: Boolean; begin Result := not BackgroundBitmap.Empty; end; function TdxDockControl.IsDrawDesignBorder: Boolean; begin Result := IsDesigning; end; function TdxDockControl.IsTransparent: Boolean; begin Result := not BackgroundBitmap.Empty or ((BarManager <> nil) and (Painter.IsNativeBackground or not BarManager.Backgrounds.Bar.Empty)); end; procedure TdxDockControl.RepaintBarControls; var I, J: Integer; begin for I := 0 to RowCount - 1 do for J := 0 to Rows[I].ColCount - 1 do Rows[I].Cols[J].BarControl.FullRepaint; end; procedure TdxDockControl.ResetBackground; begin FBackgroundTempBitmap.Assign(nil); end; procedure TdxDockControl.UpdateDoubleBuffered; begin DoubleBuffered := IsTransparent; end; procedure TdxDockControl.InitiateAction; var I: Integer; begin if FBarManager <> nil then with FBarManager do for I := 0 to Bars.Count - 1 do with Bars[I] do if Visible then ItemLinks.InitiateActions; end; { TdxBarDockControl } constructor TdxBarDockControl.Create(AOwner: TComponent); begin inherited; Align := dalTop; end; function TdxBarDockControl.GetAlign: TdxBarDockAlign; begin Result := TdxBarDockAlign(inherited Align); end; function TdxBarDockControl.GetColor: TColor; begin Result := inherited Color; end; function TdxBarDockControl.GetIsLoading: Boolean; begin Result := (csLoading in ComponentState) or (BarManager <> nil) and BarManager.BarsLoading; end; function TdxBarDockControl.GetParentColor: Boolean; begin Result := inherited ParentColor; end; procedure TdxBarDockControl.SetAlign(Value: TdxBarDockAlign); const Styles: array[TdxBarDockAlign] of TdxBarDockingStyle = (dsTop, dsTop, dsBottom, dsLeft, dsRight); var I, J: Integer; begin if Align <> Value then begin if BarManager <> nil then BarManager.BeginUpdate; try for I := 0 to RowCount - 1 do for J := 0 to Rows[I].ColCount - 1 do Rows[I].Cols[J].BarControl.DockingStyle := Styles[Value]; inherited Align := TAlign(Value); finally if BarManager <> nil then begin BarManager.EndUpdate; for I := 0 to RowCount - 1 do for J := 0 to Rows[I].ColCount - 1 do Rows[I].Cols[J].BarControl.RepaintBar; if Parent <> nil then Parent.Invalidate; end; end; end; end; procedure TdxBarDockControl.SetAllowZeroSizeInDesignTime(Value: Boolean); begin if FAllowZeroSizeInDesignTime <> Value then begin FAllowZeroSizeInDesignTime := Value; Perform(WM_SIZE, 0, 0); end; end; procedure TdxBarDockControl.SetColor(Value: TColor); begin if Color <> Value then begin inherited Color := Value; if not IsLoading then UseOwnColor := True; end; end; procedure TdxBarDockControl.SetParentColor(Value: Boolean); begin if ParentColor <> Value then begin inherited ParentColor := Value; if not IsLoading then UseOwnColor := True; end; end; procedure TdxBarDockControl.SetSunkenBorder(Value: Boolean); begin if SunkenBorder <> Value then begin FSunkenBorder := Value; FUseOwnSunkenBorder := True; NCChanged; end; end; procedure TdxBarDockControl.SetUseOwnColor(Value: Boolean); begin if FUseOwnColor <> Value then begin FUseOwnColor := Value; if not Value then ColorChanged; end; end; procedure TdxBarDockControl.SetUseOwnSunkenBorder(Value: Boolean); var PrevSunkenBorder: Boolean; begin if FUseOwnSunkenBorder <> Value then begin PrevSunkenBorder := SunkenBorder; FUseOwnSunkenBorder := Value; if Value then FSunkenBorder := PrevSunkenBorder else if SunkenBorder <> PrevSunkenBorder then NCChanged; end; end; function TdxBarDockControl.IsColorStored: Boolean; begin Result := FUseOwnColor and not ParentColor; end; procedure TdxBarDockControl.WMCreate(var Message: TWMCreate); begin inherited; if BarManager <> nil then BarManager.ShowBarsFromRestoringList(Self); end; procedure TdxBarDockControl.WMSize(var Message: TWMSize); begin inherited; if not IsLoading and (RowCount = 0) then if Horizontal then ClientHeight := GetMinSize else ClientWidth := GetMinSize; end; procedure TdxBarDockControl.CreateParams(var Params: TCreateParams); begin inherited; if IsDesigning then with Params do WindowClass.Style := WindowClass.Style or CS_HREDRAW or CS_VREDRAW; end; procedure TdxBarDockControl.Paint; begin inherited; if IsDrawDesignBorder then begin Canvas.Brush.Style := bsClear; Canvas.Pen.Style := psDot; Canvas.Rectangle(0, 0, ClientWidth, ClientHeight); Canvas.Pen.Style := psSolid; Canvas.Brush.Style := bsSolid; end; end; procedure TdxBarDockControl.BarManagerChanged; begin inherited; if not (csDestroying in ComponentState) then begin ColorChanged; NCChanged; end; end; function TdxBarDockControl.CanDocking(Bar: TdxBar): Boolean; begin Result := inherited CanDocking(Bar) and ((Bar.Control = nil) or not HasAsParent(Handle, Bar.Control.Handle)); end; procedure TdxBarDockControl.ColorChanged; begin if not FUseOwnColor then begin inherited; FUseOwnColor := False; end; end; function TdxBarDockControl.GetClientSize: Integer; begin if IsLoading then if Horizontal then Result := ClientHeight else Result := ClientWidth else begin Result := inherited GetClientSize; if Result = 0 then Result := GetMinSize; end; end; function TdxBarDockControl.GetMinSize: Integer; begin if IsDesigning and not AllowZeroSizeInDesignTime then Result := MinDockSize else Result := 0; end; function TdxBarDockControl.GetSunkenBorder: Boolean; begin if FUseOwnSunkenBorder then Result := FSunkenBorder else Result := inherited GetSunkenBorder; end; { TdxBarShadowPart } constructor TdxBarShadowPart.CreateEx(AOwner: TdxBarShadow; AKind: TdxBarShadowPartKind; ACorners: TdxBarShadowCorners); begin Create(nil); FOwner := AOwner; FKind := AKind; FCorners := ACorners; FImage := TBitmap.Create; end; destructor TdxBarShadowPart.Destroy; begin FreeAndNil(FImage); inherited; end; function TdxBarShadowPart.GetControl: TWinControl; begin Result := FOwner.Owner; end; function TdxBarShadowPart.GetShadowSize: Integer; begin Result := FOwner.ShadowSize; end; function TdxBarShadowPart.GetTransparent: Boolean; begin Result := FOwner.Transparent; end; procedure TdxBarShadowPart.WMNCHitTest(var Message: TWMNCHitTest); begin inherited; Message.Result := HTTRANSPARENT; end; function TdxBarShadowPart.CanShow: Boolean; begin Result := (FCorners = []) or (Width >= ShadowSize) and (Height >= ShadowSize); end; procedure TdxBarShadowPart.CreateParams(var Params: TCreateParams); begin inherited; with Params do begin Style := WS_POPUP; if Transparent then ExStyle := WS_EX_LAYERED else ExStyle := 0; if GetWindowLong(Control.Handle, GWL_EXSTYLE) and WS_EX_TOPMOST <> 0 then ExStyle := ExStyle or WS_EX_TOPMOST; WndParent := Control.Handle; WindowClass.style := 0; end; end; procedure TdxBarShadowPart.Paint; begin with Canvas do begin Brush.Color := clBtnShadow; FillRect(ClientRect); end; end; procedure TdxBarShadowPart.UpdateImage; var AColors: TRGBColors; function GetAlphaIndex(X, Y: Integer): Integer; begin Result := Y * Width + X; end; function GetAlpha(X, Y: Integer): Byte; begin Result := AColors[GetAlphaIndex(X, Y)].rgbReserved; end; procedure SetAlpha(X, Y: Integer; Value: Byte); begin AColors[GetAlphaIndex(X, Y)].rgbReserved := Value; end; procedure ProcessMainContent; const AlphaStep = 15; var X, Y: Integer; begin for X := 0 to Width - 1 do for Y := 0 to Height - 1 do if FKind = spHorizontal then SetAlpha(X, Y, (Height - Y) * AlphaStep) else SetAlpha(X, Y, (Width - X) * AlphaStep); end; procedure ProcessCorners; type TCornerKind = (ckLeft, ckRight, ckTop); procedure ProcessCorner(ACornerKind: TCornerKind); var I, J, X, Y: Integer; procedure ConvertCoordinates; begin case ACornerKind of ckLeft: begin X := I; Y := J; end; ckRight: begin X := Width - 1 - I; Y := J; end; ckTop: begin X := J; Y := I; end; end; end; begin for I := 0 to ShadowSize - 1 do for J := 0 to ShadowSize - 1 do begin ConvertCoordinates; SetAlpha(X, Y, MulDiv(GetAlpha(X, Y), 1 + I, 1 + ShadowSize)); end; end; begin if FKind = spHorizontal then begin if scLeft in FCorners then ProcessCorner(ckLeft); if scRight in FCorners then ProcessCorner(ckRight); end else if scTop in FCorners then ProcessCorner(ckTop); end; begin if not CanShow then Exit; FImage.PixelFormat := pf32bit; FImage.Width := Width; FImage.Height := Height; SetLength(AColors, Width * Height); ProcessMainContent; ProcessCorners; SetBitmapBits(FImage, AColors, True); end; procedure TdxBarShadowPart.Hide; begin if HandleAllocated then ShowWindow(Handle, SW_HIDE); DestroyHandle; end; procedure TdxBarShadowPart.Show; procedure MakeAlphaBlended; var ASize: TSize; P: TPoint; ABlend: TBlendFunction; begin ASize := TSize(ClientRect.BottomRight); P := cxNullPoint; with ABlend do begin BlendOp := AC_SRC_OVER; BlendFlags := 0; SourceConstantAlpha := 255; AlphaFormat := AC_SRC_ALPHA; end; UpdateLayeredWindow(Handle, 0, nil, @ASize, FImage.Canvas.Handle, @P, 0, @ABlend, LWA_ALPHA); end; begin if not CanShow then Exit; if Transparent then MakeAlphaBlended; dxSetZOrder(Handle, Control.Handle, False, SWP_SHOWWINDOW); end; procedure TdxBarShadowPart.UpdateBounds(const ABounds: TRect); begin BoundsRect := ABounds; UpdateImage; if FOwner.Visible then Show; end; { TdxBarShadow } constructor TdxBarShadow.Create(AOwner: TWinControl); begin inherited Create; FOwner := AOwner; end; destructor TdxBarShadow.Destroy; begin DestroyParts; inherited; end; function TdxBarShadow.GetShadowSize: Integer; begin if Transparent then Result := dxBarTransparentShadowSize else Result := dxBarOpaqueShadowSize; end; function TdxBarShadow.GetTransparent: Boolean; begin Result := (@UpdateLayeredWindow <> nil) and (BitsPerPixel > 8); end; procedure TdxBarShadow.SetVisible(Value: Boolean); begin if FVisible <> Value then begin FVisible := Value; if FVisible then Show else Hide; end; end; procedure TdxBarShadow.CreateParts; var APartCount: Integer; procedure CreatePart(AKind: TdxBarShadowPartKind; ACorners: TdxBarShadowCorners; const ABounds: TRect); begin if IsRectEmpty(ABounds) then Exit; FParts[APartCount] := TdxBarShadowPart.CreateEx(Self, AKind, ACorners); FParts[APartCount].UpdateBounds(ABounds); Inc(APartCount); end; procedure CreatePartsForHorizontalMode; begin if not IsRectEmpty(R1) then CreatePart(spVertical, [scTop], Rect(R1.Right, R1.Top + ShadowSize, R1.Right + ShadowSize, R1.Bottom)); CreatePart(spHorizontal, [scLeft, scRight], Rect(R2.Left + ShadowSize, R2.Bottom, R2.Right + ShadowSize, R2.Bottom + ShadowSize)); if not IsRectEmpty(R1) then begin if R1.Left + ShadowSize < R2.Left then CreatePart(spHorizontal, [scLeft], Rect(R1.Left + ShadowSize, R1.Bottom, R2.Left, R1.Bottom + ShadowSize)); if R1.Right > R2.Right then CreatePart(spHorizontal, [scRight], Rect(R2.Right, R1.Bottom, R1.Right + ShadowSize, R1.Bottom + ShadowSize)); end; if IsRectEmpty(R1) or (R1.Right < R2.Right) then CreatePart(spVertical, [scTop], Rect(R2.Right, R2.Top + ShadowSize, R2.Right + ShadowSize, R2.Bottom)) else CreatePart(spVertical, [], Rect(R2.Right, R2.Top, R2.Right + ShadowSize, R2.Bottom)); end; procedure CreatePartsForVerticalMode; begin CreatePart(spVertical, [scTop], Rect(R2.Right, R2.Top + ShadowSize, R2.Right + ShadowSize, R2.Bottom)); if R1.Top + ShadowSize < R2.Top then CreatePart(spVertical, [scTop], Rect(R1.Right, R1.Top + ShadowSize, R1.Right + ShadowSize, R2.Top)); if R1.Bottom > R2.Bottom then begin CreatePart(spHorizontal, [scLeft, scRight], Rect(R1.Left + ShadowSize, R1.Bottom, R1.Right + ShadowSize, R1.Bottom + ShadowSize)); CreatePart(spVertical, [], Rect(R1.Right, R2.Bottom, R1.Right + ShadowSize, R1.Bottom)); end else CreatePart(spHorizontal, [scLeft], Rect(R1.Left + ShadowSize, R1.Bottom, R1.Right, R1.Bottom + ShadowSize)); if R1.Bottom >= R2.Bottom then CreatePart(spHorizontal, [scRight], Rect(R2.Left, R2.Bottom, R2.Right + ShadowSize, R2.Bottom + ShadowSize)) else CreatePart(spHorizontal, [scLeft, scRight], Rect(R2.Left + ShadowSize, R2.Bottom, R2.Right + ShadowSize, R2.Bottom + ShadowSize)); end; begin APartCount := 0; if FHorizontal then CreatePartsForHorizontalMode else CreatePartsForVerticalMode; end; procedure TdxBarShadow.DestroyParts; var I: Integer; begin for I := Low(FParts) to High(FParts) do begin FParts[I].Free; FParts[I] := nil; end; end; procedure TdxBarShadow.Hide; var I: Integer; begin for I := Low(FParts) to High(FParts) do if FParts[I] <> nil then FParts[I].Hide; end; procedure TdxBarShadow.Show; var I: Integer; begin for I := Low(FParts) to High(FParts) do if FParts[I] <> nil then FParts[I].Show; end; procedure TdxBarShadow.Refresh; begin DestroyParts; CreateParts; end; procedure TdxBarShadow.SetOwnerBounds(AR1, AR2: TRect); procedure SwapRects; var R: TRect; begin R := R1; R1 := R2; R2 := R; end; begin R1 := AR1; R2 := AR2; FHorizontal := IsRectEmpty(R1) or (R1.Bottom = R2.Top) or (R1.Top = R2.Bottom); if FHorizontal and (R1.Top = R2.Bottom) or not FHorizontal and (R1.Left = R2.Right) then SwapRects; Refresh; end; { TCustomdxBarControl } constructor TCustomdxBarControl.Create(AOwner: TComponent); begin inherited Create(AOwner); FCanvas := TcxCanvas.Create(inherited Canvas); FViewInfo := GetViewInfoClass.Create(Self); AddBarControl(Self); ControlStyle := ControlStyle - [csCaptureMouse]; UpdateControlStyle; Color := clBtnFace; FLastMousePos := cxInvalidPoint; FShadow := TdxBarShadow.Create(Self); Visible := False; SetBounds(100, 100, 30, 50); FBackgroundTempBitmap := TBitmap.Create; FViewState := bvsNormal; end; destructor TCustomdxBarControl.Destroy; begin AccessibilityHelperOwnerObjectDestroyed(FIAccessibilityHelper); BarManager.EndMouseTracking(Self); DoDestroy; //#DG if (BarManager <> nil) and (BarManager.FSelectedItem <> nil) and (BarManager.FSelectedItem.Parent = Self) then BarManager.FSelectedItem := nil; if FItemLinks <> nil then FItemLinks.FBarControl := nil; if IsCustomizing and (Self is TdxBarSubMenuControl) then begin SelectedLink := nil; with TdxBarSubMenuControl(Self) do if FSubItem <> nil then with FSubItem do begin BarManager.FSelectedItem := FSubItem; FIsActive := False; Repaint; end; end; RemoveBarControl(Self); cxClearObjectLinks(Self); dxFreeAndNilObjectLink(FPrevFocusedBarControlLink); FreeAndNil(FShadow); FreeAndNil(FBackgroundTempBitmap); FreeAndNil(FViewInfo); FreeAndNil(FCanvas); FreeAndNil(FActiveCanvas); inherited Destroy; end; procedure TCustomdxBarControl.BarGetFocus(ASelectedItem: TdxBarItemControl); begin DoBarGetFocus(ASelectedItem); end; procedure TCustomdxBarControl.BarLostFocus; begin if IsFocused then DoBarLostFocus; end; procedure TCustomdxBarControl.BeforeDestruction; begin inherited; if (ChildBar <> nil) and not ChildBar.IsDestroying then FreeAndNil(FChildBar); if ParentBar <> nil then ParentBar.ChildBar := nil; end; procedure TCustomdxBarControl.MouseDownNotifyControls( ALinkAtPos: TdxBarItemLink; const AMousePos: TPoint; Button: TMouseButton; Shift: TShiftState); begin if GetControlByLink(ALinkAtPos) <> nil then GetControlByLink(ALinkAtPos).MouseDown(Button, Shift, AMousePos.X, AMousePos.Y); end; procedure TCustomdxBarControl.MouseNotifyControls(ALinkAtPos: TdxBarItemLink; const AMousePos: TPoint; Shift: TShiftState); begin if FPrevTrackedLink <> ALinkAtPos then begin if GetControlByLink(FPrevTrackedLink) <> nil then GetControlByLink(FPrevTrackedLink).MouseLeave; FPrevTrackedLink := ALinkAtPos; if GetControlByLink(ALinkAtPos) <> nil then GetControlByLink(ALinkAtPos).MouseEnter(Shift, AMousePos.X, AMousePos.Y); end; if GetControlByLink(ALinkAtPos) <> nil then GetControlByLink(ALinkAtPos).MouseMove(Shift, AMousePos.X, AMousePos.Y); end; procedure TCustomdxBarControl.MouseUpNotifyControls(ALinkAtPos: TdxBarItemLink; const AMousePos: TPoint; Button: TMouseButton; Shift: TShiftState); begin if GetControlByLink(ALinkAtPos) <> nil then GetControlByLink(ALinkAtPos).MouseUp(Button, Shift, AMousePos.X, AMousePos.Y); end; function TCustomdxBarControl.GetActiveCanvas: TcxCanvas; begin if HandleAllocated then begin if FActiveCanvas <> nil then begin FreeAndNil(FActiveCanvas); UpdateCanvasFont; end; Result := FCanvas; end else begin if FActiveCanvas = nil then begin FActiveCanvas := TcxScreenCanvas.Create; UpdateCanvasFont; end; Result := FActiveCanvas; end; end; function TCustomdxBarControl.GetBarControlOwnerBrush: HBRUSH; begin Result := Painter.BarControlOwnerBrush(BarManager); end; function TCustomdxBarControl.GetBarManager: TdxBarManager; begin Result := Owner as TdxBarManager; end; function TCustomdxBarControl.GetCanvas: TcxCanvas; begin Result := ActiveCanvas; end; function TCustomdxBarControl.GetFlat: Boolean; begin // TODO: obsolete Result := BarManager.Flat; end; function TCustomdxBarControl.GetIsDestroying: Boolean; begin Result := csDestroying in ComponentState; end; function TCustomdxBarControl.GetOwnerLinkBounds(AOwnerPart: Boolean): TRect; var AOwnerBounds: TRect; AFirstCase: Boolean; procedure ConvertRects; procedure ConvertRect(var R: TRect); procedure ConvertPoint(var P: TPoint); var APrevX: Integer; begin with P do begin APrevX := X; X := Y; Y := APrevX; end; end; begin ConvertPoint(R.TopLeft); ConvertPoint(R.BottomRight); end; begin if not FShadow.Horizontal then begin ConvertRect(Result); ConvertRect(AOwnerBounds); end; end; begin if IsRectEmpty(FOwnerBounds) or not IsLinkedToOwner then SetRectEmpty(Result) else begin Result := WindowRect; AOwnerBounds := FOwnerBounds; with Result do begin OffsetRect(AOwnerBounds, -Left, -Top); OffsetRect(Result, -Left, -Top); ConvertRects; AFirstCase := AOwnerBounds.Bottom = Top; if AFirstCase then Bottom := Top + 1 else Top := Bottom - 1; if AOwnerPart then OffsetRect(Result, 0, -(2 * Ord(AFirstCase) - 1)); if Left < AOwnerBounds.Left + 1 then Left := AOwnerBounds.Left + 1 else Inc(Left); if Right > AOwnerBounds.Right - 1 then Right := AOwnerBounds.Right - 1 else Dec(Right); ConvertRects; end; if AOwnerPart then OffsetRect(Result, Left, Top); end; end; function TCustomdxBarControl.GetPainterClass: TdxBarPainterClass; begin Result := TdxBarPainterClass(Painter.ClassType); end; function TCustomdxBarControl.GetSelectedControlAtDesign: TdxBarItemControl; begin if (BarManager.LastSelectedLinkAtDesign <> nil) and (BarManager.LastSelectedLinkAtDesign.BarControl = Self) then Result := BarManager.LastSelectedLinkAtDesign.Control else Result := nil; end; function TCustomdxBarControl.GetSelectedControl: TdxBarItemControl; begin Result := GetControlByLink(SelectedLink); end; function TCustomdxBarControl.ItemAtMousePos: TdxBarItemControl; begin Result := ItemAtPos(ScreenToClient(GetMouseCursorPos)); end; procedure TCustomdxBarControl.SetChildBar(Value: TCustomdxBarControl); procedure InternalSetParentBar(AParent, AChild: TCustomdxBarControl); begin if AChild <> nil then AChild.ParentBar := AParent; end; //var // APrevChildBar: TCustomdxBarControl; begin FChildBar := Value; if (Value <> nil) and (Value.ParentBar <> Self) then Value.ParentBar := Self; { if FChildBar <> Value then begin APrevChildBar := FChildBar; FChildBar := Value; InternalSetParentBar(nil, APrevChildBar); InternalSetParentBar(Self, FChildBar); end; } end; procedure TCustomdxBarControl.SetDockControl(Value: TdxDockControl); begin FDockControl := Value; UpdateDoubleBuffered; //! end; procedure TCustomdxBarControl.SetIsActive(Value: Boolean); begin BarManager.HintActivate(False, ''); if (FIsActive <> Value) and CanActiveChange or IsCustomizing and not Value then DoSetIsActive(Value); end; procedure TCustomdxBarControl.SetParentBar(Value: TCustomdxBarControl); procedure InternalSetChidBar(AParent, AChild: TCustomdxBarControl); begin if AParent <> nil then AParent.ChildBar := AChild; end; //var // APrevParentBar: TCustomdxBarControl; begin FParentBar := Value; if (Value <> nil) and (Value.ChildBar <> Self) then Value.ChildBar := Self; { if FParentBar <> Value then begin APrevParentBar := FParentBar; FParentBar := Value; InternalSetChidBar(APrevParentBar, nil); InternalSetChidBar(FParentBar, Self); end; } end; procedure TCustomdxBarControl.SetViewState(Value: TdxBarViewState); var APrevViewState: TdxBarViewState; begin if (Value <> FViewState) and not IsCustomizing then begin APrevViewState := FViewState; FViewState := Value; ViewStateChanged(APrevViewState); end; end; procedure TCustomdxBarControl.WMCaptureChanged(var Message: TMessage); begin inherited; if FDragDown then begin BarManager.DraggingItem := nil; BarManager.DraggingItemLink := nil; FDragDown := False; end; FClickedControl := nil; end; procedure TCustomdxBarControl.WMDestroy(var Message: TMessage); begin if not IsDestroying then begin MarkState := msNone; BeforeDestroyHandle; end; inherited; end; procedure TCustomdxBarControl.WMEraseBkgnd(var Message: TWMEraseBkgnd); begin // if FItemLinks.CanVisibleItemCount = 0 then // else Fill Rgn is called // FillBackground(Message.DC, ClientRect, ToolbarBrush, clNone, True); Message.Result := 1; end; procedure TCustomdxBarControl.WMKeyDown(var Message: TWMKeyDown); var AKey: Word; IsTabKey, ADuplicate: Boolean; AItemLink: TdxBarItemLink; ATabForward: Boolean; begin inherited; if ActiveBarControl = nil then Exit; AKey := Message.CharCode; if IsRealVertical then begin case AKey of VK_LEFT: AKey := VK_UP; VK_RIGHT: AKey := VK_DOWN; VK_UP: AKey := VK_LEFT; VK_DOWN: AKey := VK_RIGHT; end; Message.CharCode := AKey; end; if Self is TdxBarSubMenuControl then case AKey of VK_LEFT, VK_RIGHT: AKey := 0; VK_UP: AKey := VK_LEFT; VK_DOWN: AKey := VK_RIGHT; end; IsTabKey := AKey = VK_TAB; ATabForward := False; if IsTabKey then begin if GetKeyState(VK_CONTROL) < 0 then ATabForward := not (GetKeyState(VK_SHIFT) < 0) else if GetKeyState(VK_SHIFT) < 0 then AKey := VK_LEFT else AKey := VK_RIGHT; end; case AKey of VK_TAB: // + Ctrl FocusNextBarControl(ATabForward); VK_F10, VK_MENU: if (AKey = VK_MENU) or BarManager.UseF10ForMenu then begin Message.CharCode := 0; HideAll; end; VK_LEFT: begin if SelectedLink = nil then AItemLink := ItemLinks.First else AItemLink := ItemLinks.Prev(SelectedLink); if AItemLink <> nil then SetKeySelectedItem(AItemLink.Control); if IsTabKey and SelectedControl.HasWindow then SelectedControl.Click(False); end; VK_RIGHT: begin if SelectedLink = nil then AItemLink := ItemLinks.First else AItemLink := ItemLinks.Next(SelectedLink); if AItemLink <> nil then begin SetKeySelectedItem(AItemLink.Control); if IsTabKey and SelectedControl.HasWindow then SelectedControl.Click(False); end; end; VK_HOME: begin AItemLink := ItemLinks.First; if AItemLink <> nil then SetKeySelectedItem(AItemLink.Control); end; VK_END: begin AItemLink := ItemLinks.Last; if AItemLink <> nil then SetKeySelectedItem(AItemLink.Control); end; else begin AKey := MapVirtualKey(AKey, 2); if AKey in [Ord('A')..Ord('Z'), Ord('0')..Ord('9')] then begin AItemLink := FindLinkWithAccel(AKey, KeyDataToShiftState(Message.KeyData), GetLinkByControl(SelectedControl), ADuplicate); if AItemLink <> nil then SetAccelSelectedItem(GetControlByLink(AItemLink), ADuplicate); end; end; end; end; procedure TCustomdxBarControl.WMLButtonDblClk(var Message: TWMLButtonDblClk); begin if not FIgnoreMouseClick then inherited; end; procedure TCustomdxBarControl.WMLButtonDown(var Message: TWMLButtonDown); begin if not FIgnoreMouseClick then inherited; end; procedure TCustomdxBarControl.WMLButtonUp(var Message: TWMLButtonUp); var P: TPoint; Item, AClickedControl: TdxBarItemControl; begin if FIgnoreMouseClick then begin FIgnoreMouseClick := False; Exit; end; inherited; if FDragDown then ReleaseCapture else begin P.X := Message.XPos; P.Y := Message.YPos; AClickedControl := FClickedControl; if AClickedControl <> nil then ReleaseCapture; if PtInRect(ClientRect, P) and IsActive then begin Item := ItemAtPos(P); if not IsCustomizing and (Item <> nil) and Item.HotPartWantMouse then if Item.Enabled and (Item = SelectedControl) then begin if Item.HasWindow then TdxBarWinControl(Item).TransferMessage(Handle, TMessage(Message)); Item.ControlUnclick(True); end else if not Item.Enabled and (Item <> SelectedControl) and (Self is TdxBarControl) and not ((SelectedControl is TdxBarButtonControl) and TdxBarButtonControl(SelectedControl).DroppedDown) then TdxBarControl(Self).HideAll;//BarLostFocus; end; if (AClickedControl <> nil) and BarControlExists(Self) then HideAll; end; end; procedure TCustomdxBarControl.WMMouseActivate(var Message: TWMMouseActivate); begin inherited; Message.Result := MA_NOACTIVATE; end; procedure TCustomdxBarControl.WMMouseMove(var Message: TWMMouseMove); var ALinkSelf: TcxObjectLink; begin ALinkSelf := cxAddObjectLink(Self); try inherited; if ALinkSelf.Ref <> nil then AfterMouseMove(KeysToShiftState(Message.Keys), Message.XPos, Message.YPos); finally cxRemoveObjectLink(ALinkSelf); end; end; procedure TCustomdxBarControl.WMPaint(var Message: TWMPaint); begin if not IsDestroying then inherited; end; procedure TCustomdxBarControl.WMRepaintBar(var Message: TMessage); begin RepaintBar; end; procedure TCustomdxBarControl.WMSetCursor(var Message: TWMSetCursor); begin with Message do if (HitTest = HTCLIENT) and (CursorWnd = Handle) then begin Windows.SetCursor(Screen.Cursors[Cursor]); Result := 1; end else inherited; end; procedure TCustomdxBarControl.WMSize(var Message: TWMSize); begin // ResetBackground; inherited; end; procedure TCustomdxBarControl.WMWindowPosChanged(var Message: TWMWindowPosChanged); begin inherited; if csDestroying in ComponentState then Exit; with Message.WindowPos^ do if (flags and SWP_NOSIZE = 0) or (flags and SWP_NOMOVE = 0) then ResizeShadow; FShadow.Visible := IsShadowVisible; ResetBackground; end; procedure TCustomdxBarControl.AdjustSize; begin // do nothing end; procedure TCustomdxBarControl.AdjustHintWindowPosition(var APos: TPoint; const ABoundsRect: TRect; AHeight: Integer); begin if GetDesktopWorkArea(APos).Bottom - APos.Y < AHeight then APos.Y := ClientToScreen(cxNullPoint).Y - AHeight; end; procedure TCustomdxBarControl.AfterControlEscape(AControl: TdxBarItemControl); begin if not (bboAllowSelectWindowItemsWithoutFocusing in BehaviorOptions) then HideAllByEscape else SelectedControl := AControl; end; procedure TCustomdxBarControl.AfterMouseMove(Shift: TShiftState; X, Y: Integer); begin if not NotHandleMouseMove then FLastMousePos := GetMouseCursorPos else if NotHandleMouseMove(False) then MouseLeave; end; procedure TCustomdxBarControl.CreateWindowHandle(const Params: TCreateParams); begin inherited; CreateControls; SetLayeredAttributes; end; procedure TCustomdxBarControl.CreateWnd; begin inherited; SetFont; CalcDrawingConsts; end; procedure TCustomdxBarControl.DestroyWindowHandle; begin if WindowHandle <> 0 then BeforeDestroyHandle; DestroyControls; inherited DestroyWindowHandle; end; procedure TCustomdxBarControl.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); procedure CorrectCurrentMessage; begin case FCurrentMessage.Msg of WM_LBUTTONDBLCLK: FCurrentMessage.Msg := WM_LBUTTONDOWN; WM_RBUTTONDBLCLK: FCurrentMessage.Msg := WM_RBUTTONDOWN; WM_MBUTTONDBLCLK: FCurrentMessage.Msg := WM_MBUTTONDOWN; end; end; var P: TPoint; AItemControl: TdxBarItemControl; begin inherited; P := Point(X, Y); AItemControl := ItemAtPos(P); if cxPointIsEqual(FLastMousePos, cxInvalidPoint) and not IsCustomizing then DoBarMouseEnter(Shift, P, AItemControl); if (ssDouble in Shift) and (AItemControl <> nil) and (AItemControl = SelectedControl) and AItemControl.WantsDblClick then DblClickOnItem(AItemControl) else begin CorrectCurrentMessage; DoBarMouseDown(Button, Shift, P, AItemControl, PtInRect(ClientRect, P)); end; end; procedure TCustomdxBarControl.MouseLeave; begin FLastMousePos := cxInvalidPoint; if BarManager.IsMouseTracking(Self) then begin BarManager.EndMouseTracking(Self); DoBarMouseLeave; end; end; procedure TCustomdxBarControl.MouseMove(Shift: TShiftState; X, Y: Integer); function DragAndDrop(const P: TPoint): Boolean; function DragRect: TRect; begin Result := Bounds(0, 0, GetSystemMetrics(SM_CXDRAG), GetSystemMetrics(SM_CYDRAG)); OffsetRect(Result, FDragPoint.X - Result.Right div 2, FDragPoint.Y - Result.Bottom div 2); end; begin Result := FDragDown and not PtInRect(DragRect, P); if Result then begin FDragDown := False; ReleaseCapture; with BarManager do begin DraggingItemLink.Control.ControlInactivate(True); DragAndDrop(DraggingItem, DraggingItemLink); end; end; end; var P: TPoint; AItemControl: TdxBarItemControl; begin inherited; P := Point(X, Y); if IsDestroying or DragAndDrop(P) then Exit; AItemControl := ItemAtPos(P); if cxPointIsEqual(FLastMousePos, cxInvalidPoint) and not NotHandleMouseMove then DoBarMouseEnter(Shift, P, AItemControl); DoBarMouseMove(Shift, P, AItemControl); end; procedure TCustomdxBarControl.MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); var P: TPoint; AItemControl: TdxBarItemControl; begin inherited; P := Point(X, Y); AItemControl := ItemAtPos(P); DoBarMouseUp(Button, Shift, P, AItemControl, PtInRect(ClientRect, P)); end; procedure TCustomdxBarControl.Resize; begin inherited; if IsPopup then Painter.SetWindowRgn(Handle, NCRect, True); end; procedure TCustomdxBarControl.WndProc(var Message: TMessage); function FindEditControl(AHandle: HWND): TdxBarEditControl; var AEditControl: TdxBarEditControl; I: Integer; begin Result := nil; for I := 0 to ItemLinks.Count - 1 do if ItemLinks[I].Control is TdxBarEditControl then begin AEditControl := TdxBarEditControl(ItemLinks[I].Control); if AEditControl.HandleAllocated and (AEditControl.Handle = AHandle) then begin Result := AEditControl; Break; end; end; end; var ABkColor, ATextColor: COLORREF; AEditControl: TdxBarCustomEditControl; begin case Message.Msg of WM_CTLCOLOREDIT, WM_CTLCOLORSTATIC: begin AEditControl := FindEditControl(Message.LParam); if AEditControl = nil then inherited else begin Painter.EditGetColors(AEditControl, ATextColor, ABkColor); SetBkColor(Message.WParam, ColorToRGB(ABkColor)); SetTextColor(Message.WParam, ColorToRGB(ATextColor)); Message.Result := AEditControl.EditBkBrush; end; end; WM_KILLFOCUS: begin inherited; if Message.wParam = 0 then HideAll; end; WM_NCACTIVATE: begin if (Message.wParam = Longint(True)) and not BarManager.IsCustomizing then SendMessage(GetParent(Handle), WM_NCACTIVATE, Longint(True), 0); Message.wParam := Longint(True); inherited; end; WM_SETFOCUS: if not (SelectedControl is TdxBarWinControl) then begin if IsCustomizing and (dxBarCustomizingForm <> nil) then begin dxSetZOrder(Handle); Windows.SetFocus(dxBarCustomizingForm.Handle); dxSetZOrder(Handle, HWND_NOTOPMOST); end else if IsWindowVisible(BarManager.Owner.Handle) then Windows.SetFocus(BarManager.Owner.Handle) else Windows.SetFocus(GetNextWindow(BarManager.Owner.Handle, GW_HWNDNEXT)); end else inherited; WM_MOUSEFIRST..WM_MOUSELAST, WM_NCMOUSEMOVE..WM_NCMBUTTONDBLCLK: if CanProcessMouseMessage then inherited; WM_COMMAND: begin inherited; if (Message.Result = 0) and (HiWord(Message.wParam) = EN_CHANGE) and (Message.lParam <> 0) then Message.Result := SendMessage(Message.lParam, Message.Msg, Message.wParam, Message.lParam); end; else inherited; end; end; function TCustomdxBarControl.CalcChildBarBounds(out ARect: TRect): Boolean; begin Result := False; end; procedure TCustomdxBarControl.CalcControlsPositions; begin CalcItemsRect; end; procedure TCustomdxBarControl.CalcDragOverParameters(const ACursorPos: TPoint; out ADragOverItemLink: TdxBarItemLink; out AIsBeginGroup, AIsFirstPart, AIsVerticalDirection: Boolean); var ACalcVerticalDirection: Boolean; AControl: TdxBarItemControl; AItemRect: TRect; ASeparatorIndex, I: Integer; ARgn: HRGN; begin AIsVerticalDirection := IsVerticalDirection; for I := 0 to FItemLinks.VisibleItemCount - 1 do begin AControl := FItemLinks.VisibleItems[I].Control; if AControl.CanCustomize then begin ARgn := GetItemRegion(AControl); try if PtInRegion(ARgn, ACursorPos.X, ACursorPos.Y) then begin ADragOverItemLink := AControl.ItemLink; AItemRect := GetFullItemRect(AControl); AIsBeginGroup := not PtInRect(AItemRect, ACursorPos); ACalcVerticalDirection := AIsVerticalDirection; if AIsBeginGroup then begin if ACursorPos.Y < AItemRect.Top then ACalcVerticalDirection := True; ViewInfo.IsAssociatedWithSeparator(AControl, ASeparatorIndex); AItemRect := ViewInfo.SeparatorInfos[ASeparatorIndex].Bounds; end; if ACalcVerticalDirection then AIsFirstPart := (ACursorPos.Y - AItemRect.Top) < (AItemRect.Bottom - ACursorPos.Y) else AIsFirstPart := (ACursorPos.X - AItemRect.Left) < (AItemRect.Right - ACursorPos.X); Break; end; finally DeleteObject(ARgn); end; end; end; end; procedure TCustomdxBarControl.CalcDrawingConsts; var Size: TSize; DC: HDC; PrevFont: HFONT; begin FTextSize := GetTextSize; FRatio := Max(1, FTextSize / GetNormalItemHeight); FMenuArrowHeight := FTextSize div 5; if FMenuArrowHeight < 4 then FMenuArrowHeight := 4; FIconAreaSize := GetIconAreaSize; DC := GetDC(0); PrevFont := SelectObject(DC, EditFontHandle); GetTextExtentPoint32(DC, '0', 1, Size); SelectObject(DC, PrevFont); ReleaseDC(0, DC); FEditTextSize := Painter.EditTextSize(Self, Size.cy); FComboBoxArrowWidth := Painter.ComboBoxArrowWidth(Self, Size.cx); end; procedure TCustomdxBarControl.CalcItemsRect; begin FItemsRect := ClientRect; end; procedure TCustomdxBarControl.CalcColumnItemRects(ATopIndex: Integer); var I: Integer; AItemLink: TdxBarItemLink; AItemRect: TRect; begin AItemRect := VisibleItemsRect; AItemRect.Bottom := AItemRect.Top; for I := ATopIndex to ItemLinks.VisibleItemCount - 1 do begin AItemLink := ItemLinks.VisibleItems[I]; AItemRect.Top := AItemRect.Bottom + GetItemControlOffset(AItemLink); AItemRect.Bottom := AItemRect.Top + AItemLink.Control.Height; if AItemRect.Bottom > VisibleItemsRect.Bottom then begin if CanDrawClippedItem(AItemRect) then AItemLink.ItemRect := AItemRect; Break; end; AItemLink.ItemRect := AItemRect; end; end; procedure TCustomdxBarControl.CalcRowItemRects; begin // do nothing end; procedure TCustomdxBarControl.CalcItemRects(APaintStyle: TdxBarPaintType; ATopIndex: Integer); begin FVisibleItemsRect := ItemsRect; CorrectVisibleItemsRectTop; ItemLinks.EmptyItemRects; case APaintStyle of ptHorz, ptVert: CalcRowItemRects; ptMenu: CalcColumnItemRects(ATopIndex); end; CorrectVisibleItemsRectBottom; end; procedure TCustomdxBarControl.CalcLayout; begin ViewInfo.Calculate; end; procedure TCustomdxBarControl.BeforeDestroyHandle; var I: Integer; begin if not IsDestroying then MouseLeave; for I := 0 to ItemLinks.CanVisibleItemCount - 1 do with ItemLinks.CanVisibleItems[I] do if Control <> nil then Control.BeforeDestroyParentHandle; end; procedure TCustomdxBarControl.CreateControls; begin if ([bsCreatingControls, bsDestroyingControls] * FState <> []) then Exit; Include(FState, bsCreatingControls); try DoCreateControls; finally Exclude(FState, bsCreatingControls); end; end; procedure TCustomdxBarControl.DestroyControls; begin if ([bsCreatingControls, bsDestroyingControls] * FState <> []) then Exit; Include(FState, bsDestroyingControls); try DoDestroyControls; finally Exclude(FState, bsDestroyingControls); end; end; procedure TCustomdxBarControl.ExpandContainerItems; var ADoneItems: TList; I: Integer; AItemLink: TdxBarItemLink; AFirstCall, AHideWhenRun: Boolean; begin if FItemLinks <> nil then begin ADoneItems := TList.Create; try I := 0; while I <= FItemLinks.CanVisibleItemCount - 1 do begin AItemLink := FItemLinks.CanVisibleItems[I]; if AItemLink.Item is TCustomdxBarContainerItem then begin if FExpandedItemLinks = nil then FExpandedItemLinks := TList.Create; FExpandedItemLinks.Count := AItemLink.Index + 1; FExpandedItemLinks[AItemLink.Index] := AItemLink; AFirstCall := ADoneItems.IndexOf(AItemLink.Item) = -1; if AFirstCall then ADoneItems.Add(AItemLink.Item); AHideWhenRun := TCustomdxBarContainerItem(AItemLink.Item).HideWhenRun; if AHideWhenRun then AItemLink.SaveRecentIndex; TCustomdxBarContainerItem(AItemLink.Item).AddListedItemLinks(FItemLinks, AItemLink.Index + 1, AFirstCall, AItemLink); if AHideWhenRun then begin AItemLink.SendToBottomInRecentList; AItemLink.Collection := nil; Dec(I); end; end; Inc(I); end; finally ADoneItems.Free; end; end; end; procedure TCustomdxBarControl.CollapseContainerItems; var I: Integer; AHideWhenRun: Boolean; begin if FExpandedItemLinks <> nil then try for I := FExpandedItemLinks.Count - 1 downto 0 do if FExpandedItemLinks[I] <> nil then with TdxBarItemLink(FExpandedItemLinks[I]) do begin AHideWhenRun := TCustomdxBarContainerItem(Item).HideWhenRun; TCustomdxBarContainerItem(Item).DeleteListedItemLinks(FItemLinks, I + Byte(not AHideWhenRun)); if AHideWhenRun then begin Collection := FItemLinks; Index := I; RestoreRecentIndex; end; end; for I := 0 to FExpandedItemLinks.Count - 1 do if FExpandedItemLinks[I] <> nil then TCustomdxBarContainerItem(TdxBarItemLink(FExpandedItemLinks[I]).Item).NeedClearItemList; finally FreeAndNil(FExpandedItemLinks); end; end; procedure TCustomdxBarControl.LayoutChanged; begin // do nothing end; procedure TCustomdxBarControl.RecreateControls; begin DestroyControls; CreateControls; end; function TCustomdxBarControl.CanActiveChange: Boolean; begin Result := IsApplicationActive or IsWindowEnabled or IsCustomizing; end; function TCustomdxBarControl.CanAlignControl(AControl: TdxBarItemControl): Boolean; begin Result := False; end; function TCustomdxBarControl.CanCallInheritedNCCalcSize: Boolean; // obsolete begin Result := True; end; function TCustomdxBarControl.CanCustomizing: Boolean; begin Result := BarManager.Designing; end; function TCustomdxBarControl.CanDeactivate(ABarManager: TdxBarManager; AActiveWindow: HWND): Boolean; begin Result := ABarManager.IsCustomizing and (BarManager.Owner = dxBarCustomizingForm) and (Handle <> AActiveWindow) or (SelectedControl = nil) or SelectedControl.CanDeselect(ABarManager); end; function TCustomdxBarControl.CanDrawClippedItem(AItemRect: TRect): Boolean; begin Result := False; end; function TCustomdxBarControl.CanHide: Boolean; begin Result := ((SelectedControl = nil) or (SelectedControl.CanHide)) and ((ChildBar = nil) or ChildBar.CanHide); end; function TCustomdxBarControl.CanProcessMouseMessage: Boolean; var AControl: TCustomdxBarControl; begin AControl := ActiveBarControl; Result := AControl = nil; while not Result and (AControl <> nil) do begin Result := AControl = Self; AControl := AControl.GetEquivalentParentBar; end; end; function TCustomdxBarControl.CanShowPopupMenuOnMouseClick(AMousePressed: Boolean): Boolean; function CanShowOnMouseDown: Boolean; begin Result := (not (bboItemCustomizePopup in BehaviorOptions) and not IsInternal) or IsCustomizing; end; function CanShowOnMouseUp: Boolean; begin Result := bboItemCustomizePopup in BehaviorOptions end; begin Result := AMousePressed and CanShowOnMouseDown or not AMousePressed and CanShowOnMouseUp and not CanShowOnMouseDown; end; function TCustomdxBarControl.CanShowHint: Boolean; begin Result := not IsActive; end; function TCustomdxBarControl.CheckLockUpdate: Boolean; begin Result := BarManager.IsUpdateLocked; end; function TCustomdxBarControl.ChildrenHaveShadows: Boolean; begin Result := Painter.BarChildrenHaveShadows(Self); end; procedure TCustomdxBarControl.CorrectVisibleItemsRectTop; begin // do nothing end; procedure TCustomdxBarControl.CorrectVisibleItemsRectBottom; begin // do nothing end; procedure TCustomdxBarControl.CustomizePrepare(APoint: TPoint; ASecondClick: Boolean); begin if (SelectedControlAtDesign <> nil) and SelectedControlAtDesign.CanCustomize then begin FDragPoint := APoint; BarManager.DraggingItem := GetItemByControl(SelectedControlAtDesign); BarManager.DraggingItemLink := GetLinkByControl(SelectedControlAtDesign); FDragDown := True; SetCapture(Handle); end; end; procedure TCustomdxBarControl.DblClickOnItem(AItemControl: TdxBarItemControl); begin if BarManager.Designing then AItemControl.Item.ShowDefaultEventHandler else if AItemControl.IsExpandable then with TCustomdxBarSubItem(AItemControl.Item).ItemLinks do if (BarControl <> nil) and BarControl.MarkExists then BarControl.MarkState := msPressed else else AItemControl.DblClick; end; procedure TCustomdxBarControl.DoBarGetFocus(ASelectedItem: TdxBarItemControl); begin SetKeySelectedItem(ASelectedItem); IsActive := True; dxFreeAndNilObjectLink(FPrevFocusedBarControlLink); if BarManager.FFocusedBarControl <> nil then FPrevFocusedBarControlLink := cxAddObjectLink(BarManager.FFocusedBarControl); BarManager.FFocusedBarControl := Self; end; procedure TCustomdxBarControl.DoBarLostFocus; begin if IsFocused then begin if (FPrevFocusedBarControlLink <> nil) and (FPrevFocusedBarControlLink.Ref <> nil) then begin BarManager.FFocusedBarControl := TCustomdxBarControl(FPrevFocusedBarControlLink.Ref); dxFreeAndNilObjectLink(FPrevFocusedBarControlLink); end else BarManager.FFocusedBarControl := nil; end; SetKeySelectedItem(nil); //TODO CHECK IsActive := False; end; procedure TCustomdxBarControl.DoBarMouseEnter(Shift: TShiftState; const APoint: TPoint; AItemControl: TdxBarItemControl); begin BarManager.BeginMouseTracking(Self); MouseNotifyControls(GetLinkByControl(AItemControl), APoint, Shift); ViewState := bvsHot; end; procedure TCustomdxBarControl.DoBarMouseDown(Button: TMouseButton; Shift: TShiftState; const APoint: TPoint; AItemControl: TdxBarItemControl; APointInClientRect: Boolean); var APrevSelectedControl: TdxBarItemControl; begin if not NotHandleMouseMove(False) then MouseDownNotifyControls(GetLinkByControl(AItemControl), APoint, Button, Shift); APrevSelectedControl := SelectedControlAtDesign; if IsCustomizing then SelectItemControl(AItemControl, Button, Shift); case Button of mbLeft: if IsCustomizing then CustomizePrepare(APoint, APrevSelectedControl = SelectedControlAtDesign) else FocusItemControl(AItemControl); mbRight: begin if SelectedControl <> AItemControl then BarLostFocus; if CanShowPopupMenuOnMouseClick(True) then ShowPopup(AItemControl) end; end; end; procedure TCustomdxBarControl.DoBarMouseLeave; begin ViewState := bvsNormal; MouseNotifyControls(nil, cxInvalidPoint, []); if MarkState = msSelected then MarkState := msNone; if (FClickedControl = nil) and (SelectedControl <> nil) and not SelectedControl.IsDroppedDown and not IsCustomizing then SetMouseSelectedItem(nil) end; procedure TCustomdxBarControl.DoBarMouseMove(Shift: TShiftState; const APoint: TPoint; AItemControl: TdxBarItemControl); var FocusedControlExists: Boolean; begin if not NotHandleMouseMove then begin MouseNotifyControls(GetLinkByControl(AItemControl), APoint, Shift); //#DG FocusedControlExists := (BarManager.SelectedItem <> nil) and (BarManager.SelectedItem is TdxBarWinControl) and TdxBarWinControl(BarManager.SelectedItem).Focused; { //#DG if (ActiveBarControl = nil) or (ActiveBarControl = Self) then if (AItemControl is TdxBarWinControl) and PtInRect(TdxBarWinControl(AItemControl).WindowRect, APoint) and (not FocusedControlExists or (AItemControl = BarManager.SelectedItem)) then Cursor := crIBeam else Cursor := crDefault; } if FocusedControlExists then Exit; if (AItemControl <> nil) and not AItemControl.CanMouseSelect then AItemControl := nil; if (Self is TdxBarControl) and IsActive and (AItemControl = nil) then Exit; if (FClickedControl = nil) and ((AItemControl <> nil) or (ChildBar = nil)) then SetMouseSelectedItem(AItemControl); {#DG // TODO if Item <> nil if (SelectedControl <> nil) and SelectedControl.FSelectedByMouse then SelectedControl.MouseMove(KeysToShiftState(Message.Keys), P.X, P.Y); } end; end; procedure TCustomdxBarControl.DoBarMouseUp(Button: TMouseButton; Shift: TShiftState; const APoint: TPoint; AItemControl: TdxBarItemControl; APointInClientRect: Boolean); begin if not NotHandleMouseMove(False) then MouseUpNotifyControls(GetLinkByControl(AItemControl), APoint, Button, Shift); if (Button = mbRight) and CanShowPopupMenuOnMouseClick(False) then ShowPopup(AItemControl); end; procedure TCustomdxBarControl.DoCreateControls; var I: Integer; begin if FItemLinks <> nil then for I := 0 to FItemLinks.CanVisibleItemCount - 1 do FItemLinks.CanVisibleItems[I].CreateControl; end; procedure TCustomdxBarControl.DoDestroy; begin //#DG Destroying; CallNotify(OnDestroy, Self); end; procedure TCustomdxBarControl.DoDestroyControls; var I: Integer; //#DG PrevDestroyFlag: Boolean; begin { if FItemLinks <> nil then begin PrevDestroyFlag := FDestroyFlag; FDestroyFlag := True; for I := 0 to FItemLinks.CanVisibleItemCount - 1 do FItemLinks.CanVisibleItems[I].DestroyControl; FDestroyFlag := PrevDestroyFlag; end; } if FItemLinks <> nil then for I := 0 to FItemLinks.CanVisibleItemCount - 1 do FItemLinks.CanVisibleItems[I].DestroyControl; end; procedure TCustomdxBarControl.DoHideAll; var ALinkSelf: TcxObjectLink; begin ALinkSelf := cxAddObjectLink(Self); try IsActive := False; if (ALinkSelf.Ref <> nil) and (ParentBar <> nil) and not ClosedByEscape then ParentBar.HideAll; finally cxRemoveObjectLink(ALinkSelf); end; end; procedure TCustomdxBarControl.DoPaintItem(AControl: TdxBarItemControl; ACanvas: TcxCanvas; const AItemRect: TRect); begin ACanvas.SaveState; try ACanvas.SetClipRegion(TcxRegion.Create(AControl.ViewInfo.Bounds), roSet); AControl.DoPaint(AItemRect, GetPaintType); finally ACanvas.RestoreState; end; DrawSelectedItem(ACanvas.Handle, AControl, AItemRect); end; procedure TCustomdxBarControl.DoRepaintBar(ARecreateControls: Boolean); begin if ARecreateControls then RecreateControls; end; procedure TCustomdxBarControl.DoSetIsActive(AValue: Boolean); begin FIsActive := AValue; if FIsActive then begin if FActiveBarControl = nil then ShowFullMenus := IsCustomizing; FPrevActiveBarControl := FActiveBarControl; FActiveBarControl := Self; if not IsCustomizing then ItemLinks.InitiateActions; end else begin if IsCustomizing then SelectedLink := nil else SetKeySelectedItem(nil); if FActiveBarControl = Self then FActiveBarControl := FPrevActiveBarControl; if (FActiveBarControl <> nil) and (not BarControlExists(FActiveBarControl) or not FActiveBarControl.IsActive) then FActiveBarControl := nil; end; end; procedure TCustomdxBarControl.DrawSelectedItem(ADC: HDC; AControl: TdxBarItemControl; const AItemRect: TRect); var ALink: TdxBarItemLink; begin ALink := GetLinkByControl(AControl); if (ALink <> nil) and ALink.IsComponentSelected then begin if BarDesignController.NeedDefaultSelection(ALink) then dxBarFrameRect(ADC, AItemRect, COLOR_WINDOWTEXT) else dxBarFocusRect(ADC, AItemRect); end; end; procedure TCustomdxBarControl.DragOver(X, Y: Integer; var Accept: Boolean); begin // do nothing end; function TCustomdxBarControl.DoFindLinkWithAccel(AKey: Word; AShift: TShiftState; ACurrentLink: TdxBarItemLink): TdxBarItemLink; begin Result := ItemLinks.FindItemWithAccel(AKey, AShift, ACurrentLink); end; function TCustomdxBarControl.FindLinkWithAccel(AKey: Word; AShift: TShiftState; ACurrentLink: TdxBarItemLink; out ADuplicate: Boolean): TdxBarItemLink; begin Result := DoFindLinkWithAccel(AKey, AShift, ACurrentLink); if (Result <> nil) and Result.Item.Enabled then ADuplicate := DoFindLinkWithAccel(AKey, AShift, Result) <> Result else Result := nil; end; procedure TCustomdxBarControl.FocusItemControl(AItemControl: TdxBarItemControl); var ABarButtonControl: TdxBarButtonControl; ALinkSelf: TcxObjectLink; begin BarManager.HintActivate(False, ''); if (AItemControl <> nil) and AItemControl.Enabled and AItemControl.HotPartWantMouse then begin SetKeySelectedItem(AItemControl); if SelectedControl is TdxBarButtonLikeControl then TdxBarButtonLikeControl(SelectedControl).FShowAnimation := True; if SelectedControl.HasWindow then // is focusable SetControlVisible(SelectedControl); ALinkSelf := cxAddObjectLink(Self); try AItemControl.ControlClick(True); if (ALinkSelf.Ref <> nil) and IsControlExists(AItemControl) then begin if SelectedControl is TdxBarButtonControl then begin ABarButtonControl := TdxBarButtonControl(SelectedControl); ABarButtonControl.FShowAnimation := False; // *** // if (ABarButtonControl.AItemControl.FDropDownMenu <> nil) and // (ABarButtonControl.AItemControl.FDropDownMenu.SubMenuControl <> nil) then // ABarButtonControl.AItemControl.FDropDownMenu.SubMenuControl.ParentBar := Self; end; end; finally cxRemoveObjectLink(ALinkSelf); end; end; end; procedure TCustomdxBarControl.FocusNextBarControl(AForward: Boolean); var APrevBarControl: TCustomdxBarControl; AIndex, APrevIndex, APrevBarIndex: Integer; ABar: TdxBar; ABars: TdxBars; begin APrevBarControl := GetParentBarForBar(Self); if APrevBarControl is TdxBarControl then begin ABar := TdxBarControl(APrevBarControl).Bar; APrevBarIndex := dxBarManagerList.IndexOf(ABar.Bars.BarManager); APrevIndex := ABar.Index; repeat AIndex := ABar.Index; if AForward then begin Inc(AIndex); if AIndex >= ABar.Bars.Count then begin ABar := dxBarManagerList.NextActive(ABar.Bars.BarManager, True).Bars[0]; AIndex := 0; end; end else begin Dec(AIndex); if AIndex < 0 then begin ABars := dxBarManagerList.NextActive(ABar.Bars.BarManager, False).Bars; ABar := ABars[ABars.Count - 1]; AIndex := ABar.Bars.Count - 1; end; end; if (APrevBarIndex = dxBarManagerList.IndexOf(ABar.Bars.BarManager)) and (AIndex = APrevIndex) then Break; ABar := ABar.Bars[AIndex]; if (ABar.Control <> nil) and (ABar.ItemLinks.First <> nil) then begin TdxBarControl(APrevBarControl).BarLostFocus; ABar.Control.BarGetFocus(ABar.ItemLinks.First.Control); Break; end; until False; end; end; function TCustomdxBarControl.GetIAccessibilityHelper: IdxBarAccessibilityHelper; begin if (FIAccessibilityHelper = nil) and (GetAccessibilityHelperClass <> nil) then FIAccessibilityHelper := GetAccessibilityHelper(GetAccessibilityHelperClass.Create(Self)); Result := FIAccessibilityHelper; end; function TCustomdxBarControl.GetBehaviorOptions: TdxBarBehaviorOptions; begin if ParentBar <> nil then Result := ParentBar.BehaviorOptions else Result := [bboAllowSelectWindowItemsWithoutFocusing, bboExtendItemWhenAlignedToClient, bboAllowDetach]; end; function TCustomdxBarControl.GetClientOffset: TPoint; begin with ClientOrigin do Result := Point(X - WindowRect.Left, Y - WindowRect.Top); end; function TCustomdxBarControl.GetDefaultItemHeight(AItem: TdxBarItemControl): Integer; begin Result := AItem.GetTextSize; if Result = 0 then Result := TextSize; end; function TCustomdxBarControl.GetDefaultItemGlyph: TBitmap; begin Result := nil; end; function TCustomdxBarControl.GetEditFont: TFont; begin Result := BarManager.FEditFont; end; function TCustomdxBarControl.GetClientBounds: TRect; begin Result := cxRectOffset(ClientRect, cxPointOffset(ClientToScreen(cxNullPoint), cxPointInvert(WindowRect.TopLeft))); end; function TCustomdxBarControl.GetNCRect: TRect; begin Result := cxRectOffset(WindowRect, cxPointInvert(WindowRect.TopLeft)); end; function TCustomdxBarControl.GetEditFontHandle: HFONT; begin Result := GetEditFont.Handle; end; function TCustomdxBarControl.GetEquivalentParentBar: TCustomdxBarControl; begin if IsInternal and (ParentBar <> nil) and not ParentBar.IsInternal then Result := nil else Result := ParentBar; end; function TCustomdxBarControl.GetFader: TdxFader; begin Result := nil; end; function TCustomdxBarControl.GetFullItemRect(Item: TdxBarItemControl): TRect; begin Result := GetItemRect(Item); end; function TCustomdxBarControl.GetIsCustomizing; begin Result := BarManager.IsCustomizing; end; function TCustomdxBarControl.GetIsFocused: Boolean; begin Result := BarManager.FocusedBarControl = Self; end; function TCustomdxBarControl.GetIsShadowVisible: Boolean; begin Result := HasShadow and IsWindowVisible(Handle); end; function TCustomdxBarControl.GetItemControlDefaultViewLevel( AItemControl: TdxBarItemControl): TdxBarItemViewLevel; begin Result := ivlDefault; end; function TCustomdxBarControl.GetItemControlOffset(AItemLink: TdxBarItemLink): Integer; begin if AItemLink.BeginGroup and (AItemLink.VisibleIndex > 0) then Result := BeginGroupSize else Result := 0; end; function TCustomdxBarControl.GetItemRect(Item: TdxBarItemControl): TRect; begin if Item = nil then SetRectEmpty(Result) else Result := Item.ItemBounds; end; function TCustomdxBarControl.GetItemRectEx(Item: TdxBarItemControl; IsBeginGroup: Boolean): TRect; begin Result := GetItemRect(Item); end; function TCustomdxBarControl.GetItemRegion(Item: TdxBarItemControl): HRGN; begin Result := CreateRectRgnIndirect(GetItemRectEx(Item, True)); end; function TCustomdxBarControl.GetItemScreenRect(Item: TdxBarItemControl): TRect; begin Result := GetItemRect(Item); MapWindowRect(Handle, 0, Result); end; function TCustomdxBarControl.GetMarkDrawState: TdxBarMarkState; begin Result := MarkState; end; function TCustomdxBarControl.GetNormalItemHeight: Integer; begin // TODO: NormalItemHeight for BarControl Result := Painter.SubMenuControlNormalItemHeight; end; function TCustomdxBarControl.GetOwnerControl: TWinControl; begin if not IsRectEmpty(FOwnerBounds) then Result := FOwnerControl else Result := nil; end; function TCustomdxBarControl.GetPainter: TdxBarPainter; begin if FPainter <> nil then Result := FPainter else if ParentBar <> nil then Result := ParentBar.GetPainter else if DockControl <> nil then Result := DockControl.Painter else Result := BarManager.DefaultPainter; end; function TCustomdxBarControl.GetPaintType: TdxBarPaintType; begin if IsVertical then Result := ptVert else Result := ptHorz; end; function TCustomdxBarControl.GetSelectableObject: TPersistent; begin Result := nil; end; function TCustomdxBarControl.GetSelectionOperation(AButton: TMouseButton; AShift: TShiftState; ASelectableItem: IdxBarSelectableItem): TdxBarSelectionOperation; begin if AButton = mbRight then begin if ASelectableItem.IsComponentSelected and not BarDesignController.IsSelectionComplex(BarManager) then Result := soAdd else Result := soExclusive; end else if ([ssShift, ssCtrl] * AShift = [ssShift]) then begin if ASelectableItem.IsComponentSelected then Result := soExclude else Result := soAdd; end else { #DG - Mouse click on item must cause exclusive selection if ASelectableItem.IsComponentSelected then Result := soAdd else } Result := soExclusive; end; function TCustomdxBarControl.GetToolbarBrush: HBRUSH; begin Result := Painter.BarToolbarBrush(Self); end; function TCustomdxBarControl.GetToolbarDownedBrush: HBRUSH; begin Result := Painter.BarToolbarDownedBrush(Self); end; function TCustomdxBarControl.GetToolbarDownedSelBrush: HBRUSH; begin Result := Painter.BarToolbarDownedSelBrush(Self); end; function TCustomdxBarControl.GetToolbarSelBrush: HBRUSH; begin Result := Painter.BarToolbarSelBrush(Self); end; procedure TCustomdxBarControl.RepaintBarEx(ARecreateControls: Boolean); var APrevSelectedItemLink: TdxBarItemLink; begin if IsDestroying or not HandleAllocated or ([bsCreatingControls, bsDestroyingControls, bsRepaintBar] * FState <> []) or CheckLockUpdate then Exit; Include(FState, bsRepaintBar); try APrevSelectedItemLink := nil; if IsCustomizing then begin //#DG if (BarManager.SelectedItem <> nil) and (BarManager.SelectedItem.Parent = Self) then begin APrevSelectedItemLink := BarManager.SelectedItem.ItemLink; BarManager.FSelectedItem := nil; end; SelectedLink := nil; end; DoRepaintBar(ARecreateControls); if APrevSelectedItemLink <> nil then SetKeySelectedItem(APrevSelectedItemLink.Control); finally Exclude(FState, bsRepaintBar); end; end; procedure TCustomdxBarControl.SetControlVisible(AControl: TdxBarItemControl); begin // do nothing end; function TCustomdxBarControl.GetBorderSize: Integer; begin Result := Painter.GetBorderSize; end; function TCustomdxBarControl.GetIconAreaSize: Integer; begin Result := Painter.GetIconAreaSize(Self); end; function TCustomdxBarControl.GetTextSize: Integer; begin Result := Painter.GetDefaultTextSize(Canvas); end; function TCustomdxBarControl.GetWindowRect: TRect; begin Windows.GetWindowRect(Handle, Result); end; function TCustomdxBarControl.GetWindowPoint(const AClientPoint: TPoint): TPoint; begin Result := AClientPoint; Result.X := Result.X + NCOffset.X; Result.Y := Result.Y + NCOffset.Y; end; function TCustomdxBarControl.HasShadow: Boolean; begin Result := Painter.BarHasShadow(Self); end; procedure TCustomdxBarControl.Hide; begin SetWindowPos(Handle, 0, 0, 0, 0, 0, SWP_NOZORDER or SWP_NOMOVE or SWP_NOSIZE or SWP_HIDEWINDOW or SWP_NOACTIVATE); if SelectedControl <> nil then SelectedControl.ParentVisibleChange(False); end; procedure TCustomdxBarControl.HideAllByEscape; begin ClosedByEscape := True; HideAll; end; function TCustomdxBarControl.HideOnClick: Boolean; begin Result := False; end; function TCustomdxBarControl.IsChildBar(Value: TCustomdxBarControl): Boolean; begin Result := False; while Value.ParentBar <> nil do begin Value := Value.ParentBar; if Self = Value then begin Result := True; Exit; end; end; end; function TCustomdxBarControl.IsChildWindow(AWnd: HWND): Boolean; begin Result := IsChildEx(Handle, AWnd) or (SelectedControl <> nil) and SelectedControl.IsChildWindow(AWnd); end; function TCustomdxBarControl.IsControlExists(ABarItemControl: TdxBarItemControl): Boolean; begin Result := ItemLinks.IsControlExists(ABarItemControl); end; function TCustomdxBarControl.IsLinkedToOwner: Boolean; var R1, R2: TRect; begin R1 := FOwnerBounds; R2 := BoundsRect; Result := ((R1.Bottom = R2.Top) or (R1.Top = R2.Bottom)) and (R1.Left < R2.Right) and (R1.Right > R2.Left) or ((R1.Right = R2.Left) or (R1.Left = R2.Right)) and (R1.Top < R2.Bottom) and (R1.Bottom > R2.Top); end; function TCustomdxBarControl.IsMeaningParent(AWnd: HWND): Boolean; begin Result := False; end; function TCustomdxBarControl.IsPopup: Boolean; begin Result := False; end; function TCustomdxBarControl.IsVerticalDirection: Boolean; begin Result := IsRealVertical; end; function TCustomdxBarControl.IsWindowEnabled: Boolean; begin Result := HandleAllocated and dxBar.IsWindowEnabled(Handle); //TODO Windows.IsWindowEnabled(Handle) and Windows.IsWindowEnabled(BarManager.Owner.Handle);//#DG end; procedure TCustomdxBarControl.MakeItemControlFullyVisible( AItemControl: TdxBarItemControl); begin end; function TCustomdxBarControl.MarkExists: Boolean; begin Result := False; end; function TCustomdxBarControl.MarkRect: TRect; begin Result := cxNullRect; end; function TCustomdxBarControl.MouseOnMark(const AMousePos: TPoint): Boolean; begin Result := PtInRect(MarkRect, AMousePos); end; function TCustomdxBarControl.MouseOnMark: Boolean; begin Result := MouseOnMark(ScreenToClient(GetMouseCursorPos)); end; procedure TCustomdxBarControl.ActivateHint(AShow: Boolean; const ACustomHint: string; AHintObject: TObject = nil); begin BarManager.ActivateHint(AShow, ACustomHint, AHintObject); end; function TCustomdxBarControl.CreateHintViewInfo(const AHintText, AShortCut: string; AScreenTip: TdxBarScreenTip): TdxBarCustomHintViewInfo; begin Result := Painter.CreateHintViewInfo(BarManager, AHintText, AShortCut, AScreenTip); end; function TCustomdxBarControl.GetHintPosition(const AItemBounds: TRect; const ACursorPos: TPoint; AHeight: Integer): TPoint; begin Result := Painter.GetBarItemContolHintPosition(Self, AItemBounds, ACursorPos, AHeight); end; function TCustomdxBarControl.NeedShowGlyphAndCheckForItem: Boolean; begin Result := False; end; function TCustomdxBarControl.NotHandleMouseMove (ACheckLastMousePos: Boolean = True): Boolean; begin Result := IsCustomizing or ACheckLastMousePos and cxPointIsEqual(FLastMousePos, GetMouseCursorPos) or not PtInRect(WindowRect, GetMouseCursorPos); end; procedure TCustomdxBarControl.PaintItem(AControl: TdxBarItemControl); begin if IsDestroying or (AControl = nil) or (AControl.ItemLink = nil) or (AControl.ItemLink.Control = nil) or (AControl.ItemLink.Item.IsDestroying) or (bsPaintItem in FState) or CheckLockUpdate then Exit; Include(FState, bsPaintItem); try FBkBrush := ToolbarBrush; DoPaintItem(AControl, Canvas, AControl.ItemBounds); finally Exclude(FState, bsPaintItem); end; end; procedure TCustomdxBarControl.ResizeShadow; var R: TRect; begin if IsLinkedToOwner then R := FOwnerBounds else SetRectEmpty(R); FShadow.SetOwnerBounds(R, BoundsRect); end; procedure TCustomdxBarControl.SetCursorForMoving(AMoving: Boolean); const Cursors: array[Boolean] of TCursor = (crDefault, crSizeAll); begin Cursor := Cursors[AMoving]; end; procedure TCustomdxBarControl.SetDockingStyle(Value: TdxBarDockingStyle); begin if FDockingStyle <> Value then begin FDockingStyle := Value; ResetBackground; Perform(CM_FONTCHANGED, 0, 0); SetLayeredAttributes; end; end; procedure TCustomdxBarControl.SetLayeredAttributes; begin end; function TCustomdxBarControl.SelectedItemWantsKey(Key: Word): Boolean; begin Result := (SelectedControl <> nil) and SelectedControl.Enabled and SelectedControl.WantsKey(Key); if Result then SelectedControl.KeyDown(Key, []); end; procedure TCustomdxBarControl.SelectItemControl(AItemControl: TdxBarItemControl; AButton: TMouseButton; AShift: TShiftState); var ASelectableItem: IdxBarSelectableItem; begin if AButton = mbRight then AShift := []; if (AItemControl = nil) then ASelectableItem := GetSelectableItem(GetSelectableObject) else begin BarGetFocus(AItemControl); ASelectableItem := GetSelectableItem(AItemControl.GetSelectableObject); case AButton of mbLeft: begin if ItemLinks.VisibleItemCount = 0 then //#DG ??? Exit; if AItemControl.CanCustomize then {1} begin if AItemControl = SelectedControl then begin if AItemControl.IsActive then AItemControl.ControlInactivate(True) else AItemControl.ControlActivate(True); //#DG BarManager.SelectedItem := AItemControl; //#DG To exclude superfluous Repaint AItemControl.Repaint; end; SetMouseSelectedItem(AItemControl); end; end; mbRight: begin if SelectedControl <> nil then SelectedControl.ControlInactivate(True); if AItemControl = SelectedControl then begin BarManager.SelectedItem := AItemControl; //#DG To exclude superfluous Repaint AItemControl.Repaint; end; SetKeySelectedItem(AItemControl); end; end; end; BarDesignController.SelectItem(ASelectableItem, GetSelectionOperation(AButton, AShift, ASelectableItem)); end; procedure TCustomdxBarControl.SetAccelSelectedItem(AItemControl: TdxBarItemControl; ADuplicate: Boolean); begin SetKeySelectedItem(AItemControl); if not ADuplicate then SendMessage(Handle, WM_KEYDOWN, VK_RETURN, 0); end; procedure TCustomdxBarControl.SetKeySelectedItem(Value: TdxBarItemControl); begin if not HandleAllocated or (csDestroying in ComponentState) then Exit; if SelectedControl <> Value then begin if (SelectedControl <> nil) and SelectedControl.IsActive then SelectedControl.ControlInactivate(True); if not BarControlExists(Self) then Exit; if Value is TdxBarSubItemControl then TdxBarSubItemControl(Value).FShowAnimation := False; if Value <> nil then Value.FSelectedByMouse := False; SelectedControl := Value; if Value <> nil then MakeItemControlFullyVisible(Value); end; end; procedure TCustomdxBarControl.SetMouseSelectedItem(Value: TdxBarItemControl); var AErrorText: string; begin if not HandleAllocated or (csDestroying in ComponentState) or BarNavigationController.NavigationMode and (bboMouseCantUnselectNavigationItem in BehaviorOptions) then Exit; if (SelectedControl <> Value) and not ((SelectedControl <> nil) and SelectedControl.HasWindow and TdxBarWinControl(SelectedControl).Focused) then begin if (SelectedControl <> nil) and SelectedControl.IsActive then SelectedControl.ControlInactivate(False); if Value <> nil then Value.FSelectedByMouse := True; SelectedControl := Value; if not BarControlExists(Self) then Exit; if SelectedControl <> nil then begin if SelectedControl is TdxBarSubItemControl then with TCustomdxBarSubItem(GetItemByLink(SelectedLink)) do if BarManager.Dragging and not CanContainItem(BarManager.DraggingItem, AErrorText) then Exit else TdxBarSubItemControl(SelectedControl).FShowAnimation := True; SelectedControl.ControlActivate(False); end; end; end; procedure TCustomdxBarControl.SetSelectedControl(Value: TdxBarItemControl); var AOldSelectedControl: TdxBarItemControl; AParentBar: TCustomdxBarControl; AQuickControl: TdxBarQuickControl; begin if SelectedControl <> Value then begin if BarDesignController.QuickControl is TdxBarQuickControl then begin AQuickControl := TdxBarQuickControl(BarDesignController.QuickControl); if not AQuickControl.IsActive and (AQuickControl <> Self) and (Value <> nil) then AQuickControl.StartHidingTimer; end; AOldSelectedControl := SelectedControl; SelectedLink := GetLinkByControl(Value); if bboMouseCantUnselectNavigationItem in BehaviorOptions then IsDowned := False; if IsCustomizing then begin BarManager.SelectedItem := Value; if not BarControlExists(Self) then Exit; end else if not BarManager.IsCustomizing then BarManager.FSelectedItem := Value; UpdateItem(AOldSelectedControl); UpdateItem(SelectedControl); //#DG GetCursorPos(FLastMousePos); if SelectedControl = nil then Cursor := crDefault; if (SelectedControl <> nil) or (Self is TdxBarSubMenuControl) or (TdxBarControl(Self).MarkState = msNone) then BarManager.HintActivate(True, '', SelectedControl); // for Application.Hint: if (SelectedControl <> nil) and (SelectedControl.Enabled or BarManager.ShowHintForDisabledItems) then Hint := GetLongHint(SelectedControl.Hint) else Hint := ''; AParentBar := GetParentBarOrSubMenuForBar(Self); if (AParentBar is TdxBarSubMenuControl) and (AParentBar.ItemLinks.Owner is TdxBarCustomPopupMenu) and TdxBarCustomPopupMenu(AParentBar.ItemLinks.Owner).FUseOwnMessageLoop then Application.Hint := Hint; end; end; procedure TCustomdxBarControl.Show; begin ShowWindow(Handle, SW_SHOWNOACTIVATE); if SelectedControl <> nil then SelectedControl.ParentVisibleChange(True); end; procedure TCustomdxBarControl.UpdateCanvasFont; var ALogFont: TLogFont; begin if bsUpdatingCanvasFont in FState then Exit; Include(FState, bsUpdatingCanvasFont); try if IsVertical then begin cxGetFontData(Font.Handle, ALogFont); ALogFont.lfEscapement := -900; ALogFont.lfOrientation := ALogFont.lfEscapement; ALogFont.lfOutPrecision := OUT_TT_ONLY_PRECIS; Canvas.Font.Handle := CreateFontIndirect(ALogFont); end else Canvas.Font := Font; finally Exclude(FState, bsUpdatingCanvasFont); end; end; procedure TCustomdxBarControl.UpdateControlStyle; begin if (BarManager.GetPaintStyle = bmsStandard) and not IsCustomizing then // ??? ControlStyle := ControlStyle - [csDoubleClicks] else ControlStyle := ControlStyle + [csDoubleClicks]; end; procedure TCustomdxBarControl.ViewStateChanged(APrevValue: TdxBarViewState); begin end; function TCustomdxBarControl.WantMouse: Boolean; begin Result := WindowFromPointEx(GetMouseCursorPos) = Handle; end; procedure TCustomdxBarControl.DoShowPopup(ASelectedControl: TdxBarItemControl); begin if (ASelectedControl <> nil) or BarManager.Designing then BarDesignController.ShowCustomizePopup(Self, GetLinkByControl(ASelectedControl)); end; procedure TCustomdxBarControl.InitCustomizationPopup(AItemLinks: TdxBarItemLinks); begin // do nothing end; procedure TCustomdxBarControl.ShowPopup(AItem: TdxBarItemControl); begin DoShowPopup(SelectedControlAtDesign); end; procedure TCustomdxBarControl.FillBackgroundRgn(DC: HDC; ARgn: HRGN; ABrush: HBRUSH; AIsClientArea: Boolean); var AClipRgn: HRGN; AClipRgnExists: Boolean; begin SaveClipRgn(DC, AClipRgn, AClipRgnExists); ExtSelectClipRgn(DC, ARgn, RGN_AND); FillBackground(DC, NCRect, ABrush, clNone, AIsClientArea); RestoreClipRgn(DC, AClipRgn, AClipRgnExists); end; procedure TCustomdxBarControl.FullInvalidate; begin if HandleAllocated then SendMessage(Handle, WM_NCPAINT, 0, 0); Invalidate; end; procedure TCustomdxBarControl.FullRepaint; begin if HandleAllocated then SendMessage(Handle, WM_NCPAINT, 0, 0); Repaint; end; procedure TCustomdxBarControl.InvalidateNCRect(ARect: TRect); var ARegion: HRGN; begin ARect := cxRectOffset(ARect, WindowRect.TopLeft); ARegion := CreateRectRgnIndirect(ARect); SendMessage(Handle, WM_NCPAINT, ARegion, 0); DeleteObject(ARegion); end; function TCustomdxBarControl.IsInternal: Boolean; begin Result := False; end; function TCustomdxBarControl.IsBackgroundBitmap: Boolean; begin Result := (DockControl <> nil) and DockControl.IsBackgroundBitmap; end; function TCustomdxBarControl.IsTransparent: Boolean; begin Result := (DockControl <> nil) and DockControl.IsTransparent; end; function TCustomdxBarControl.NCOffset: TPoint; begin Result.X := 0; Result.Y := 0; end; function TCustomdxBarControl.PointBarToDock(const APoint: TPoint): TPoint; var ABounds: TRect; begin ABounds := BoundsRect; Result.X := APoint.X + ABounds.Left; Result.Y := APoint.Y + ABounds.Top; end; procedure TCustomdxBarControl.ResetBackground; begin FBackgroundTempBitmap.Assign(nil); end; procedure TCustomdxBarControl.UpdateDoubleBuffered; begin DoubleBuffered := IsTransparent or BarManager.IsUncustomizable; end; procedure TCustomdxBarControl.HideAll; var ALinkSelf: TcxObjectLink; begin if bsHideAll in FState then Exit; ALinkSelf := cxAddObjectLink(Self); Include(FState, bsHideAll); try DoHideAll; finally if ALinkSelf.Ref <> nil then Exclude(FState, bsHideAll); cxRemoveObjectLink(ALinkSelf); end; end; function TCustomdxBarControl.IsRealVertical: Boolean; begin Result := False; end; function TCustomdxBarControl.IsVertical: Boolean; begin Result := False; end; function TCustomdxBarControl.ItemAtPos(const APos: TPoint): TdxBarItemControl; var I: Integer; begin Result := nil; if not IsCustomizing or CanCustomizing then for I := 0 to ViewInfo.ItemControlCount - 1 do if PtInRect(ViewInfo.ItemControlViewInfos[I].Bounds, APos) then begin Result := ViewInfo.ItemControlViewInfos[I].Control; Break; end; end; procedure TCustomdxBarControl.RepaintBar; begin RepaintBarEx(True); end; { TdxDockCol } constructor TdxDockCol.Create(ADockRow: TdxDockRow; ABarControl: TdxBarControl); begin inherited Create; FDockRow := ADockRow; FBarControl := ABarControl; end; procedure TdxDockCol.AssignPosition; begin with FBarControl do FPos := Point(Left, Top); end; { TdxDockRow } constructor TdxDockRow.Create(ADockControl: TdxDockControl); begin inherited Create; FDockControl := ADockControl; FColList := TList.Create; FBars := TList.Create; end; destructor TdxDockRow.Destroy; var I: Integer; begin for I := ColCount - 1 downto 0 do Cols[I].Free; FreeAndNil(FColList); while FBars.Count <> 0 do TdxBar(FBars[0]).RemoveFromDockRow(False); FreeAndNil(FBars); inherited; end; function TdxDockRow.AddCol(ABarControl: TdxBarControl): TdxDockCol; begin Result := TdxDockCol.Create(Self, ABarControl); ColList.Add(Result); UpdateOneOnRows; end; procedure TdxDockRow.DeleteCol(ABarControl: TdxBarControl); var I: Integer; begin if FColList = nil then Exit; for I := 0 to ColCount - 1 do if Cols[I].BarControl = ABarControl then begin DeleteCol(I); Break; end; end; procedure TdxDockRow.DeleteCol(AIndex: Integer); begin Cols[AIndex].Free; ColList.Delete(AIndex); UpdateOneOnRows; end; procedure TdxDockRow.AddBar(ABar: TdxBar); var I: Integer; ACol: TdxDockCol; begin FBars.Add(ABar); if (FBars.Count > ColCount) and (ABar.Control <> nil) and (ABar.RealDockControl = DockControl) then begin for I := 0 to ColCount - 1 do if TdxDockCol(ColList[I]).BarControl = ABar.Control then Exit; ACol := TdxDockCol.Create(Self, ABar.Control); ColList.Add(ACol); UpdateOneOnRows; ACol.Pos := Point(ABar.DockedLeft, ABar.DockedTop); end; end; procedure TdxDockRow.DeleteBar(ABar: TdxBar; ADestroyEmptyDockRow: Boolean); begin if FBars.IndexOf(ABar) < 0 then Exit; FBars.Delete(FBars.IndexOf(ABar)); if ABar.Control <> nil then DeleteCol(ABar.Control); if (FBars.Count = 0) and ADestroyEmptyDockRow then begin FDockControl.RowList.Delete(FDockControl.RowList.IndexOf(Self)); Free; end; end; function TdxDockRow.GetCol(Index: Integer): TdxDockCol; begin Result := FColList[Index]; end; function TdxDockRow.GetColCount: Integer; begin Result := FColList.Count; end; function TdxDockRow.GetVisible: Boolean; var ABarControl: TdxBarControl; I: Integer; begin Result := False; for I := 0 to FBars.Count - 1 do begin ABarControl := TdxBar(FBars[I]).Control; if (ABarControl <> nil) and (ABarControl.DockingStyle <> dsNone) then begin Result := True; Break; end; end; end; procedure TdxDockRow.UpdateOneOnRows; var I: Integer; begin for I := 0 to ColCount - 1 do Cols[I].BarControl.Bar.OneOnRow := ColCount = 1; end; { TdxBarControl } constructor TdxBarControl.CreateEx(AOwner: TComponent; ABar: TdxBar); begin inherited Create(AOwner); FBar := ABar; end; constructor TdxBarControl.CreateForPopup(AParentBarControl: TdxBarControl; ABar: TdxBar); begin CreateEx(ABar.BarManager, ABar); FPopupBar := ABar; ParentBar := AParentBarControl; BarManager.Bars.BeginUpdate; try Bar := BarManager.Bars.Add; Bar.AllowQuickCustomizing := False; Bar.Hidden := True; Bar.Font := AParentBarControl.Font; Bar.UseOwnFont := False; finally BarManager.Bars.EndUpdate(False); end; ItemLinks := Bar.ItemLinks; ItemLinks.BarControl := Self; ItemLinks.Internal := True; end; destructor TdxBarControl.Destroy; begin //#DG Destroying; AccessibilityHelperOwnerObjectDestroyed(FMarkIAccessibilityHelper); if (FBar <> nil) and (FBar.Bars <> nil) and (DockingStyle <> dsNone) then FBar.Bars.UnregFromDock(FDockingStyle, FDockControl, Self); BarLostFocus; // HideAll; //#DG TODO: CHECK IT!!! if WindowHandle = 0 then DestroyControls else DestroyHandle; inherited Destroy; if IsPopup then FreeAndNil(FBar); end; function TdxBarControl.ClientToScreen(const APoint: TPoint): TPoint; begin Result := APoint; Windows.ClientToScreen(Handle, Result); end; procedure TdxBarControl.CloseUp; begin ParentBar.MarkState := msNone; end; function TdxBarControl.GetCaptionBkColor: COLORREF; begin Result := Painter.BarCaptionBkColor(Self, BarManager.MainFormActive); end; function TdxBarControl.GetCaptionButtons: TdxBarCaptionButtons; begin Result := Bar.CaptionButtons; end; function TdxBarControl.GetCaptionColor: COLORREF; begin Result := Painter.BarCaptionColor(Self); end; function TdxBarControl.GetHorizontal: Boolean; begin Result := DockingStyle in [dsTop, dsBottom]; end; function TdxBarControl.GetInternallyLocked: Boolean; begin Result := FInternalLockCount <> 0; end; function TdxBarControl.GetMarkIAccessibilityHelper: IdxBarAccessibilityHelper; begin if FMarkIAccessibilityHelper = nil then FMarkIAccessibilityHelper := GetAccessibilityHelper(GetMarkAccessibilityHelperClass.Create(Self)); Result := FMarkIAccessibilityHelper; end; function TdxBarControl.GetVertical: Boolean; begin Result := DockingStyle in [dsLeft, dsRight]; end; procedure TdxBarControl.SetCloseButtonState(Value: TdxBarMarkState); var DC: HDC; begin if FCloseButtonState <> Value then begin FCloseButtonState := Value; if HandleAllocated then begin DC := GetWindowDC(Handle); DrawCloseButton(DC); ReleaseDC(Handle, DC); end; end; end; procedure TdxBarControl.SetMoving(Value: Boolean); var I: Integer; KillingHandle: HWND; begin if FMoving <> Value then begin FMovingChanging := True; try FMoving := Value; if Value then FBar.Bars.FMovingBarControl := Self else FBar.Bars.FMovingBarControl := nil; // SetCursorForMoving(Value); for I := 0 to ItemLinks.CanVisibleItemCount - 1 do if ItemLinks.CanVisibleItems[I].Control.HasWindow then with TdxBarWinControl(ItemLinks.CanVisibleItems[I].Control) do if FMoving then DestroyInnerEdit else CreateInnerEdit; if FMoving then begin if FDockingStyle = dsNone then begin FFloatingHandle := Handle; FDockingStyle := dsLeft; FDockControl := FBar.Bars.FDockControls[dsLeft]; DestroyControls; WindowHandle := 0; CreateHandle; FDockedHandle := Handle; WindowHandle := 0; FDockingStyle := Bar.DockingStyle; FDockControl := nil; BeginInternal; try CreateHandle; finally EndInternal; end; Windows.SetParent(FDockedHandle, 0); end else begin FDockedHandle := Handle; FDockingStyle := dsNone; DestroyControls; WindowHandle := 0; CreateHandle; FFloatingHandle := Handle; WindowHandle := 0; FDockingStyle := Bar.DockingStyle; BeginInternal; try CreateHandle; finally EndInternal; end; end; // this code creates problems with other relative popups // SetWindowPos(FFloatingHandle, HWND_TOPMOST, 0, 0, 0, 0, // SWP_NOMOVE or SWP_NOSIZE or SWP_NOACTIVATE); end else begin // this code makes top-most windows normal //SetWindowPos(FFloatingHandle, HWND_NOTOPMOST, 0, 0, 0, 0, // SWP_NOMOVE or SWP_NOSIZE or SWP_NOACTIVATE); if FDockingStyle = dsNone then KillingHandle := FDockedHandle else KillingHandle := FFloatingHandle; SetWindowLong(KillingHandle, GWL_WNDPROC, Longint(DefWndProc)); DestroyWindow(KillingHandle); SavePos; end; SetCursorForMoving(Value); Perform(WM_SIZE, 0, 0); // to store normal size RepaintBar; finally FMovingChanging := False; end; end; end; procedure TdxBarControl.ChangeStyleWinTo(AStyle: TdxBarDockingStyle; ADockControl: TdxDockControl); begin if (FBar = nil) or (FBar.Bars = nil) or IsDestroying then Exit; if FMoving then begin DockControl := ADockControl; DockingStyle := AStyle; WindowHandle := 0; BeginInternal; try CreateHandle; finally EndInternal; end; if FDockingStyle = dsNone then Windows.SetParent(FDockedHandle, 0) else Windows.SetParent(Handle, FDockControl.Handle); RepaintBar; end else begin BeginInternal; try DestroyHandle; finally EndInternal; end; DockControl := ADockControl; DockingStyle := AStyle; CreateHandle; FrameChanged; end; end; function TdxBarControl.GetDragPointOffset(Style: TdxBarDockingStyle): TPoint; begin if (Style <> dsNone) and (Self = Bar.Bars.FMovingBarControl) and (Style = Bar.Bars.FMovingBarOriginalDockingStyle) then with Bar.Bars do if Vertical then Result := Point(-FMovingOffset.X, FMovingStaticOffset.Y) else Result := Point(FMovingStaticOffset.X, -FMovingOffset.Y) else with GetTrackSize(Style) do begin Result.X := MulDiv(X, RX.X, RX.Y); Result.Y := MulDiv(Y, RY.X, RY.Y); end; end; function TdxBarControl.GetCaptionNCRect: TRect; begin Result := Painter.GetToolbarCaptionRect(NCRect); end; function TdxBarControl.GetCaptionRect: TRect; begin Result := cxRectOffset(GetCaptionNCRect, WindowRect.TopLeft); MapWindowRect(0, Handle, Result); end; procedure TdxBarControl.DrawCloseButton(DC: HDC); begin Painter.BarDrawCloseButton(Self, DC, CloseButtonRectNC); end; procedure TdxBarControl.DrawMark(DC: HDC); begin Painter.BarDrawMark(Self, DC, MarkNCRect); end; procedure TdxBarControl.DrawMDIButton(AButton: TdxBarMDIButton; ASelected, APressed: Boolean); var R: TRect; DC: HDC; begin R := RectMDI(AButton); DC := Canvas.Handle; Painter.BarDrawMDIButton(Self, AButton, ASelected, APressed, DC, R); end; function TdxBarControl.GetMDIWidth: Integer; begin if RealMDIButtonsOnBar then if IsRealVertical then Result := MDIButtonWidth else Result := 3 * MDIButtonWidth + 2 else Result := MDIButtonWidth; end; function TdxBarControl.GetMDIHeight: Integer; begin if RealMDIButtonsOnBar then if IsRealVertical then Result := 3 * MDIButtonHeight + 2 else Result := MDIButtonHeight else Result := MDIButtonHeight; end; function TdxBarControl.RectMDI(Button: TdxBarMDIButton): TRect; var AVertical: Boolean; AWidth, AHeight, W, H, MDISize, Offset: Integer; function MDIButtonsHaveOwnRow: Boolean; var I, L: Integer; begin Result := False; L := ItemLinks.VisibleItemCount - 1; for I := L downto 0 do with ItemLinks.VisibleItems[I] do begin if Control.FLastInRow and (I <> L) then begin Result := True; Break; end; if AVertical then if ItemRect.Left < Offset then Break else else if ItemRect.Bottom > Offset then Break; if I = 0 then Result := True; end; end; begin SetRectEmpty(Result); AVertical := Vertical; if AVertical then begin AWidth := ClientHeight; AHeight := ClientWidth; W := MDIButtonHeight; H := MDIButtonWidth; MDISize := GetMDIHeight; end else begin AWidth := ClientWidth; AHeight := ClientHeight; W := MDIButtonWidth; H := MDIButtonHeight; MDISize := GetMDIWidth; end; if (DockingStyle <> dsNone) and MarkExists then Dec(AWidth, Painter.MarkSizeX); if MultiLine then begin if AVertical then Offset := H else Offset := AHeight - H; if not MDIButtonsHaveOwnRow then if ItemLinks.VisibleItemCount = 0 then Offset := (AHeight - H) div 2 else Offset := AHeight - (ItemLinks.VisibleItems[ItemLinks.VisibleItemCount - 1].RowHeight - H) div 2 - H else if AVertical then Offset := AHeight - Offset; end else Offset := (AHeight - H) div 2; if RealMDIButtonsOnBar then begin Result := Bounds(AWidth - MDISize + W * Ord(Button), Offset, W, H); if Button = mdibClose then OffsetRect(Result, 2, 0); end else Result := Bounds(AWidth - W, Offset, W, H); if AVertical then with Result do begin W := Left; Left := AHeight - Bottom; Bottom := Right; Right := AHeight - Top; Top := W; end; end; function TdxBarControl.RealMDIButtonsOnBar: Boolean; begin Result := IsMainMenu and BarManager.IsMDIMaximized and (GetSystemMenu(BarManager.ActiveMDIChild, False) <> 0); end; function TdxBarControl.MDIButtonsOnBar: Boolean; begin Result := RealMDIButtonsOnBar or IsMainMenu and BarManager.ShowCloseButton; end; function TdxBarControl.MDIButtonEnabled(AButton: TdxBarMDIButton; State: Integer): Boolean; begin Result := (AButton = mdibRestore) or (AButton = mdibClose) and not RealMDIButtonsOnBar and MDIButtonsOnBar or (GetMenuState(GetSystemMenu(BarManager.ActiveMDIChild, False), MDIButtonCommands[AButton], MF_BYCOMMAND) and State = 0); end; procedure MoreButtonsHintTimerProc(Wnd: HWND; Msg: UINT; idEvent: UINT; Time: DWORD); stdcall; var BarControl: TdxBarControl; begin BarControl := TdxBarControl(FindControl(Wnd)); with BarControl do if not IsWindowVisible(Handle) or not MouseOnMark then FinishMoreButtonsHintTimer; end; procedure TdxBarControl.StartMoreButtonsHintTimer; begin FMoreButtonsHintTimer := SetTimer(Handle, 1, 50, @MoreButtonsHintTimerProc); end; procedure TdxBarControl.FinishMoreButtonsHintTimer; begin if dxKillTimer(0, FMoreButtonsHintTimer) and (MarkState = msSelected) then MarkState := msNone; end; function TdxBarControl.CanResizeSelectedLink(APoint: TPoint): Boolean; begin Result := (SelectedControlAtDesign <> nil) and SelectedControlAtDesign.CanResize(APoint); end; procedure TdxBarControl.WMCaptureChanged(var Message: TMessage); begin inherited; if FIsResizing then begin FIsResizing := False; SelectedControl.EndResize(False); end; end; procedure TdxBarControl.WMDestroy(var Message: TMessage); var ADockControl: TdxDockControl; begin ADockControl := DockControl; if ADockControl <> nil then ADockControl.IsBarHandleDestroying := True; try FinishMoreButtonsHintTimer; inherited; if (FBar <> nil) and not InternallyLocked and not IsInternal and FBar.Visible and not BarManager.IsDestroying then begin BarManager.AddBarToRestoringList(Bar); FBar.Visible := False; end; finally if ADockControl <> nil then ADockControl.IsBarHandleDestroying := False; end; end; procedure TdxBarControl.WMGetDlgCode(var Message: TWMGetDlgCode); begin Message.Result := DLGC_WANTALLKEYS or DLGC_WANTARROWS or DLGC_WANTTAB; end; procedure TdxBarControl.WMGetMinMaxInfo(var Message: TWMGetMinmaxInfo); begin inherited; with Message.MinMaxInfo^ do begin ptMinTrackSize := Point(10, 10); ptMaxTrackSize := Point(30000, 30000); // because of Win95/98 ptMaxSize := ptMaxTrackSize; ptMaxPosition := ptMaxSize; end; end; procedure TdxBarControl.WMGetObject(var Message: TMessage); begin // if CanReturnAccessibleObject(Message) then // Message.Result := WMGetObjectResultFromIAccessibilityHelper(Message, IAccessibilityHelper) // else inherited; end; procedure TdxBarControl.WMKeyDown(var Message: TWMKeyDown); begin inherited; if (ActiveBarControl = nil) or SelectedItemWantsKey(Message.CharCode) then Exit; with Message do case CharCode of VK_ESCAPE: begin CharCode := 0; HideAllByEscape; end; VK_RETURN: SelectedControl.Click(False); end; end; procedure TdxBarControl.WMLButtonDblClk(var Message: TWMLButtonDblClk); begin CheckMarkState(Point(Message.XPos, Message.YPos)); inherited; end; procedure TdxBarControl.WMLButtonUp(var Message: TWMLButtonUp); var P: TPoint; AButton: TdxBarMDIButton; begin if FIgnoreMouseClick then begin FIgnoreMouseClick := False; Exit; end; if FIsResizing then begin FIsResizing := False; SelectedControl.EndResize(True); ReleaseCapture; Exit; end; P := Point(Message.XPos, Message.YPos); if MDIButtonsOnBar and FIsMDIButtonPressed then begin ReleaseCapture; FIsMDIButtonPressed := False; FIsMouseOverMDIButton := False; RepaintMDIButtons; if not RealMDIButtonsOnBar then begin if PtInRect(RectMDI(mdibClose), P) then BarManager.DoCloseButtonClick; end else begin for AButton := Low(TdxBarMDIButton) to High(TdxBarMDIButton) do if PtInRect(RectMDI(AButton), P) then begin if AButton = FPressedMDIButton then SendMessage(BarManager.ActiveMDIChild, WM_SYSCOMMAND, MDIButtonCommands[AButton], 0); Break; end; end; end; inherited; end; procedure TdxBarControl.WMMouseActivate(var Message: TWMMouseActivate); begin inherited; if not IsActive and (DockingStyle = dsNone) then dxSetZOrder(Handle, HWND_TOP); //ProcessPaintMessages; end; procedure TdxBarControl.WMNCCalcSize(var Message: TWMNCCalcSize); var AContentOffsets: TRect; begin if not FMovingChanging then FHasSizeGrip := FBar.HasSizeGrip; AContentOffsets := Painter.GetToolbarContentOffsets(Bar, DockingStyle, FHasSizeGrip); with Message.CalcSize_Params^.rgrc[0] do begin Inc(Left, AContentOffsets.Left); Inc(Top, AContentOffsets.Top); Dec(Right, AContentOffsets.Right); Dec(Bottom, AContentOffsets.Bottom); end; end; procedure TdxBarControl.WMNCHitTest(var Message: TWMNCHitTest); var P: TPoint; AControl: TdxBarItemControl; function MouseAboveMDIButtons: Boolean; begin Result := MDIButtonsOnBar and (RealMDIButtonsOnBar and (PtInRect(RectMDI(mdibMinimize), P) or PtInRect(RectMDI(mdibRestore), P)) or PtInRect(RectMDI(mdibClose), P)); end; function NoControl: Boolean; begin Result := (AControl = nil) or not IsCustomizing and not AControl.HotPartWantMouse; end; begin inherited; if bboUnmoved in BehaviorOptions then begin FHitTest := Message.Result; Exit; end; FHitTest := 0; P := SmallPointToPoint(Message.Pos); Windows.ScreenToClient(Handle, P); with Message do if DockingStyle = dsNone then case Result of HTTOPLEFT, HTTOPRIGHT: if YPos < WindowRect.Top + Painter.BorderSizeY then begin FHitTest := HTTOP; Result := HTTOP; end else if Result = HTTOPLEFT then begin FHitTest := HTLEFT; Result := HTLEFT; end else begin FHitTest := HTRIGHT; Result := HTRIGHT; end; HTBOTTOMLEFT, HTBOTTOMRIGHT: if YPos > WindowRect.Bottom - Painter.BorderSizeY then begin FHitTest := HTBOTTOM; Result := HTBOTTOM; end else if Result = HTBOTTOMLEFT then begin FHitTest := HTLEFT; Result := HTLEFT; end else begin FHitTest := HTRIGHT; Result := HTRIGHT; end; HTCLIENT: begin AControl := ItemAtPos(P); if NoControl and not MouseAboveMDIButtons then begin FHitTest := HTCAPTION; Result := HTCLIENT; end; end; HTNOWHERE: begin if not IsCustomizing and MarkExists and MouseOnMark(P) then FHitTest := HTCLIENT else if PtInRect(CloseButtonRect, P) then if not Painter.BarUseSystemClose then FHitTest := HTCLOSE else begin FHitTest := HTCLIENT; Result := HTCLOSE; Exit; end else FHitTest := HTCAPTION; Result := HTCLIENT; end; else FHitTest := Result; end else // DockingStyle <> dsNone begin if Result = HTCLIENT then AControl := ItemAtPos(P) else AControl := nil; if (Result = HTCLIENT) and NoControl or (Result = HTNOWHERE) then begin if not Vertical and (P.X < 0) or Vertical and (P.Y < 0) or NoControl and not MouseAboveMDIButtons and (not MarkExists or not MouseOnMark(P)) then if FHasSizeGrip and PtInRect(SizeGripRect, P) then begin FHitTest := HTBOTTOMRIGHT; Result := HTBOTTOMRIGHT; end else begin FHitTest := HTCAPTION; Result := HTCLIENT; end; end else begin FHitTest := Result; Result := HTCLIENT; end; end; end; procedure TdxBarControl.WMNCLButtonDown(var Message: TWMNCLButtonDown); const CloseButtonID = -2; var ACloseButtonRectNC: TRect; AActiveButtonID: Integer; function GetWindowCursorPos: TPoint; begin Result := cxPointOffset(GetMouseCursorPos, cxPointInvert(WindowRect.TopLeft)); end; function GetButtonID(const APoint: TPoint): Integer; begin if PtInRect(ACloseButtonRectNC, APoint) then Result := CloseButtonID else Result := CaptionButtons.GetButtonIndex(APoint); end; procedure UpdateButtonState(AMousePressed: Boolean); var APoint: TPoint; begin APoint := GetWindowCursorPos; if AActiveButtonID = CloseButtonID then if GetButtonID(APoint) = CloseButtonID then if AMousePressed then CloseButtonState := msPressed else CloseButtonState := msSelected else if AMousePressed then CloseButtonState := msSelected else CloseButtonState := msNone else CaptionButtons.UpdateButtonStates(APoint, AMousePressed); end; procedure DoClick; var ABar: TdxBar; begin if AActiveButtonID = CloseButtonID then begin ABar := FBar; Bar.Visible := False; ABar.BarManager.DesignerModified; ABar.BarManager.DoBarClose(ABar); end else CaptionButtonClick(AActiveButtonID); end; var ASuccessfulDragging: Boolean; ACaptureWnd: HWND; AMsg: TMsg; begin if NeedHideOnNCMouseClick then HideAll; if not BarControlExists(Self) then Exit; ACloseButtonRectNC := CloseButtonRectNC; AActiveButtonID := GetButtonID(GetWindowCursorPos); if AActiveButtonID <> -1 then begin if not BarManager.HideFloatingBarsWhenInactive then SetActiveWindow(BarManager.Owner.Handle); UpdateButtonState(True); ASuccessfulDragging := False; ACaptureWnd := Handle; SetCapture(ACaptureWnd); try while GetCapture = ACaptureWnd do begin case Integer(GetMessage(AMsg, 0, 0, 0)) of -1: Break; 0: begin PostQuitMessage(AMsg.wParam); Break; end; end; with AMsg do case message of WM_LBUTTONUP: begin ASuccessfulDragging := GetButtonID(GetWindowCursorPos) = AActiveButtonID; Break; end; WM_MOUSEMOVE: if PtInRect(WindowRect, GetMouseCursorPos) then begin if cxPointIsEqual(FLastMousePos, cxInvalidPoint) then DoBarMouseEnter([], cxInvalidPoint, nil); FLastMousePos := GetMouseCursorPos; UpdateButtonState(True); end; else TranslateMessage(AMsg); DispatchMessage(AMsg); end; end; finally if GetCapture = ACaptureWnd then ReleaseCapture; UpdateButtonState(False); // CloseButtonState := msNone; if ASuccessfulDragging then DoClick; end; Exit; end; inherited; end; procedure TdxBarControl.WMNCPaint(var Message: TMessage); var ADC, ATempDC: HDC; ADrawBitmap: TBitmap; APrevClipRgn: TcxRegion; CR: TRect; begin if (ClientHeight = Height) and (ClientWidth = Width) then begin inherited; Exit; end; ADrawBitmap := nil; APrevClipRgn := nil; ADC := 0; try if BarManager.IsUncustomizable then begin if Message.WParam = 1 then APrevClipRgn := TcxRegion.Create(0, 0, Width, Height) else begin APrevClipRgn := TcxRegion.Create; CombineRgn(APrevClipRgn.Handle, APrevClipRgn.Handle, Message.WParam, RGN_OR); APrevClipRgn.Offset(-WindowRect.Left, -WindowRect.Top); APrevClipRgn.Combine(TcxRegion.Create(0, 0, Width, Height), roIntersect); end; CR := cxRectOffset(ClientRect, GetClientOffset); APrevClipRgn.Combine(TcxRegion.Create(CR), roSubtract); ADrawBitmap := cxCreateBitmap(Width, Height, pf32bit); ADC := ADrawBitmap.Canvas.Handle; SelectClipRgn(ADC, APrevClipRgn.Handle); end else ADC := GetWindowDC(Handle); inherited; DoNCPaint(ADC); if BarManager.IsUncustomizable then begin SelectClipRgn(ADC, APrevClipRgn.Handle); DrawDisablingHatch(ADC, Rect(0, 0, Width, Height)); ATempDC := GetWindowDC(Handle); try SelectClipRgn(ATempDC, APrevClipRgn.Handle); BitBlt(ATempDC, 0, 0, Width, Height, ADC, 0, 0, SRCCOPY); finally ReleaseDC(Handle, ATempDC); end; end; finally FreeAndNil(ADrawBitmap); FreeAndNil(APrevClipRgn); if not BarManager.IsUncustomizable and (ADC <> 0) then ReleaseDC(Handle, ADC); end; end; procedure TdxBarControl.WMSetCursor(var Message: TWMSetCursor); var P: TPoint; begin P := ScreenToClient(GetMouseCursorPos); if FIsResizing or CanResizeSelectedLink(P) then SetCursor(Screen.Cursors[crdxBarEditSizing]) else begin if not Moving and CanMoving then // --- SetCursorForMoving(PtInRect(GetSizeAllCursorBounds, P)); inherited; end; end; procedure TdxBarControl.WMSize(var Message: TWMSize); begin if IsDestroying then Exit; inherited; CalcLayout; end; procedure TdxBarControl.WMSizing(var Message: TMessage); var Size: TPoint; NCSize: Integer; begin inherited; if DockingStyle = dsNone then with Message, PRect(lParam)^ do begin case wParam of WMSZ_LEFT, WMSZ_RIGHT: begin NCSize := Bar.BarNCSizeX(dsNone); Size := GetSizeForWidth(DockingStyle, Right - Left - NCSize); if wParam = WMSZ_LEFT then Left := Right - Size.X - NCSize else Right := Left + Size.X + NCSize; Bottom := Top + Size.Y + Bar.BarNCSizeY(dsNone); end; WMSZ_TOP, WMSZ_BOTTOM: begin NCSize := Bar.BarNCSizeY(dsNone); Size := GetSizeForHeight(DockingStyle, Bottom - Top - NCSize); Right := Left + Size.X + Bar.BarNCSizeX(dsNone); if wParam = WMSZ_TOP then Top := Bottom - Size.Y - NCSize else Bottom := Top + Size.Y + NCSize; end; else PRect(lParam)^ := BoundsRect; Result := 1; end; // against windows' bug: if Top < -15 then OffsetRect(PRect(lParam)^, 0, -15 - Top); Result := 1; end; end; procedure TdxBarControl.WMWindowPosChanged(var Message: TWMWindowPosChanged); begin inherited; if (FBar = nil) or InternallyLocked or IsDestroying then Exit; FBar.ChangeDockingStyle(DockingStyle, DockControl); SavePos; with Message.WindowPos^ do begin if ((flags and SWP_NOSIZE = 0) or (flags and SWP_NOMOVE = 0)) and (FQuickPopup <> nil) then begin FQuickPopup.OwnerBounds := MarkScreenRect; FQuickPopup.ResizeShadow; SendMessage(FQuickPopup.Handle, WM_NCPAINT, 0, 0); end; if (flags and SWP_NOSIZE <> 0) and (flags and SWP_NOMOVE = 0) and (FHasSizeGrip <> FBar.HasSizeGrip) then RebuildBar; end; if IsPopup and (Message.WindowPos^.flags and SWP_HIDEWINDOW <> 0) and not IsDestroying then CloseUp; end; procedure TdxBarControl.WMWindowPosChanging(var Message: TWMWindowPosChanging); procedure CalcCoords(const AWindowPos: TWindowPos; var ALeft, ATop, AWidth, AHeight: Integer); begin if AWindowPos.flags and SWP_NOMOVE = 0 then begin ALeft := AWindowPos.x; ATop := AWindowPos.y; end else begin ALeft := Left; ATop := Top; end; if AWindowPos.flags and SWP_NOSIZE = 0 then begin AWidth := AWindowPos.cx; AHeight := AWindowPos.cy; end else begin AWidth := Width; AHeight := Height; end; end; var L, T, W, H: Integer; I: Integer; AIntersect: Boolean; P: TPoint; R, ABarRect, ARect: TRect; begin inherited; if DockingStyle <> dsNone then Exit; if (Message.WindowPos^.flags and SWP_NOMOVE = 0) or (Message.WindowPos^.flags and SWP_NOSIZE = 0) then begin CalcCoords(Message.WindowPos^, L, T, W, H); ABarRect := Bounds(L, T, W, H); AIntersect := False; for I := 0 to Screen.MonitorCount - 1 do begin // begin BoundsRect P := Point(Screen.Monitors[I].Left, Screen.Monitors[I].Top); R := GetWorkArea(P); // end BoundsRect if IntersectRect(ARect, R, ABarRect) then begin AIntersect := True; Break; end; end; if not AIntersect then begin R := GetWorkArea(GetMouseCursorPos); with Message.WindowPos^ do begin with R do begin if L + W <= Left then begin x := Left; y := T; flags := flags and not SWP_NOMOVE; end; if T + H <= Top then begin x := L; y := Top; flags := flags and not SWP_NOMOVE; end; if L >= Right then begin x := Right - W; y := T; flags := flags and not SWP_NOMOVE; end; if T >= Bottom then begin x := L; y := Bottom - H; flags := flags and not SWP_NOMOVE; end; end; end; end; end; end; procedure TdxBarControl.CMFontChanged(var Message: TMessage); begin UpdateCanvasFont; if not HandleAllocated then Exit; CalcDrawingConsts; if not InternallyLocked then begin SetMouseSelectedItem(nil); RepaintBar; end; inherited; end; procedure TdxBarControl.CreateParams(var Params: TCreateParams); begin inherited CreateParams(Params); with Params do begin Style := WS_CLIPCHILDREN or WS_CLIPSIBLINGS; WindowClass.Style := CS_DBLCLKS or CS_HREDRAW or CS_VREDRAW; ExStyle := 0;//WS_EX_TOOLWINDOW; if DockingStyle = dsNone then begin Style := Style or WS_POPUPWINDOW or WS_SIZEBOX; // WndParent := BarManager.MainForm.Handle; WndParent := BarManager.Owner.Handle; end else begin Style := Style or WS_CHILD; WndParent := FDockControl.Handle; end; end; end; procedure TdxBarControl.CreateWnd; begin if FMoving and InternallyLocked then if FDockingStyle = dsNone then WindowHandle := FFloatingHandle else WindowHandle := FDockedHandle else inherited; Text := GetCaption; SendMessage(Handle, WM_NCACTIVATE, Longint(True), 0); // don't remove (AV in ntdll.dll) end; procedure TdxBarControl.Paint; var APrevRegion: TcxRegion; begin APrevRegion := Canvas.GetClipRegion; try inherited; DoPaint; if BarManager.IsUncustomizable then begin Canvas.SetClipRegion(APrevRegion, roSet, False); DrawDisablingHatch(Canvas.Handle, ClientRect); end; finally APrevRegion.Free; end; end; procedure TdxBarControl.Resize; begin inherited; UpdateCaptionButtons(nil); end; procedure TdxBarControl.BeginInternal; begin Inc(FInternalLockCount); end; procedure TdxBarControl.EndInternal; begin if FInternalLockCount > 0 then Dec(FInternalLockCount); end; procedure TdxBarControl.LayoutChanged; begin if BarManager.CanShowRecentItems and (DockingStyle <> dsNone) then PostMessage(Handle, WM_REPAINTBAR, 0, 0); end; procedure TdxBarControl.CalcControlsPositions; begin inherited CalcControlsPositions; CalcItemRects(GetPaintType); end; procedure TdxBarControl.CalcRowItemRects; var FirstInRow, X, Y, ARowHeight, ABeginGroupSize, ASize, VerSize, AWidth, AHeight: Integer; AMultiLine, AVertical, ItemControlAlignApplied: Boolean; AItemLink: TdxBarItemLink; procedure InitValues; begin X := 0; Y := 0; VerSize := 0; AItemLink := nil; AMultiLine := MultiLine; AVertical := Vertical; if AMultiLine then begin if AVertical then begin ASize := ClientHeight; VerSize := ClientWidth; end else ASize := ClientWidth; if MarkExists and (DockingStyle <> dsNone) then Dec(ASize, Painter.MarkSizeX); ARowHeight := 0; FirstInRow := 0; end else if AVertical then begin ASize := ClientHeight - Byte(MarkExists) * Painter.MarkSizeX - Byte(MDIButtonsOnBar) * GetMDIHeight; ARowHeight := ClientWidth; end else begin ASize := ClientWidth - Byte(MarkExists) * Painter.MarkSizeX - Byte(MDIButtonsOnBar) * GetMDIWidth; ARowHeight := ClientHeight; end; end; procedure InitItemControlValues; begin with AItemLink.Control do begin FLastInRow := False; if AVertical then begin AWidth := Height; AHeight := Width; end else begin AWidth := Width; AHeight := Height; end; end; if AItemLink.BeginGroup and (X > 0) then ABeginGroupSize := BeginGroupSize else ABeginGroupSize := 0; end; function ItemControlBreaksRow: Boolean; begin Result := ((X > 0) or not AMultiLine and CanHideAllItemsInSingleLine) and (X + ABeginGroupSize + AWidth > ASize) or AMultiLine and AItemLink.Control.FBreakingRow; end; procedure ArrangeControlsOnRow(const LastInRow: Integer); var I: Integer; begin for I := FirstInRow to LastInRow do with ItemLinks.VisibleItems[I], ItemRect do begin if AVertical then ItemRect := cxRectOffset(ItemRect, -(ARowHeight - (Right - Left)) div 2, 0) else ItemRect := cxRectOffset(ItemRect, 0, (ARowHeight - (Bottom - Top)) div 2); RowHeight := ARowHeight; end; FirstInRow := LastInRow + 1; end; function GetItemControlRect: TRect; procedure ApplyAlign; procedure CheckSize; var AMDISize: Integer; begin if AMultiLine and (AItemLink.Control.Align <> iaLeft) and MDIButtonsOnBar then begin if AVertical then AMDISize := GetMDIHeight else AMDISize := GetMDIWidth; if Result.Right + AMDISize <= ASize then Dec(ASize, AMDISize); end; end; begin CheckSize; ItemControlAlignApplied := True; case AItemLink.Control.Align of iaLeft: ItemControlAlignApplied := False; iaCenter: if AVertical then OffsetRect(Result, 0, (ASize - Result.Bottom) div 2) else OffsetRect(Result, (ASize - Result.Right) div 2, 0); iaRight: if AVertical then OffsetRect(Result, 0, ASize - Result.Bottom) else OffsetRect(Result, ASize - Result.Right, 0); iaClient: with Result do if AVertical then begin Bottom := ASize; if Bottom - Top < AItemLink.Control.MinWidth then Bottom := Top + AItemLink.Control.MinWidth; end else begin Right := ASize; if Right - Left < AItemLink.Control.MinWidth then Right := Left + AItemLink.Control.MinWidth; end; end; end; begin if AMultiLine then if AVertical then Result := Bounds(VerSize - Y - AHeight, X + ABeginGroupSize, AHeight, AWidth) else Result := Bounds(X + ABeginGroupSize, Y, AWidth, AHeight) else case DockingStyle of dsTop, dsBottom: Result := Bounds(X + ABeginGroupSize, (ARowHeight - AHeight) div 2, AWidth, AHeight); dsLeft, dsRight: Result := Bounds((ARowHeight - AHeight) div 2, X + ABeginGroupSize, AHeight, AWidth); end; ApplyAlign; end; procedure CalcX(ALinkIndex: Integer); begin if ItemControlAlignApplied then begin X := ASize; if ALinkIndex < ItemLinks.VisibleItemCount - 1 then FTruncated := True; end else Inc(X, ABeginGroupSize + AWidth); end; var I: Integer; begin InitValues; for I := 0 to ItemLinks.VisibleItemCount - 1 do begin AItemLink := ItemLinks.VisibleItems[I]; if AItemLink.Control = nil then AItemLink.CreateControl; InitItemControlValues; if ItemControlBreaksRow then if AMultiLine then begin ItemLinks.VisibleItems[I - 1].Control.FLastInRow := True; ArrangeControlsOnRow(I - 1); Inc(Y, ARowHeight + ABeginGroupSize); X := 0; ABeginGroupSize := 0; ARowHeight := 0; end else begin if I = 0 then AItemLink := nil else AItemLink := ItemLinks.VisibleItems[I - 1]; Break; end; AItemLink.ItemRect := GetItemControlRect; AItemLink.RowHeight := ARowHeight; CalcX(I); if ARowHeight < AHeight then ARowHeight := AHeight; end; if AItemLink <> nil then AItemLink.Control.FLastInRow := True; if AMultiLine then ArrangeControlsOnRow(ItemLinks.VisibleItemCount - 1); end; procedure TdxBarControl.CalcDrawingConsts; begin inherited CalcDrawingConsts; FMDIButtonWidth := GetSystemMetrics(SM_CXMENUSIZE) - 2; FMDIButtonHeight := GetSystemMetrics(SM_CYMENUSIZE) - 2 * 2; end; procedure TdxBarControl.CalcDragOverParameters(const ACursorPos: TPoint; out ADragOverItemLink: TdxBarItemLink; out AIsBeginGroup, AIsFirstPart, AIsVerticalDirection: Boolean); var I: Integer; AControl: TdxBarItemControl; AItemRect: TRect; AVertical: Boolean; begin inherited CalcDragOverParameters(ACursorPos, ADragOverItemLink, AIsBeginGroup, AIsFirstPart, AIsVerticalDirection); if (ADragOverItemLink = nil) and PtInRect(ClientRect, ACursorPos) then begin for I := 0 to ItemLinks.VisibleItemCount - 1 do begin AControl := ItemLinks.VisibleItems[I].Control; if AControl.CanCustomize and AControl.FLastInRow then begin AItemRect := GetItemRect(AControl); AVertical := Vertical; if AVertical and (AItemRect.Left <= ACursorPos.X) and (ACursorPos.X < AItemRect.Right) or not AVertical and (AItemRect.Top <= ACursorPos.Y) and (ACursorPos.Y < AItemRect.Bottom) then begin if AVertical and (ACursorPos.Y < AItemRect.Top) or not AVertical and (ACursorPos.X < AItemRect.Left) then begin AIsFirstPart := True; if AControl.Align in [iaCenter, iaRight] then ADragOverItemLink := AControl.ItemLink else if ItemLinks.VisibleItemCount > 1 then // ??? ADragOverItemLink := ItemLinks.VisibleItems[1]; // ??? end else ADragOverItemLink := AControl.ItemLink; Break; end; end; end; end; end; function TdxBarControl.CanAlignControl(AControl: TdxBarItemControl): Boolean; begin with AControl.ItemLink do Result := Bar.UseRestSpace and (CanVisibleIndex = Owner.CanVisibleItemCount - 1); end; function TdxBarControl.CanCallInheritedNCCalcSize: Boolean; // obsolete begin Result := (DockingStyle <> dsNone) or not Flat; end; function TdxBarControl.CanCustomizing: Boolean; begin Result := inherited CanCustomizing or FBar.AllowCustomizing; end; function TdxBarControl.CanHideAllItemsInSingleLine: Boolean; begin Result := False; end; function TdxBarControl.CanMoving: Boolean; begin Result := Bar.CanMoving; end; procedure TdxBarControl.CaptionButtonClick(AIndex: Integer); var AButton: TdxBarCaptionButton; begin if IsPopup then AButton := PopupBar.CaptionButtons[AIndex] else AButton := CaptionButtons[AIndex]; if not NeedHideOnNCMouseClick then CloseUp; AButton.Click; end; procedure TdxBarControl.CheckMarkState(const P: TPoint); begin if IsMarkAccessible and MouseOnMark(P) then if MarkState = msPressed then MarkState := msSelected else MarkState := msPressed; end; function TdxBarControl.CloseButtonRect: TRect; var ASize: TSize; RW, RH: Integer; begin if HasCloseButton then begin Result := GetCaptionRect; with Result do Left := Right - Painter.BarCaptionSize; ASize := Painter.BarCloseButtonSize; RW := Result.Right - Result.Left; if ASize.cx < RW then begin Result.Left := Result.Left + (RW div 2) - (ASize.cx div 2); Result.Right := Result.Left + ASize.cx; end; RH := Result.Bottom - Result.Top; if ASize.cy < RH then begin Result.Top := Result.Top + (RH div 2) - (ASize.cy div 2); Result.Bottom := Result.Top + ASize.cy; end; end else Result := cxEmptyRect; end; function TdxBarControl.CloseButtonRectNC: TRect; begin Result := CloseButtonRect; MapWindowRect(Handle, 0, Result); OffsetRect(Result, -WindowRect.Left, -WindowRect.Top); end; function TdxBarControl.CheckLockUpdate: Boolean; begin Result := inherited CheckLockUpdate; if Result and (Bar <> nil) then Bar.DoChanged; end; procedure TdxBarControl.CustomizePrepare(APoint: TPoint; ASecondClick: Boolean); begin if ASecondClick and CanResizeSelectedLink(APoint) then begin FIsResizing := True; SelectedControlAtDesign.BeginResize(APoint); SetCapture(Handle); end else inherited; end; procedure TdxBarControl.DoBarGetFocus(ASelectedItem: TdxBarItemControl); var AControl: TWinControl; ItemLink: TdxBarItemLink; begin AControl := FindControl(WindowFromPointEx(GetMouseCursorPos)); if (AControl is TCustomdxBarControl) and (AControl <> Self) then TCustomdxBarControl(AControl).MouseLeave; dxBar.SendCancelMode; FBeforeBarGetFocusFocusedWnd := GetFocus; if not IsCustomizing and not (IsPopup and ParentBar.Focused) and (GetParentPopupWindow(Self, True) = nil) then dxSetZOrder(MasterForm.Handle, HWND_TOP, True); if ASelectedItem = nil then begin ItemLink := nil; repeat ItemLink := ItemLinks.Next(ItemLink); until (ItemLink = nil) or (ItemLink.Control <> nil) and not (ItemLink.Control is TSystemMenuSubItemControl); // !!! if ItemLink <> nil then ASelectedItem := ItemLink.Control; end; inherited DoBarGetFocus(ASelectedItem); end; procedure TdxBarControl.DoBarLostFocus; var P: TPoint; AControl: TWinControl; begin inherited DoBarLostFocus; P := GetMouseCursorPos; AControl := FindControl(WindowFromPointEx(P)); if AControl is TCustomdxBarControl then with TCustomdxBarControl(AControl) do begin Windows.ScreenToClient(Handle, P); FLastMousePos := cxInvalidPoint; PostMessage(Handle, WM_MOUSEMOVE, 0, MakeLParam(P.X, P.Y)); end; if Application.Active and IsFormActive(ParentForm) and // -> bug with toolbars' hiding (without Application.Active) IsWindowVisible(FBeforeBarGetFocusFocusedWnd) then Windows.SetFocus(FBeforeBarGetFocusFocusedWnd); end; procedure TdxBarControl.DoBarMouseDown(Button: TMouseButton; Shift: TShiftState; const APoint: TPoint; AItemControl: TdxBarItemControl; APointInClientRect: Boolean); function CheckMDIButton(AButton: TdxBarMDIButton): Boolean; begin Result := PtInRect(RectMDI(AButton), APoint); if Result then begin FIsMDIButtonPressed := True; FIsMouseOverMDIButton := True; FPressedMDIButton := AButton; FSelectedMDIButton := FPressedMDIButton; DrawMDIButtons([AButton]); SetCapture(Handle); end end; var AButton: TdxBarMDIButton; R: TRect; begin case Button of mbLeft: begin // !!! if not BarManager.HideFloatingBarsWhenInactive and (not IsInternal and (DockingStyle = dsNone)) then SetActiveWindow(BarManager.Owner.Handle); end; mbRight: ReleaseCapture; end; inherited; if not BarControlExists(Self) then Exit; case Button of mbLeft: begin if MDIButtonsOnBar and not BarManager.IsCustomizing then if RealMDIButtonsOnBar then for AButton := Low(TdxBarMDIButton) to High(TdxBarMDIButton) do if MDIButtonEnabled(AButton, MF_DISABLED or MF_GRAYED) and CheckMDIButton(AButton) then Exit else else if CheckMDIButton(mdibClose) then Exit; if FHitTest = HTCAPTION then begin R := WindowRect; RX.X := GetMouseCursorPos.X - R.Left; RY.X := GetMouseCursorPos.Y - R.Top; RX.Y := R.Right - R.Left; RY.Y := R.Bottom - R.Top; FBar.Bars.Moving(Self); end else begin CheckMarkState(APoint); if not IsCustomizing and not APointInClientRect then begin SendMessage(Handle, WM_NCLBUTTONDOWN, FHitTest, LPARAM(PointToSmallPoint(GetMouseCursorPos))); end; end; end; end; end; procedure TdxBarControl.DoBarMouseLeave; begin inherited; CaptionButtons.UpdateButtonStates(cxInvalidPoint); if not IsActive then begin //#DG inherited; CloseButtonState := msNone; // MDI if MDIButtonsOnBar then begin FIsMouseOverMDIButton := False; RepaintMDIButtons; end; end else if SelectedControl is TdxBarButtonControl then SelectedControl.Repaint; end; procedure TdxBarControl.DoBarMouseMove(Shift: TShiftState; const APoint: TPoint; AItemControl: TdxBarItemControl); var PrevIsMouseOverMDIButton: Boolean; PrevSelectedMDIButton: TdxBarMDIButton; AButton: TdxBarMDIButton; AButtons: TdxBarMDIButtons; AChangeMark: Boolean; begin if FIsMDIButtonPressed then begin PrevIsMouseOverMDIButton := FIsMouseOverMDIButton; FIsMouseOverMDIButton := PtInRect(RectMDI(FPressedMDIButton), APoint); if FIsMouseOverMDIButton <> PrevIsMouseOverMDIButton then DrawMDIButtons([FPressedMDIButton]); end else begin // check MDI if MDIButtonsOnBar then begin PrevIsMouseOverMDIButton := FIsMouseOverMDIButton; PrevSelectedMDIButton := FSelectedMDIButton; FIsMouseOverMDIButton := False; if not RealMDIButtonsOnBar then begin if MDIButtonEnabled(mdibClose, MF_GRAYED) and PtInRect(RectMDI(mdibClose), APoint) then begin FIsMouseOverMDIButton := True; FSelectedMDIButton := mdibClose; end end else begin for AButton := Low(TdxBarMDIButton) to High(TdxBarMDIButton) do if MDIButtonEnabled(AButton, MF_GRAYED) and PtInRect(RectMDI(AButton), APoint) then begin FIsMouseOverMDIButton := True; FSelectedMDIButton := AButton; Break; end; end; if (FIsMouseOverMDIButton <> PrevIsMouseOverMDIButton) or (FSelectedMDIButton <> PrevSelectedMDIButton) then begin AButtons := [PrevSelectedMDIButton]; if FSelectedMDIButton <> PrevSelectedMDIButton then AButtons := AButtons + [FSelectedMDIButton]; DrawMDIButtons(AButtons); end; end; // if IsCustomizing and FIsResizing and (GetCapture = Handle) then if FIsResizing then SelectedControlAtDesign.Resizing(APoint); //#DG //#DG SelectedItem.Resizing(P); AChangeMark := False; if not NotHandleMouseMove then begin CaptionButtons.UpdateButtonStates(cxPointOffset(APoint, NCOffset)); if ActiveBarControl = nil then begin if Painter.BarAllowQuickCustomizing and MarkExists and (MarkState <> msPressed) then if MouseOnMark(APoint) then MarkState := msSelected else AChangeMark := True; if HasCloseButton and Painter.BarAllowHotTrack then if PtInRect(CloseButtonRect, APoint) then CloseButtonState := msSelected else CloseButtonState := msNone; end; end; inherited; if AChangeMark then MarkState := msNone; end; end; procedure TdxBarControl.DoHideAll; var ALinkSelf: TcxObjectLink; AWasPopup: Boolean; begin ALinkSelf := cxAddObjectLink(Self); try AWasPopup := IsPopup; BarLostFocus; inherited; if (ALinkSelf.Ref <> nil) and AWasPopup then begin if LeftButtonPressed and PtInRect(IgnoreClickAreaWhenHidePopup, GetMouseCursorPos) then ParentBar.FIgnoreMouseClick := True; CloseUp; end; finally cxRemoveObjectLink(ALinkSelf); end; end; procedure TdxBarControl.DoRepaintBar(ARecreateControls: Boolean); var P: TPoint; begin inherited DoRepaintBar(ARecreateControls); if DockingStyle = dsNone then begin if HandleAllocated then begin P := GetSizeForWidth(DockingStyle, ClientWidth); ClientWidth := P.X; ClientHeight := P.Y; end; CalcLayout; end else FDockControl.UpdateDock; //Repaint; Invalidate; if BarManager.IsUncustomizable then SendMessage(Handle, WM_NCPAINT, 1, 0) else if IsTransparent then SendMessage(Handle, WM_NCPAINT, 0, 0); end; procedure TdxBarControl.DoSetIsActive(AValue: Boolean); begin if not AValue then begin if IsCustomizing and (SelectedControl <> nil) then SetMouseSelectedItem(nil); if IsActive and (SelectedControl is TdxBarButtonControl) and TdxBarButtonControl(SelectedControl).DroppedDown then SelectedControl.ControlInactivate(True); if IsDowned then begin IsDowned := False; if not IsCustomizing then {HideAll;//}BarLostFocus; end; end; inherited; BarLostFocus; // !!! end; procedure TdxBarControl.FocusItemControl(AItemControl: TdxBarItemControl); var AProcessedByItemControl: Boolean; ALinkSelf: TcxObjectLink; begin if (AItemControl <> nil) and AItemControl.Enabled and AItemControl.HotPartWantMouse then begin AProcessedByItemControl := False; ALinkSelf := cxAddObjectLink(Self); try if IsActive and not ((bboNeedsFocusWhenActive in BehaviorOptions) and not IsFocused) then AItemControl.ControlGetFocus(AItemControl = SelectedControl, AProcessedByItemControl) else BarGetFocus(AItemControl); if (ALinkSelf.Ref = nil) or AProcessedByItemControl then Exit; finally cxRemoveObjectLink(ALinkSelf); end; if IsActive and not AItemControl.HasWindow then IsDowned := True; if (SelectedControl <> nil) and SelectedControl.NeedCaptureMouse then begin FClickedControl := AItemControl; SetCapture(Handle); AItemControl.Repaint; end; end else IsActive := False; inherited; end; function TdxBarControl.GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; begin Result := TdxBarControlAccessibilityHelper; end; function TdxBarControl.GetAlphaBlendValue: Byte; begin if {not FMovingChanging and }(DockingStyle = dsNone) then Result := 200 else Result := 255; end; function TdxBarControl.GetBackgroundBitmap: TBitmap; begin Result := Bar.BackgroundBitmap; end; function TdxBarControl.GetBeginGroupSize: Integer; begin Result := Painter.BarBeginGroupSize; end; function TdxBarControl.GetCol: Integer; var I, J: Integer; begin Result := 0; if (FBar = nil) or (FBar.Bars = nil) or (DockingStyle = dsNone) or (FDockControl = nil) then Exit; with FDockControl do for I := 0 to FRowList.Count - 1 do for J := 0 to Rows[I].ColCount - 1 do if Rows[I].Cols[J].BarControl = Self then begin Result := J; Exit; end; end; procedure TdxBarControl.WndProc(var Message: TMessage); var AStyle: TdxBarDockingStyle; ADockControl: TdxDockControl; begin FCurrentMessage := Message; //#DG if Message.Msg = WM_SETFOCUS then Exit; if (FIsMDIButtonPressed or FIsMouseOverMDIButton) and (Message.Msg = WM_CANCELMODE) then begin ReleaseCapture; FIsMDIButtonPressed := False; FIsMouseOverMDIButton := False; RepaintMDIButtons; end; if (Message.Msg = WM_LBUTTONDBLCLK) and (FHitTest = HTCAPTION) then begin if not BarManager.Designing then with Bar do begin ADockControl := nil; if DockingStyle = dsNone then if DockedDockingStyle <> dsNone then begin AStyle := DockedDockingStyle; ADockControl := DockedDockControl; if ADockControl = nil then ADockControl := Bars.FDockControls[AStyle]; end else begin AStyle := dsTop; ADockControl := Bars.FDockControls[dsTop]; end else AStyle := dsNone; if BarManager.DoDocking(Bar, AStyle, ADockControl) then begin Visible := False; if DockingStyle = dsNone then begin ChangeDockingStyle(AStyle, ADockControl); if DockedDockingStyle = dsNone then begin OneOnRow := True; Row := ADockControl.RowCount; end; end else DockingStyle := dsNone; Visible := True; end; end; Exit; end; inherited; end; function TdxBarControl.GetDockCol: TdxDockCol; var I, J: Integer; begin Result := nil; if (FBar = nil) or (FBar.Bars = nil) or (DockingStyle = dsNone) or (FDockControl = nil) then Exit; with FDockControl do for I := 0 to RowCount - 1 do for J := 0 to Rows[I].ColCount - 1 do if Rows[I].Cols[J].BarControl = Self then begin Result := Rows[I].Cols[J]; Exit; end; end; function TdxBarControl.GetIsMainMenu: Boolean; begin Result := (Bar <> nil) and Bar.IsMainMenu; end; function TdxBarControl.GetMarkAccessibilityHelperClass: TdxBarAccessibilityHelperClass; begin Result := TdxBarControlMarkAccessibilityHelper; end; function TdxBarControl.GetMarkDrawState: TdxBarMarkState; begin if MarkIAccessibilityHelper.IsSelected then Result := msSelected else Result := inherited GetMarkDrawState; end; function TdxBarControl.GetMoreButtonsHint: string; begin Result := cxGetResourceString(@dxSBAR_MOREBUTTONS); end; function TdxBarControl.GetMultiLine: Boolean; begin Result := (DockingStyle = dsNone) or FBar.MultiLine; end; function TdxBarControl.GetQuickControlClass: TdxBarControlClass; begin Result := TdxBarQuickControl; end; function TdxBarControl.GetRow: Integer; var I, J: Integer; begin Result := 0; if (FBar = nil) or (FBar.Bars = nil) or (DockingStyle = dsNone) or (FDockControl = nil) then Exit; with FDockControl do for I := 0 to RowCount - 1 do for J := 0 to Rows[I].ColCount - 1 do if Rows[I].Cols[J].BarControl = Self then begin Result := I; Exit; end; end; function TdxBarControl.GetViewInfoClass: TCustomdxBarControlViewInfoClass; begin Result := TdxBarControlViewInfo; end; function TdxBarControl.GetMasterForm: TCustomForm; begin if DockControl <> nil then Result := DockControl.MasterForm else Result := BarManager.MasterForm; end; function TdxBarControl.GetParentForm: TCustomForm; begin if DockControl <> nil then Result := DockControl.ParentForm else Result := BarManager.ParentForm; end; function TdxBarControl.GetSelectableObject: TPersistent; begin Result := Bar; end; function TdxBarControl.AllowQuickCustomizing: Boolean; begin Result := Bar.AllowQuickCustomizing; end; procedure TdxBarControl.HandleQuickAccessSubItemPopup(Sender: TObject); begin BarDesignController.ClearOwnedItems(TdxBarSubItem(Sender).ItemLinks); InitAddRemoveSubItemPopup(TdxBarSubItem(Sender).ItemLinks); end; procedure TdxBarControl.InitQuickControl(AQuickControlItemLinks: TdxBarItemLinks); var I: Integer; AItemLink: TdxBarItemLink; begin for I := 0 to ItemLinks.CanVisibleItemCount - 1 do begin AItemLink := ItemLinks.CanVisibleItems[I]; if (AItemLink.VisibleIndex = -1) or (AItemLink.Control <> nil) and IsRectEmpty(AItemLink.ItemRect) then begin with AQuickControlItemLinks.Add do begin Assign(AItemLink); FOriginalItemLink := AItemLink; end; end; end; if AllowQuickCustomizing then InitQuickCustomizeItemLinks(AQuickControlItemLinks); end; procedure TdxBarControl.InitQuickCustomizeItemLinks(AQuickControlItemLinks: TdxBarItemLinks); var AItemLink: TdxBarItemLink; AAddRemoveSubItem: TdxBarSubItem; begin AItemLink := BarDesignController.AddInternalItem(AQuickControlItemLinks, TdxBarQuickAccessItem, cxGetResourceString(@dxSBAR_ADDREMOVEBUTTONS)); AItemLink.BeginGroup := True; AAddRemoveSubItem := TdxBarSubItem(AItemLink.Item); // AAddRemoveSubItem.Enabled := AllowQuickCustomizing; AAddRemoveSubItem.OnPopup := HandleQuickAccessSubItemPopup; end; procedure TdxBarControl.InitAddRemoveSubItemPopup(AItemLinks: TdxBarItemLinks); var I: Integer; AItemLink: TdxBarItemLink; AllowReset: Boolean; AQuickCustItem: TdxBarQuickCustItem; begin AQuickCustItem := TdxBarQuickCustItem.Create(BarManager.Owner);//#DG BarDesignController.AddInternalItem(AQuickCustItem); for I := 0 to ItemLinks.AvailableItemCount - 1 do begin AItemLink := ItemLinks.AvailableItems[I]; if (AItemLink.Control = nil) or AItemLink.Control.CanCustomize then with AItemLinks.Add do begin Item := AQuickCustItem; Data := {$IFNDEF CLR}Integer{$ENDIF}(AItemLink); end; end; // add reset button AllowReset := BarManager.CanReset and Bar.CanReset; if AllowReset then BarDesignController.AddInternalItem(AItemLinks, TdxBarQuickCustExtButton, cxGetResourceString(@dxSBAR_RESETTOOLBAR), ResetToolbarClick).BeginGroup := True; // add customize button BarDesignController.AddCustomizeItem(AItemLinks, TdxBarQuickCustExtButton, not AllowReset); end; procedure TdxBarControl.ResetToolbarClick(Sender: TObject); begin Bar.ResetWithConfirmation; end; function TdxBarControl.GetMinWidth(AStyle: TdxBarDockingStyle): Integer; var I, AWidth: Integer; begin if (AStyle in [dsLeft, dsRight]) or MultiLine then begin if ItemLinks.CanVisibleItemCount = 0 then Result := Painter.GetButtonWidth(BarManager.GlyphSize, TextSize) else begin Result := 0; for I := 0 to ItemLinks.CanVisibleItemCount - 1 do begin AWidth := ItemLinks.CanVisibleItems[I].Control.Width; if Result < AWidth then Result := AWidth; end; end; if MDIButtonsOnBar and (Result < GetMDIWidth) then Result := GetMDIWidth; end else begin if ItemLinks.CanVisibleItemCount = 0 then Result := Painter.GetButtonWidth(BarManager.GlyphSize, TextSize) else begin ItemLinks.RecentItemCount := 1; Result := ItemLinks.VisibleItems[0].Control.Width; ItemLinks.RestoreRecentItemCount; end; if MDIButtonsOnBar then Inc(Result, GetMDIWidth); end; if Horizontal and MarkExists then Inc(Result, Painter.MarkSizeX); end; function TdxBarControl.GetMinHeight(AStyle: TdxBarDockingStyle): Integer; var I, AHeight: Integer; begin if (AStyle in [dsTop, dsBottom]) or MultiLine then begin if ItemLinks.CanVisibleItemCount = 0 then Result := Painter.GetButtonHeight(BarManager.GlyphSize, TextSize) else begin Result := 0; for I := 0 to ItemLinks.CanVisibleItemCount - 1 do begin AHeight := ItemLinks.CanVisibleItems[I].Control.Height; if Result < AHeight then Result := AHeight; end; end; if MDIButtonsOnBar and (Result < GetMDIHeight) then Result := GetMDIHeight; end else begin if ItemLinks.CanVisibleItemCount = 0 then Result := Painter.GetButtonHeight(BarManager.GlyphSize, TextSize) else begin ItemLinks.RecentItemCount := 1; Result := ItemLinks.VisibleItems[0].Control.Height; ItemLinks.RestoreRecentItemCount; end; if MDIButtonsOnBar then Inc(Result, GetMDIHeight); end; if Vertical and MarkExists then Inc(Result, Painter.MarkSizeX); end; function TdxBarControl.GetMaxWidth(AStyle: TdxBarDockingStyle): Integer; var AWidth, I: Integer; AItemLink: TdxBarItemLink; begin Result := GetMinWidth(AStyle); AWidth := 0; if (AStyle in [dsTop, dsBottom]) or MultiLine then begin ItemLinks.RecentItemCount := -1; for I := 0 to ItemLinks.VisibleItemCount - 1 do begin AItemLink := ItemLinks.VisibleItems[I]; if AItemLink.BeginGroup then Inc(AWidth, BeginGroupSize); Inc(AWidth, AItemLink.Control.Width); end; ItemLinks.RestoreRecentItemCount; if MDIButtonsOnBar then Inc(AWidth, GetMDIWidth); if Horizontal and MarkExists then Inc(AWidth, Painter.MarkSizeX); end else begin for I := 0 to ItemLinks.CanVisibleItemCount - 1 do begin AItemLink := ItemLinks.CanVisibleItems[I]; if AWidth < AItemLink.Control.Width then AWidth := AItemLink.Control.Width; end; if MDIButtonsOnBar and (AWidth < GetMDIWidth) then AWidth := GetMDIWidth; end; if Result < AWidth then Result := AWidth; end; function TdxBarControl.GetMaxHeight(AStyle: TdxBarDockingStyle): Integer; var AHeight, I: Integer; AItemLink: TdxBarItemLink; begin Result := GetMinHeight(AStyle); AHeight := 0; if (AStyle in [dsLeft, dsRight]) or MultiLine then begin ItemLinks.RecentItemCount := -1; for I := 0 to ItemLinks.VisibleItemCount - 1 do begin AItemLink := ItemLinks.VisibleItems[I]; if AItemLink.BeginGroup then Inc(AHeight, BeginGroupSize); Inc(AHeight, AItemLink.Control.Height); end; ItemLinks.RestoreRecentItemCount; if MDIButtonsOnBar then Inc(AHeight, GetMDIHeight); if Vertical and MarkExists then Inc(AHeight, Painter.MarkSizeX); end else begin for I := 0 to ItemLinks.CanVisibleItemCount - 1 do begin AItemLink := ItemLinks.CanVisibleItems[I]; if AHeight < AItemLink.Control.Height then AHeight := AItemLink.Control.Height; end; if MDIButtonsOnBar and (AHeight < GetMDIHeight) then AHeight := GetMDIHeight; end; if Result < AHeight then Result := AHeight; end; procedure TdxBarControl.GetMultiLineBarSize(AStyle: TdxBarDockingStyle; ASize: Integer; var Result: TPoint); var ABeginGroupSize, ACount, ACurRowHeight, ACurX, ACurY, ALastItemLinkWithBeginGroupCurX, ALastItemLinkWithBeginGroupCurRowHeight, AMaxSize, I, H, W: Integer; AItemLink, ALastItemLinkWithBeginGroup: TdxBarItemLink; ABreakingRow, AEntireRow, AVertical: Boolean; begin AVertical := Vertical; if AVertical and (ASize < Result.Y) then ASize := Result.Y else if not AVertical and (ASize < Result.X) then ASize := Result.X; if (AStyle <> dsNone) and MarkExists then Dec(ASize, Painter.MarkSizeX); ACurX := 0; ACurY := 0; ACurRowHeight := 0; AMaxSize := 0; ALastItemLinkWithBeginGroup := nil; ALastItemLinkWithBeginGroupCurX := 0; ALastItemLinkWithBeginGroupCurRowHeight := 0; ABreakingRow := False; AEntireRow := True; ACount := ItemLinks.VisibleItemCount; I := 0; while I < ACount do begin AItemLink := ItemLinks.VisibleItems[I]; if AItemLink.BeginGroup and (ACurX > 0) then begin ABeginGroupSize := BeginGroupSize; ALastItemLinkWithBeginGroup := AItemLink; ALastItemLinkWithBeginGroupCurX := ACurX; ALastItemLinkWithBeginGroupCurRowHeight := ACurRowHeight; end else ABeginGroupSize := 0; with AItemLink.Control do if AVertical then begin W := Height; H := Width; end else begin W := Width; H := Height; end; if (ACurX > 0) and (ACurX + ABeginGroupSize + W > ASize) or ABreakingRow or (ABeginGroupSize > 0) and not AEntireRow then begin AEntireRow := True; AItemLink.Control.FBreakingRow := True; if ALastItemLinkWithBeginGroup = nil then AEntireRow := False else if ABreakingRow then begin ALastItemLinkWithBeginGroup := nil; ABreakingRow := False; end else begin I := ALastItemLinkWithBeginGroup.VisibleIndex; ACurX := ALastItemLinkWithBeginGroupCurX; ACurRowHeight := ALastItemLinkWithBeginGroupCurRowHeight; ABreakingRow := True; Continue; end; Inc(ACurY, ABeginGroupSize + ACurRowHeight); ACurRowHeight := 0; if AMaxSize < ACurX then AMaxSize := ACurX; ACurX := W; end else begin AItemLink.Control.FBreakingRow := False; Inc(ACurX, ABeginGroupSize + W); end; if ACurRowHeight < H then ACurRowHeight := H; Inc(I); end; if ItemLinks.VisibleItemCount > 0 then if AVertical then Result.X := ACurY + ACurRowHeight else Result.Y := ACurY + ACurRowHeight; if MDIButtonsOnBar then begin if AVertical then I := GetMDIHeight else I := GetMDIWidth; if ACurX + I <= ASize then Inc(ACurX, I) else if AVertical then Inc(Result.X, GetMDIWidth) else Inc(Result.Y, GetMDIHeight); end; if AMaxSize < ACurX then AMaxSize := ACurX; if AVertical then if Result.Y < AMaxSize then Result.Y := AMaxSize else else if Result.X < AMaxSize then Result.X := AMaxSize; CalcLayout; // because of a FBreakingRow end; function TdxBarControl.GetSizeAllCursorBounds: TRect; begin if (DockingStyle = dsNone) or (Bar.BorderStyle = bbsNone) then SetRectEmpty(Result) else if Horizontal then Result := Rect(-100, -100, 0, 100) else Result := Rect(-100, -100, 100, 0); end; function TdxBarControl.GetSizeForWidth(AStyle: TdxBarDockingStyle; AWidth: Integer): TPoint; var J, ABeginGroupSize: Integer; AItemLink: TdxBarItemLink; Found: Boolean; PrevSize, Size: TPoint; function CalcSize(var Size: TPoint): Boolean; var I: Integer; begin Result := False; Size.X := 0; Size.Y := 0; for I := 0 to ItemLinks.VisibleItemCount - 1 do begin AItemLink := ItemLinks.VisibleItems[I]; if AItemLink.BeginGroup then ABeginGroupSize := BeginGroupSize else ABeginGroupSize := 0; with AItemLink.Control do begin if (Size.X + ABeginGroupSize + Width > AWidth) and (I <> 0) then begin Result := True; Break; end; Inc(Size.X, ABeginGroupSize + Width); if Size.Y < Height then Size.Y := Height; end; end; end; begin // if ItemLinks.RecentItemCount <> -1 then begin ItemLinks.RecentItemCount := -1; CalcLayout; ItemLinks.RestoreRecentItemCount; end; if MultiLine then if Vertical then begin Size := GetSizeForHeight(AStyle, GetMaxHeight(AStyle)); repeat if Size.X >= AWidth then Break; PrevSize := Size; Dec(Size.Y); Size := GetSizeForHeight(AStyle, Size.Y); until Size.Y = PrevSize.Y; Result := Size; end else begin Result := Point(GetMinWidth(AStyle), GetMinHeight(AStyle)); GetMultiLineBarSize(AStyle, AWidth, Result); end else case AStyle of dsTop, dsBottom: begin Result := Point(GetMinWidth(AStyle), GetMinHeight(AStyle)); if AWidth < Result.X then AWidth := Result.X; if MDIButtonsOnBar then Dec(AWidth, GetMDIWidth); ItemLinks.RecentItemCount := -1; if ItemLinks.CanVisibleItemCount > 0 then begin if MarkExists then Dec(AWidth, Painter.MarkSizeX); if ItemLinks.CanUseRecentItems and not BarManager.Designing then begin PrevSize := Result; if MarkExists then Dec(PrevSize.X, Painter.MarkSizeX); Found := False; for J := 1 to ItemLinks.CanVisibleItemCount do begin ItemLinks.RecentItemCount := J; Found := CalcSize(Size); if Found then begin ItemLinks.RecentItemCount := J - 1; Size := PrevSize; Break; end; PrevSize := Size; end; if not Found then ItemLinks.RecentItemCount := -1; end else CalcSize(Size); if MarkExists then Inc(Size.X, Painter.MarkSizeX); if Result.X < Size.X then Result.X := Size.X; Result.Y := Size.Y; if MDIButtonsOnBar then begin Inc(Result.X, GetMDIWidth); if Result.Y < GetMDIHeight then Result.Y := GetMDIHeight; end; end; end; dsLeft, dsRight: Result := Point(GetMinWidth(AStyle), GetMaxHeight(AStyle)); else Result := cxNullPoint; end; end; function TdxBarControl.GetSizeForHeight(AStyle: TdxBarDockingStyle; AHeight: Integer): TPoint; var J, ABeginGroupSize: Integer; AItemLink: TdxBarItemLink; Found: Boolean; PrevSize, Size: TPoint; function CalcSize(var Size: TPoint): Boolean; var I: Integer; begin Result := False; Size.X := 0; Size.Y := 0; for I := 0 to ItemLinks.VisibleItemCount - 1 do begin AItemLink := ItemLinks.VisibleItems[I]; if AItemLink.BeginGroup then ABeginGroupSize := BeginGroupSize else ABeginGroupSize := 0; with AItemLink.Control do begin if (Size.Y + ABeginGroupSize + Height > AHeight) and (I <> 0) then begin Result := True; Break; end; Inc(Size.Y, ABeginGroupSize + Height); if Size.X < Width then Size.X := Width; end; end; end; begin if ItemLinks.RecentItemCount <> -1 then begin ItemLinks.RecentItemCount := -1; CalcLayout; ItemLinks.RestoreRecentItemCount; end; if MultiLine then if Vertical then begin Result := Point(GetMinWidth(AStyle), GetMinHeight(AStyle)); GetMultiLineBarSize(AStyle, AHeight, Result); end else begin Size := GetSizeForWidth(AStyle, GetMaxWidth(AStyle)); repeat if Size.Y >= AHeight then Break; PrevSize := Size; Dec(Size.X); Size := GetSizeForWidth(AStyle, Size.X); until Size.X = PrevSize.X; Result := Size; end else case AStyle of dsTop, dsBottom: Result := Point(GetMaxWidth(AStyle), GetMinHeight(AStyle)); dsLeft, dsRight: begin Result := Point(GetMinWidth(AStyle), GetMinHeight(AStyle)); if AHeight < Result.Y then AHeight := Result.Y; if MDIButtonsOnBar then Dec(AHeight, GetMDIHeight); ItemLinks.RecentItemCount := -1; if ItemLinks.CanVisibleItemCount > 0 then begin if MarkExists then Dec(AHeight, Painter.MarkSizeX); if ItemLinks.CanUseRecentItems and not BarManager.Designing then begin PrevSize := Result; if MarkExists then Dec(PrevSize.Y, Painter.MarkSizeX); Found := False; for J := 1 to ItemLinks.CanVisibleItemCount do begin ItemLinks.RecentItemCount := J; Found := CalcSize(Size); if Found then begin ItemLinks.RecentItemCount := J - 1; Size := PrevSize; Break; end; PrevSize := Size; end; if not Found then ItemLinks.RecentItemCount := -1; end else CalcSize(Size); if MarkExists then Inc(Size.Y, Painter.MarkSizeX); if Result.Y < Size.Y then Result.Y := Size.Y; Result.X := Size.X; if MDIButtonsOnBar then begin Inc(Result.Y, GetMDIHeight); if Result.X < GetMDIWidth then Result.X := GetMDIWidth; end; end; end; end; end; function TdxBarControl.GetSizeForPopup: TSize; begin Result := cxNullSize; end; function TdxBarControl.GetTrackSize(AStyle: TdxBarDockingStyle): TPoint; var PrevRecentItemCount: Integer; begin if bboUnmoved in BehaviorOptions then AStyle := dsNone; Result.X := 0; Result.Y := 0; PrevRecentItemCount := ItemLinks.RecentItemCount; case AStyle of dsNone: begin Result := GetSizeForWidth(AStyle, Bar.FloatClientWidth); Inc(Result.X, Bar.BarNCSizeX(AStyle)); Inc(Result.Y, Bar.BarNCSizeY(AStyle)); end; dsTop, dsBottom: begin if (FBar <> nil) and FBar.WholeRow then Result.X := FDockControl.ClientWidth - FBar.BarNCSizeX(AStyle) else Result.X := GetMaxWidth(AStyle); Result := GetSizeForWidth(AStyle, Result.X); if (FBar <> nil) and FBar.WholeRow then Result.X := FDockControl.ClientWidth else Inc(Result.X, Bar.BarNCSizeX(AStyle)); Inc(Result.Y, Bar.BarNCSizeY(AStyle)); end; dsLeft, dsRight: begin if (FBar <> nil) and FBar.WholeRow then Result.Y := FDockControl.ClientHeight - FBar.BarNCSizeY(AStyle) else Result.Y := GetMaxHeight(AStyle); Result := GetSizeForHeight(AStyle, Result.Y); Inc(Result.X, Bar.BarNCSizeX(AStyle)); if (FBar <> nil) and FBar.WholeRow then Result.Y := FDockControl.ClientHeight else Inc(Result.Y, Bar.BarNCSizeY(AStyle)); end; end; if ItemLinks.RecentItemCount <> PrevRecentItemCount then begin ItemLinks.RecentItemCount := PrevRecentItemCount; CalcLayout; end; end; function TdxBarControl.HasCaption: Boolean; begin Result := True; end; function TdxBarControl.HasCloseButton: Boolean; begin Result := (DockingStyle = dsNone) and Bar.CanClose; end; function TdxBarControl.HideOnClick: Boolean; begin Result := IsPopup; end; function TdxBarControl.IgnoreClickAreaWhenHidePopup: TRect; begin Result := ParentBar.MarkRect; MapWindowRect(ParentBar.Handle, 0, Result); end; procedure TdxBarControl.InvalidateMark; begin Painter.BarMarkRectInvalidate(Self); end; function TdxBarControl.IsMarkAccessible: Boolean; begin Result := Painter.BarAllowQuickCustomizing and MarkExists; end; function TdxBarControl.IsInternal: Boolean; begin Result := IsPopup; end; function TdxBarControl.MarkExists: Boolean; begin Result := Bar.ShowMark and (FTruncated or (Painter.BarAllowQuickCustomizing and Bar.AllowQuickCustomizing)); end; function TdxBarControl.MarkNCRect: TRect; begin Result := MarkScreenRect; OffsetRect(Result, -WindowRect.Left, -WindowRect.Top); end; function TdxBarControl.MarkRect: TRect; begin Result := Painter.BarMarkRect(Self); end; function TdxBarControl.MarkItemRect: TRect; begin Result := Painter.BarMarkItemRect(Self); end; function TdxBarControl.MarkScreenRect: TRect; begin Result := MarkRect; MapWindowRect(Handle, 0, Result); end; procedure TdxBarControl.SetMarkState(Value: TdxBarMarkState); var ALinkSelf: TcxObjectLink; begin if IsCustomizing then Exit; if FMarkState <> Value then begin FMarkState := Value; FinishMoreButtonsHintTimer; if FMarkState = msPressed then begin //PlaySound(psMenuPopup); BarDesignController.ShowQuickControl(Self, MarkScreenRect); FQuickPopup := BarDesignController.QuickControl; end else begin ALinkSelf := cxAddObjectLink(Self); try FreeAndNil(FQuickPopup); if ALinkSelf.Ref = nil then Exit; finally cxRemoveObjectLink(ALinkSelf); end; if FMarkState = msSelected then begin if DockingStyle = dsNone then StartMoreButtonsHintTimer; BarManager.HintActivate(True, GetMoreButtonsHint, Self); end else if SelectedControl = nil then BarManager.HintActivate(False, ''); end; InvalidateMark; end; end; procedure TdxBarControl.SelectItemControl(AItemControl: TdxBarItemControl; AButton: TMouseButton; AShift: TShiftState); begin if (AItemControl = nil) then IsActive := False; //#DG first subitem - blue caption inherited; end; procedure TdxBarControl.ShowPopup(AItem: TdxBarItemControl); begin if not BarManager.IsCustomizing then BarDesignController.ShowToolbarsPopup(BarManager, Painter) else inherited; end; function TdxBarControl.SizeGripRect: TRect; begin with Result do begin Left := ClientWidth; Right := Left + Painter.StatusBarGripSize(BarManager).cx; Bottom := ClientHeight; Top := Bottom - Painter.StatusBarGripSize(BarManager).cy; end; end; procedure TdxBarControl.UpdateCaptionButtons(ACaptionButton: TdxBarCaptionButton); begin // do nothing end; procedure TdxBarControl.UpdateItem(AControl: TdxBarItemControl); begin cxInvalidateRect(Handle, GetItemRect(AControl), False); end; procedure TdxBarControl.BarManagerStyleChanged; var ABar: TdxBar; begin UpdateControlStyle; CalcDrawingConsts; if DockingStyle = dsNone then begin ABar := Bar; ABar.Visible := False; ABar.Visible := True; end else RebuildBar; end; procedure TdxBarControl.CaptionChanged; begin Text := GetCaption; SendMessage(Handle, WM_NCPAINT, 0, 0); end; procedure TdxBarControl.DoDrawBeginGroup(const ASeparatorRect: TRect; AHorz: Boolean); begin Painter.BarDrawBeginGroup(Self, Canvas.Handle, ASeparatorRect, ToolbarBrush, AHorz); end; procedure TdxBarControl.DoNCPaint(DC: HDC); var AWindowRect, R, CR: TRect; Rgn, Rgn1: HRGN; AToolbarBrush: HBRUSH; BR: TRect; procedure DrawStatusBar; var R1: TRect; begin // separator R1 := R; R1.Bottom := R1.Top + Painter.StatusBarTopBorderSize(BarManager); Painter.BarDrawStatusBarTopBorder(Self, DC, R1, AToolbarBrush); // grip if FHasSizeGrip then begin R1 := R; Inc(R1.Top, Painter.StatusBarTopBorderSize(BarManager)); R1.Left := R1.Right - Painter.StatusBarGripSize(BarManager).cx; Painter.BarDrawStatusBarGrip(Self, DC, R1, AToolbarBrush); end; end; procedure DrawFloatingBarBorder; begin Painter.BarDrawFloatingBarBorder(Self, DC, R, CR, AToolbarBrush); end; procedure DrawFloatingBarCaption; begin if not HasCaption then Exit; R := GetCaptionNCRect; CR := R; Painter.BarDrawFloatingBarCaption(Self, DC, R, CR, AToolbarBrush); end; begin if Painter.IsCompoundPainting then begin Painter.DrawToolbarNonContentPart(Self, DC); Exit; end; AWindowRect := WindowRect; CR := ClientBounds; R := NCRect; AToolbarBrush := ToolbarBrush; if (DockingStyle <> dsNone) and (FBar.BorderStyle = bbsNone) then begin if FBar.IsStatusBar then DrawStatusBar; Exit; end; with R do if DockingStyle = dsNone then begin DrawFloatingBarBorder; R := CR; if HasCaption then begin Dec(Left, Painter.BarHorSize); Inc(Right, Painter.BarHorSize); Dec(Top, Painter.BarTopSize); Inc(Bottom, Painter.BarBottomSize); end; Rgn := CreateRectRgn(Left, Top, Right, Bottom); end else begin Painter.BarBorderPaintSizes(Self, BR); Rgn := CreateRectRgn(Left + BR.Left, Top + BR.Top, Right - BR.Right, Bottom - BR.Bottom); end; with CR do Rgn1 := CreateRectRgn(Left, Top, Right, Bottom); CombineRgn(Rgn, Rgn1, Rgn, RGN_XOR); DeleteObject(Rgn1); FillBackgroundRgn(DC, Rgn, AToolbarBrush, False); DeleteObject(Rgn); if DockingStyle <> dsNone then Painter.BarDrawDockedBarBorder(Self, DC, R, AToolbarBrush); if DockingStyle = dsNone then DrawFloatingBarCaption; end; procedure TdxBarControl.DoPaint; var AButtons: TdxBarMDIButtons; AItemLink: TdxBarItemLink; I: Integer; begin //#DG if {not IsWindowVisible(BarManager.Owner.Handle) or} FDestroyFlag then Exit; if {not IsWindowVisible(BarManager.Owner.Handle) or} IsDestroying then Exit; // // recalc positions of items // CalcLayout; // hide invisible items that require that if not BarManager.Designing then for I := 0 to FItemLinks.CanVisibleItemCount - 1 do begin AItemLink := FItemLinks.CanVisibleItems[I]; with AItemLink do if Item.NeedToBeHidden and (VisibleIndex = -1) then Item.HideControl(Control); end; Canvas.SaveClipRegion; try if Painter.IsCompoundPainting then DrawContentBackground; DrawItems; DrawBeginGroups; if MDIButtonsOnBar then begin if RealMDIButtonsOnBar then AButtons := [mdibMinimize, mdibRestore, mdibClose] else AButtons := [mdibClose]; DrawMDIButtons(AButtons, True); end; if (DockingStyle <> dsNone) and MarkExists then DrawMarks; if not Painter.IsCompoundPainting then DrawContentBackground; finally Canvas.RestoreClipRegion; end; DrawSelection(Canvas.Handle); end; procedure TdxBarControl.DrawBeginGroups; var I: Integer; ASeparatorRect: TRect; begin for I := 0 to ViewInfo.SeparatorCount - 1 do begin ASeparatorRect := ViewInfo.SeparatorInfos[I].Bounds; DoDrawBeginGroup(ASeparatorRect, ViewInfo.SeparatorInfos[I].Kind = skHorizontal); Canvas.ExcludeClipRect(ASeparatorRect); end; end; procedure TdxBarControl.DrawItems; var I: Integer; AItemControlViewInfo: TdxBarItemControlViewInfo; begin for I := 0 to ViewInfo.ItemControlCount - 1 do begin AItemControlViewInfo := ViewInfo.ItemControlViewInfos[I]; PaintItem(AItemControlViewInfo.Control); Canvas.ExcludeClipRect(AItemControlViewInfo.Bounds); end; end; procedure TdxBarControl.DrawContentBackground; begin Painter.DrawToolbarContentPart(Self, Canvas); end; procedure TdxBarControl.DrawMarks; var AMarkRect: TRect; begin AMarkRect := MarkItemRect; Painter.BarDrawMarks(Self, Canvas, AMarkRect, ToolbarBrush); Canvas.ExcludeClipRect(AMarkRect); end; procedure TdxBarControl.DrawMDIButtons(AButtons: TdxBarMDIButtons; AExcludeClipRect: Boolean = False); var AButton: TdxBarMDIButton; begin for AButton := Low(TdxBarMDIButton) to High(TdxBarMDIButton) do if AButton in AButtons then begin DrawMDIButton(AButton, FIsMouseOverMDIButton and (AButton = FSelectedMDIButton), FIsMDIButtonPressed and (AButton = FPressedMDIButton)); if AExcludeClipRect then Canvas.ExcludeClipRect(RectMDI(AButton)); end; end; procedure TdxBarControl.DrawSelection(ADC: HDC); begin if BarManager.Designing and Bar.IsComponentSelected then begin if BarDesignController.NeedDefaultSelection(Bar) then dxBarFrameRect(ADC, ClientRect, COLOR_WINDOWTEXT) else dxBarFocusRect(ADC, ClientRect); end; end; procedure TdxBarControl.FillBackground(ADC: HDC; const ARect: TRect; ABrush: HBRUSH; AColor: TColor; AIsClientArea: Boolean); var R: TRect; begin // calc rect if AIsClientArea then R := cxRectOffset(ARect, NCOffset) else R := ARect; Painter.BarDrawBackground(Self, ADC, ARect, R, ABrush, AColor); end; procedure TdxBarControl.FrameChanged; begin SetWindowPos(Handle, 0, 0, 0, 0, 0, SWP_NOZORDER or SWP_NOMOVE or SWP_NOSIZE or SWP_NOACTIVATE or SWP_FRAMECHANGED); end; function TdxBarControl.GetCaption: TCaption; begin Result := Bar.Caption; end; function TdxBarControl.GetEditFont: TFont; begin if FBar.UseOwnFont then Result := FBar.FEditFont else Result := inherited GetEditFont; end; function TdxBarControl.GetFont: TFont; begin Result := Bar.Font; end; function TdxBarControl.GetFullItemRect(Item: TdxBarItemControl): TRect; begin Result := GetItemRect(Item); with Item.ItemLink, Result do if Vertical then begin Dec(Left, (RowHeight - (Right - Left)) div 2); Right := Left + RowHeight; end else begin Dec(Top, (RowHeight - (Bottom - Top)) div 2); Bottom := Top + RowHeight; end; end; function TdxBarControl.GetItemRegion(Item: TdxBarItemControl): HRGN; var Rgn: HRGN; ASeparatorIndex: Integer; begin Result := CreateRectRgnIndirect(GetFullItemRect(Item)); if ViewInfo.IsAssociatedWithSeparator(Item, ASeparatorIndex) then begin Rgn := CreateRectRgnIndirect(ViewInfo.SeparatorInfos[ASeparatorIndex].Bounds); CombineRgn(Result, Result, Rgn, RGN_OR); DeleteObject(Rgn); end; end; function TdxBarControl.GetToolbarBrush: HBRUSH; begin Result := Painter.BarToolbarBrushEx(Self); end; procedure TdxBarControl.GlyphChanged; begin end; function TdxBarControl.IsBackgroundBitmap: Boolean; begin Result := inherited IsBackgroundBitmap or not Bar.BackgroundBitmap.Empty or not BarManager.Backgrounds.Bar.Empty; end; function TdxBarControl.IsTransparent: Boolean; begin Result := (Bar.Color <> clDefault) or not Bar.BackgroundBitmap.Empty or not BarManager.Backgrounds.Bar.Empty or inherited IsTransparent or Painter.IsCompoundPainting; end; function TdxBarControl.LockHotTrackWhenPopup: Boolean; begin Result := True; end; function TdxBarControl.NCOffset: TPoint; begin // Result := inherited NCOffset; // if DockingStyle <> dsNone then Result := ClientBounds.TopLeft; end; function TdxBarControl.NeedHideOnNCMouseClick: Boolean; begin Result := GetParentPopupWindow(Self, True) = nil; end; function TdxBarControl.NotHandleMouseMove(ACheckLastMousePos: Boolean = True): Boolean; function ControlContainerActive: Boolean; begin Result := HasAsParent(GetActiveWindow, BarManager.Owner.Handle); end; var AQuickControl: TdxBarControl; begin Result := inherited NotHandleMouseMove(ACheckLastMousePos) or (DockingStyle <> dsNone) and not IsFormActive(ParentForm) and not ControlContainerActive; if not Result then begin AQuickControl := BarDesignController.QuickControl; Result := (AQuickControl <> nil) and AQuickControl.LockHotTrackWhenPopup and not ((Self = AQuickControl) or AQuickControl.IsChildBar(Self)); end; end; procedure TdxBarControl.RebuildBar; begin UpdateDoubleBuffered; FrameChanged; RepaintBar; end; procedure TdxBarControl.RefreshShadow; begin FShadow.Refresh; end; procedure TdxBarControl.RepaintMDIButtons; var AButtons: TdxBarMDIButtons; begin if RealMDIButtonsOnBar then AButtons := [mdibMinimize, mdibRestore, mdibClose] else AButtons := [mdibClose]; DrawMDIButtons(AButtons); end; procedure TdxBarControl.SavePos; begin if not FBar.Visible or FMoving or BarManager.IsDestroying then Exit; FPosSaving := True; BarManager.LockDesignerModified(True); try if DockingStyle = dsNone then begin Bar.FloatLeft := Left; Bar.FloatTop := Top; Bar.FloatClientWidth := ClientWidth; Bar.FloatClientHeight := ClientHeight; end else if (DockControl <> nil) and not DockControl.IsBarHandleDestroying and not BarManager.IsHandleCreating then begin Bar.DockedDockingStyle := DockingStyle; if DockControl.Main then Bar.DockedDockControl := nil else Bar.DockedDockControl := TdxBarDockControl(DockControl); if GetDockCol <> nil then begin Bar.OneOnRow := GetDockCol.DockRow.FBars.Count = 1; // FBar.Bars.BeginUpdate; try Bar.DockedLeft := Left; Bar.DockedTop := Top; finally // FBar.Bars.EndUpdate; end; end; end; finally FPosSaving := False; BarManager.LockDesignerModified(False); end; end; procedure TdxBarControl.SetFont; begin Font := GetFont; end; procedure TdxBarControl.SetDockingStyle(Value: TdxBarDockingStyle); begin if DockingStyle <> Value then FTruncated := False; inherited; end; procedure TdxBarControl.SetKeySelectedItem(Value: TdxBarItemControl); var APrevSelectedControl: TdxBarItemControl; begin APrevSelectedControl := SelectedControl; inherited SetKeySelectedItem(Value); if (SelectedControl <> APrevSelectedControl) and (SelectedControl <> nil) and not SelectedControl.IsActive and not IsCustomizing then if SelectedControl is TdxBarSubItemControl then SelectedControl.ControlClick(False) else SelectedControl.ControlActivate(True); end; procedure TdxBarControl.SetLayeredAttributes; var AAlphaBlendValue: Byte; begin if FMoving or ((DockingStyle = dsNone) and not IsInternal) then AAlphaBlendValue := Bar.AlphaBlendValue else AAlphaBlendValue := 255; if FMoving then SetLayeredWndAttributes(FFloatingHandle, AAlphaBlendValue) else SetLayeredWndAttributes(Handle, AAlphaBlendValue); end; function TdxBarControl.IsRealVertical: Boolean; begin Result := Vertical; end; function TdxBarControl.IsVertical: Boolean; begin Result := IsRealVertical and Bar.RotateWhenVertical; end; function TdxBarControl.Kind: TdxBarKind; begin Result := bkBarControl; end; procedure TdxBarControl.Popup(const AOwnerRect: TRect); begin PopupEx(AOwnerRect, xdRight); end; procedure TdxBarControl.PopupEx(const AOwnerRect: TRect; APopupDirection: TXDirection); var AWorkArea: TRect; ASize: TSize; P: TPoint; begin ClosedByEscape := False; ASize := GetSizeForPopup; if ParentBar.IsRealVertical then P := Point(AOwnerRect.Right, AOwnerRect.Top) else case APopupDirection of xdLeft: P := Point(AOwnerRect.Right - ASize.cx, AOwnerRect.Bottom); xdRight: P := Point(AOwnerRect.Left, AOwnerRect.Bottom); end; AWorkArea := GetWorkArea(P); if ParentBar.IsRealVertical then begin if P.X + ASize.cx > AWorkArea.Right then P.X := AOwnerRect.Left - ASize.cx; if P.Y < AWorkArea.Top then P.Y := AWorkArea.Top; if P.Y + ASize.cy > AWorkArea.Bottom then P.Y := AWorkArea.Bottom - ASize.cy; end else begin if P.X < AWorkArea.Left then P.X := AWorkArea.Left; if P.X + ASize.cx > AWorkArea.Right then P.X := AWorkArea.Right - ASize.cx; if P.Y + ASize.cy > AWorkArea.Bottom then P.Y := AOwnerRect.Top - ASize.cy; end; SetWindowPos(Handle, HWND_TOP, P.X, P.Y, ASize.cx, ASize.cy, SWP_SHOWWINDOW or SWP_NOACTIVATE); end; procedure TdxBarControl.Repaint; begin if (Bar <> nil) and Bar.BarManager.IsUpdateLocked then Bar.DoChanged else inherited; end; procedure TdxBarControl.UpdateFont; begin Font := GetFont; Perform(CM_FONTCHANGED, 0, 0); end; procedure TdxBarControlViewInfo.Calculate; var AItemLink: TdxBarItemLink; I: Integer; begin BarControl.CalcControlsPositions; inherited Calculate; for I := 0 to BarControl.ItemLinks.VisibleItemCount - 1 do begin AItemLink := BarControl.ItemLinks.VisibleItems[I]; if AItemLink.Control = nil then Continue; AddItemControlViewInfo(AItemLink.Control.ViewInfo); IdxBarItemControlViewInfo(AItemLink.Control.ViewInfo).SetBounds(BarControl.GetItemRect(AItemLink.Control)); CalcSeparatorInfo(AItemLink); if IsLastVisibleItemControl(AItemLink.Control) then Break; end; end; procedure TdxBarControlViewInfo.CalcSeparatorInfo(AItemLink: TdxBarItemLink); var AItemRect: TRect; begin if not CanShowSeparators then Exit; AItemRect := AItemLink.Control.ViewInfo.Bounds; if AItemLink.BeginGroup and not IsRectEmpty(AItemRect) then DoCalcSeparatorInfo(AItemLink, AItemRect); end; function TdxBarControlViewInfo.CanShowButtonGroups: Boolean; begin Result := False; end; function TdxBarControlViewInfo.CanShowSeparators: Boolean; begin Result := True; end; procedure TdxBarControlViewInfo.DoCalcSeparatorInfo(AItemLink: TdxBarItemLink; const AItemRect: TRect); var R: TRect; begin if not BarControl.Vertical and (AItemRect.Left = 0) and (AItemRect.Top > 0) or BarControl.Vertical and (AItemRect.Top > 0) then begin // begin group in vertical direction if BarControl.Vertical then R := Bounds(AItemRect.Left - (AItemLink.FRowHeight - cxRectWidth(AItemRect)) div 2, AItemRect.Top - BarControl.BeginGroupSize, AItemLink.FRowHeight, BarControl.BeginGroupSize) else R := Bounds( 0, AItemRect.Top - (AItemLink.FRowHeight - cxRectHeight(AItemRect)) div 2 - BarControl.BeginGroupSize, BarControl.ClientWidth - Byte((BarControl.DockingStyle <> dsNone) and BarControl.MarkExists) * BarControl.Painter.MarkSizeX, BarControl.BeginGroupSize); AddSeparatorInfo(R, skHorizontal, AItemLink.Control); end else begin // begin group in horizontal direction if BarControl.Vertical then R := Bounds( AItemRect.Right + (AItemLink.FRowHeight - cxRectWidth(AItemRect)) div 2, 0, BarControl.BeginGroupSize, BarControl.ClientHeight - Byte((BarControl.DockingStyle <> dsNone) and BarControl.MarkExists) * BarControl.Painter.MarkSizeX) else R := Bounds( AItemRect.Left - BarControl.BeginGroupSize, AItemRect.Top - (AItemLink.FRowHeight - cxRectHeight(AItemRect)) div 2, BarControl.BeginGroupSize, AItemLink.FRowHeight); AddSeparatorInfo(R, skVertical, AItemLink.Control); end; end; function TdxBarControlViewInfo.IsLastVisibleItemControl( AItemControl: TdxBarItemControl): Boolean; begin Result := False; end; function TdxBarControlViewInfo.GetBarControl: TdxBarControl; begin Result := TdxBarControl(FBarControl); end; { TdxBarSubMenuControl } type TdxBarAnimationInfo = record AnimationMenu: TdxBarSubMenuControl; AnimationType: TdxBarMenuAnimations; LeftDirection, TopDirection: Boolean; RealLeft, RealTop: Integer; RealClientWidth, RealClientHeight: Integer; BorderWidth, BorderHeight: Integer; FirstValue: Integer; Delta: Integer; Step: Integer; OldClientRect: TRect; end; TdxBarAnimationThread = class(TThread) private FAnimationInfo: TdxBarAnimationInfo; FPrevGDIObject: HGDIOBJ; FCompatibleDC: HDC; procedure DoAnimation; procedure DoOneStepOfAnimation(AIteration: Integer); procedure DoFinishAnimation; protected procedure DoTerminate; override; procedure Execute; override; public constructor Create(const AAnimationInfo: TdxBarAnimationInfo); destructor Destroy; override; procedure TerminateAnimation; end; constructor TdxBarAnimationThread.Create(const AAnimationInfo: TdxBarAnimationInfo); var ADC: HDC; begin inherited Create(True); FreeOnTerminate := True; FAnimationInfo := AAnimationInfo; ADC := FAnimationInfo.AnimationMenu.Canvas.Handle; FCompatibleDC := CreateCompatibleDC(ADC); FPrevGDIObject := SelectObject(FCompatibleDC, CreateCompatibleBitmap(ADC, FAnimationInfo.RealClientWidth, FAnimationInfo.RealClientHeight)); FAnimationInfo.AnimationMenu.PaintWindow(FCompatibleDC); end; destructor TdxBarAnimationThread.Destroy; begin ReverseGDIObject(FCompatibleDC, FPrevGDIObject); DeleteDC(FCompatibleDC); inherited; end; procedure TdxBarAnimationThread.TerminateAnimation; begin FreeOnTerminate := False; try Terminate; WaitFor; finally Free; end; end; procedure TdxBarAnimationThread.DoTerminate; begin inherited; Synchronize(DoFinishAnimation); end; procedure TdxBarAnimationThread.Execute; begin DoAnimation; end; procedure TdxBarAnimationThread.DoAnimation; var AFirstTime: DWORD; I: Integer; begin for I := 1 to FAnimationInfo.Delta div FAnimationInfo.Step do begin if Terminated then Break; AFirstTime := GetTickCount; DoOneStepOfAnimation(I); Sleep(1); while (GetTickCount - AFirstTime < 1) and not Terminated do {loop}; end; end; procedure TdxBarAnimationThread.DoOneStepOfAnimation(AIteration: Integer); var ANewLeft, ANewTop, ANewClientWidth, ANewClientHeight: Integer; R, R1, R2: TRect; DC: HDC; begin with FAnimationInfo do begin if FirstValue >= 0 then begin ANewClientWidth := Step * AIteration; ANewClientHeight := FirstValue + ANewClientWidth; if AnimationType = maSlide then ANewClientWidth := AnimationMenu.ClientWidth; end else begin ANewClientHeight := Step * AIteration; ANewClientWidth := Abs(FirstValue) + ANewClientHeight; end; if LeftDirection then ANewLeft := AnimationMenu.Left - (ANewClientWidth - AnimationMenu.ClientWidth) else ANewLeft := AnimationMenu.Left; if TopDirection then ANewTop := AnimationMenu.Top - (ANewClientHeight - AnimationMenu.ClientHeight) else ANewTop := AnimationMenu.Top; SetWindowPos(AnimationMenu.Handle, 0, ANewLeft, ANewTop, BorderWidth + ANewClientWidth, BorderHeight + ANewClientHeight, SWP_NOZORDER or SWP_NOACTIVATE or SWP_SHOWWINDOW); DC := GetDC(AnimationMenu.Handle); AnimationMenu.PreparePalette(DC); R1 := OldClientRect; if TopDirection then begin R := Rect(0, 0, ANewClientWidth, ANewClientHeight); OffsetRect(R1, 0, ANewClientHeight - R1.Bottom); cxBitBlt(DC, DC, OldClientRect, R1.TopLeft, SRCCOPY); R1 := OldClientRect; BitBlt(DC, 0, R1.Bottom, AnimationMenu.ClientWidth, AnimationMenu.ClientHeight - R1.Bottom, FCompatibleDC, R.Left, R.Top + R1.Bottom, SRCCOPY); BitBlt(DC, R1.Right, R1.Top, AnimationMenu.ClientWidth - R1.Right, R1.Bottom - R1.Top, FCompatibleDC, R.Left + R1.Right, R.Top, SRCCOPY); end else if LeftDirection then begin R := Rect(RealClientWidth - AnimationMenu.ClientWidth, RealClientHeight - AnimationMenu.ClientHeight, RealClientWidth, RealClientHeight); OffsetRect(R1, AnimationMenu.ClientWidth - R1.Right, 0); R2 := R1; OffsetRect(R2, 0, AnimationMenu.ClientHeight - R1.Bottom); cxBitBlt(DC, DC, R2, R1.TopLeft, SRCCOPY); R1 := R2; BitBlt(DC, 0, 0, AnimationMenu.ClientWidth, R1.Top, FCompatibleDC, R.Left, R.Top, SRCCOPY); BitBlt(DC, 0, R1.Top, R1.Left, AnimationMenu.ClientHeight - R1.Top, FCompatibleDC, R.Left, R.Top + R1.Top, SRCCOPY); end else begin R := Rect(0, RealClientHeight - AnimationMenu.ClientHeight, AnimationMenu.ClientWidth, RealClientHeight); OffsetRect(R1, 0, AnimationMenu.ClientHeight - R1.Bottom); cxBitBlt(DC, DC, R1, OldClientRect.TopLeft, SRCCOPY); BitBlt(DC, 0, 0, AnimationMenu.ClientWidth, R1.Top, FCompatibleDC, R.Left, R.Top, SRCCOPY); BitBlt(DC, R1.Right, R1.Top, AnimationMenu.ClientWidth - R1.Right, AnimationMenu.ClientHeight - R1.Top, FCompatibleDC, R.Left + R1.Right, R.Top + R1.Top, SRCCOPY); end; OldClientRect := AnimationMenu.ClientRect; AnimationMenu.UnpreparePalette(DC); UpdateColors(DC); ReleaseDC(AnimationMenu.Handle, DC); end; end; procedure TdxBarAnimationThread.DoFinishAnimation; begin with FAnimationInfo do if not AnimationMenu.IsDestroying then begin SetWindowPos(AnimationMenu.Handle, 0, RealLeft, RealTop, BorderWidth + RealClientWidth, BorderHeight + RealClientHeight, SWP_NOZORDER or SWP_NOACTIVATE or SWP_SHOWWINDOW or SWP_FRAMECHANGED {to enforce WM_WINDOWPOSCHANGED}); AnimationMenu.Repaint; end; end; constructor TdxBarSubMenuControl.Create(AOwner: TComponent); begin inherited Create(AOwner); Width := 0; FXDirection := xdRight; FYDirection := ydBottom; end; destructor TdxBarSubMenuControl.Destroy; begin if BarManager.FChangedSubMenuControl = Self then BarManager.FChangedSubMenuControl := nil; DoBarLostFocus; //#DG IsActive := False; inherited Destroy; end; function TdxBarSubMenuControl.GetBandSize: Integer; begin Result := Painter.SubMenuControlGetBandSize(Self); end; function TdxBarSubMenuControl.GetBarSize: Integer; begin if GetSubMenuOwner <> nil then Result := GetSubMenuOwner.GetBarSize else Result := 0; end; function TdxBarSubMenuControl.GetBarRect: TRect; begin Result := Rect(ItemsRect.Left - BarSize, ItemsRect.Top, ItemsRect.Left, ItemsRect.Bottom); end; function TdxBarSubMenuControl.GetBottomVisibleItemIndex: Integer; var AMaxVisibleItemCount: Integer; begin AMaxVisibleItemCount := Max(GetMaxVisibleCount, 1); Result := TopIndex + AMaxVisibleItemCount - 1; if not UseScrollButtons and DownArrowExists then Dec(Result); end; function TdxBarSubMenuControl.GetBorderSize: Integer; begin Result := Painter.SubMenuControlBorderSize; end; function TdxBarSubMenuControl.GetContentRect: TRect; begin Result := cxRectContent(ClientRect, Painter.SubMenuControlContentRectOffset(Self)); end; function TdxBarSubMenuControl.GetDetachCaptionSize: Integer; begin Result := Canvas.TextHeight('Qq') div 2; if not Odd(Result) then Inc(Result); end; function TdxBarSubMenuControl.GetMaxVisibleCount: Integer; var I: Integer; begin for I := TopIndex to ItemLinks.VisibleItemCount - 1 do if ItemLinks.VisibleItems[I].ItemRect.Bottom = 0 then begin Result := I - TopIndex; Exit; end; Result := ItemLinks.VisibleItemCount - TopIndex; end; function TdxBarSubMenuControl.GetParentItemControl: TdxBarItemControl; begin if FDropDownButton <> nil then Result := FDropDownButton else Result := FSubItem; end; function TdxBarSubMenuControl.GetSubMenuOwner: IdxBarSubMenuOwner; begin Supports(TObject(ItemLinks.Owner), IdxBarSubMenuOwner, Result); end; function TdxBarSubMenuControl.GetToolbarItemsBrush: HBRUSH; begin Result := Painter.SubMenuControlToolbarItemsBrush(Self); end; function TdxBarSubMenuControl.GetTopVisibleItemIndex: Integer; begin Result := TopIndex; if not UseScrollButtons and UpArrowExists then Inc(Result); end; procedure TdxBarSubMenuControl.SetDetachCaptionSelected(AValue: Boolean); begin if IsCustomizing or (GetCapture <> 0) then Exit; if FDetachCaptionSelected <> AValue then begin FDetachCaptionSelected := AValue; InvalidateDetachCaption; SetCursorForMoving(AValue); if AValue then BarManager.HintActivate(True, cxGetResourceString(@dxSBAR_DRAGTOMAKEMENUFLOAT), Self) else if SelectedControl = nil then BarManager.HintActivate(False, ''); end; end; procedure TdxBarSubMenuControl.SetTopIndex(AValue: Integer); begin if AValue < 0 then AValue := 0; if FTopIndex <> AValue then begin FTopIndex := AValue; InvalidateItemsRect; end; end; procedure TdxBarSubMenuControl.CalcBounds(out ASize: TSize); procedure CalcItemSizeParams; var ARecentItemCount: Integer; AExtendedView: Boolean; ALastWasRecentItem: Boolean; I: Integer; AItemLink: TdxBarItemLink; begin ARecentItemCount := ItemLinks.MostRecentItemCount; if ARecentItemCount = -1 then ARecentItemCount := ItemLinks.CanVisibleItemCount; AExtendedView := ExtendedView; ALastWasRecentItem := True; for I := TopIndex to ItemLinks.VisibleItemCount - 1 do begin AItemLink := ItemLinks.VisibleItems[I]; AItemLink.Control.FNonRecent := AExtendedView and (AItemLink.RecentIndex >= ARecentItemCount); AItemLink.Control.FChangeRecentGroup := AExtendedView and ((I > TopIndex) or Detachable) and (AItemLink.Control.FNonRecent = ALastWasRecentItem); ALastWasRecentItem := not AItemLink.Control.FNonRecent; end; end; begin CalcItemSizeParams; CalcSize(ASize); end; procedure TdxBarSubMenuControl.CalcSize(out ASize: TSize); begin DoCalcSize(ASize); if (ASize.cy <= 2) or MarkExists then Inc(ASize.cy, TextSize); DoCorrectSize(ASize); end; function TdxBarSubMenuControl.GetItemsPaneSize: TSize; var I: Integer; AItemLink: TdxBarItemLink; begin Result := Size(0, 0); for I := TopIndex to ItemLinks.VisibleItemCount - 1 do begin AItemLink := ItemLinks.VisibleItems[I]; Result.cx := Max(Result.cx, AItemLink.Control.Width); Result.cy := Result.cy + GetItemControlOffset(AItemLink) + AItemLink.Control.Height; end; if UseScrollButtons and UpArrowExists then Inc(Result.cy, Painter.SubMenuControlGetScrollBandSize(Self)); if Result.cx = 0 then Result.cx := 100; end; procedure TdxBarSubMenuControl.CreateLightBrush; var Color: COLORREF; R, G, B: Integer; DC: HDC; LogPalette: TLogPalette; begin Color := GetSysColor(COLOR_BTNFACE); R := Min(255, GetRValue(Color) + dxBarNonrecentlyUsedItemsColorDelta); G := Min(255, GetGValue(Color) + dxBarNonrecentlyUsedItemsColorDelta); B := Min(255, GetBValue(Color) + dxBarNonrecentlyUsedItemsColorDelta); DC := GetDC(0); if BarManager.ShowRecentItemsFirst and (GetDeviceCaps(DC, BITSPIXEL) <= 8) then begin with LogPalette do begin palVersion := $0300; palNumEntries := 1; with palPalEntry[0] do begin peRed := R; peGreen := G; peBlue := B; peFlags := 0; end; end; FLightPalette := CreatePalette(LogPalette); FLightBrush := CreateSolidBrush(PaletteIndex(0)); end else begin Color := RGB(R, G, B); FLightBrush := CreateSolidBrush(Color); end; ReleaseDC(0, DC); end; procedure TdxBarSubMenuControl.DestroyLightBrush; begin DeleteGDIObject(FLightBrush); DeleteGDIObject(FLightPalette); end; procedure TdxBarSubMenuControl.PreparePalette(DC: HDC); begin if FLightPalette <> 0 then begin SelectPalette(DC, FLightPalette, True); RealizePalette(DC); end; end; procedure TdxBarSubMenuControl.UnpreparePalette(DC: HDC); begin if FLightPalette <> 0 then begin SelectPalette(DC, GetStockObject(DEFAULT_PALETTE), True); RealizePalette(DC); end; end; procedure TdxBarSubMenuControl.ExpandMenu; begin if MarkExists then begin ShowFullMenus := True; FShowAnimation := True; FExpandingMenu := True; try DestroyWnd; finally FExpandingMenu := False; end; Left := FOnShowLeft; Top := FOnShowTop; Show; end; end; function TdxBarSubMenuControl.ExtendedView: Boolean; begin Result := BarManager.ShowRecentItemsFirst and ShowFullMenus; end; procedure TdxBarSubMenuControl.InvalidateItemsRect; begin cxInvalidateRect(Handle, ItemsRect, False); end; procedure TdxBarSubMenuControl.InvalidateDetachCaption; var DC: HDC; begin DC := GetWindowDC(Handle); Painter.SubMenuControlDrawDetachCaption(Self, DC, DetachCaptionRect); ReleaseDC(Handle, DC); end; function TdxBarSubMenuControl.MouseOnArrow(AArrowDirection: TcxArrowDirection): Boolean; begin Result := PtInRect(Painter.SubMenuControlGetScrollBandBounds(Self, AArrowDirection), ScreenToClient(GetMouseCursorPos)); end; function TdxBarSubMenuControl.MouseOnUpArrow: Boolean; begin Result := MouseOnArrow(adUp); end; function TdxBarSubMenuControl.MouseOnDownArrow: Boolean; begin Result := MouseOnArrow(adDown); end; procedure ExpandMenuTimerProc(Wnd: HWND; Msg: UINT; idEvent: UINT; Time: DWORD); stdcall; begin with TdxBarSubMenuControl(FindControl(Wnd)) do begin KillExpandMenuTimer; if idEvent = 3 then MarkState := msPressed else if ChildBar = nil then MarkState := msSelected; end; end; procedure TdxBarSubMenuControl.SetExpandMenuTimer(Time: UINT; ExpandAfterDelay: Boolean); begin FExpandMenuTimer := SetTimer(Handle, 2 + Byte(ExpandAfterDelay), Time, @ExpandMenuTimerProc); end; procedure TdxBarSubMenuControl.KillExpandMenuTimer; begin if FExpandMenuTimer <> 0 then dxKillTimer(Handle, FExpandMenuTimer); end; procedure TdxBarSubMenuControl.KillScrollTimer; begin if FScrollTimerID <> 0 then dxKillTimer(Handle, FScrollTimerID); end; function TdxBarSubMenuControl.IsAnimationRunning: Boolean; begin Result := (FAnimationThread <> nil) and not FAnimationThread.Suspended; end; procedure TdxBarSubMenuControl.OnTerminateAnimation(Sender: TObject); begin FAnimationThread := nil; end; procedure TdxBarSubMenuControl.WMGetDlgCode; begin Message.Result := DLGC_WANTALLKEYS or DLGC_WANTARROWS or DLGC_WANTTAB; end; procedure TdxBarSubMenuControl.WMKeyDown(var Message: TWMKeyDown); var Shift: TShiftState; ParentBarControl: TCustomdxBarControl; ALinkSelf: TcxObjectLink; begin TerminateAnimation; Shift := KeyDataToShiftState(Message.KeyData); if (Message.CharCode in [VK_DOWN, VK_TAB]) and MarkExists then if (Message.CharCode = VK_DOWN) and (Shift = [ssCtrl]) then begin MarkState := msPressed; Exit; end else if (Shift = []) and (SelectedControl <> nil) then with SelectedControl.ItemLink do if VisibleIndex = Owner.VisibleItemCount - 1 then begin MarkState := msPressed; SendMessage(Handle, WM_KEYDOWN, Message.CharCode, 1); Exit; end; ALinkSelf := cxAddObjectLink(Self); try inherited; if (ALinkSelf.Ref <> nil) and (ActiveBarControl <> nil) and not SelectedItemWantsKey(Message.CharCode) then with Message do begin case CharCode of VK_ESCAPE: if (ParentBar <> nil) and (ParentBar.SelectedControl <> nil) then begin ClosedByEscape := True; ParentBarControl := ParentBar; ParentBarControl.SelectedControl.ControlInactivate(True); ParentBarControl.IsDowned := False; end else HideByEscape; VK_LEFT: begin ParentBarControl := ParentBar; if (ParentBarControl <> nil) and (ParentBarControl.SelectedControl <> nil) then if ParentBarControl is TdxBarSubMenuControl then ParentBarControl.SelectedControl.ControlInactivate(True) else begin ParentBarControl := GetParentBarForBar(Self); if ParentBarControl <> nil then if ParentBarControl.IsRealVertical then Message.Result := SendMessage(Handle, WM_KEYDOWN, VK_ESCAPE, 0) else Message.Result := SendMessage(ParentBarControl.Handle, WM_KEYDOWN, VK_LEFT, 0); end; end; VK_RIGHT: begin ParentBarControl := GetParentBarForBar(Self); if ParentBarControl <> nil then Message.Result := SendMessage(ParentBarControl.Handle, WM_KEYDOWN, VK_RIGHT, 0); end; VK_RETURN: if SelectedControl <> nil then SelectedControl.Click(False); end; end; finally cxRemoveObjectLink(ALinkSelf); end; end; procedure TdxBarSubMenuControl.WMLButtonDown(var Message: TWMLButtonDown); begin if FScrollTimerId <> 0 then Exit; inherited; if not BarControlExists(Self) then Exit; if FIgnoreMouseClick then Exit; TerminateAnimation; if DetachCaptionSelected then DoDetachMenu else if MarkExists and MouseOnMark then if MarkState = msNone then begin SetKeySelectedItem(nil); MarkState := msSelected; end else begin FIgnoreMouseClick := True; MarkState := msPressed; end; end; procedure TdxBarSubMenuControl.WMNCCalcSize(var Message: TWMNCCalcSize); begin inherited; with Message.CalcSize_Params^ do rgrc[0] := cxRectContent(rgrc[0], GetClientOffset); end; procedure TdxBarSubMenuControl.WMNCHitTest(var Message: TWMNCHitTest); var ADetachCaptionRect: TRect; begin if Detachable then begin ADetachCaptionRect := cxRectOffset(DetachCaptionRect, Left, Top); if PtInRect(ADetachCaptionRect, SmallPointToPoint(Message.Pos)) then Message.Result := HTCLIENT else inherited; end else inherited; end; procedure TdxBarSubMenuControl.WMNCPaint(var Message: TWMNCPaint); var DC: HDC; begin inherited; DC := GetWindowDC(Handle); NCPaint(DC); ReleaseDC(Handle, DC); end; procedure TdxBarSubMenuControl.WMPrint(var Message: TMessage); begin inherited; NCPaint(Message.WParam); end; procedure TdxBarSubMenuControl.WMPrintClient(var Message: TMessage); begin inherited; PaintWindow(Message.WParam); end; procedure TdxBarSubMenuControl.WMRButtonDown(var Message: TWMRButtonUp); begin inherited; if IsContextMenu then with TMessage(Message) do SendMessage(Handle, WM_LBUTTONDOWN, WParam, LParam); end; procedure TdxBarSubMenuControl.WMRButtonUp(var Message: TWMRButtonUp); begin inherited; if IsContextMenu then with TMessage(Message) do SendMessage(Handle, WM_LBUTTONUP, WParam, LParam); end; procedure TdxBarSubMenuControl.WMTimer(var Message: TWMTimer); procedure EndScrollingSubMenu; var P: TPoint; begin KillScrollTimer; FLastMousePos := cxInvalidPoint; P := GetMouseCursorPos; if BarManager.Dragging then begin Windows.ScreenToClient(BarManager.Owner.Handle, P); //#DG PostMessage(BarManager.Owner.Handle, WM_MOUSEMOVE, 0, MakeLParam(P.X, P.Y)); //#DG end else begin Windows.ScreenToClient(Handle, P); SendMessage(Handle, WM_MOUSEMOVE, 0, MakeLParam(P.X, P.Y)); end; end; begin if UpArrowExists and MouseOnUpArrow then TopIndex := TopIndex - 1 else if DownArrowExists and MouseOnDownArrow then TopIndex := TopIndex + 1 else EndScrollingSubMenu; end; procedure TdxBarSubMenuControl.CMFontChanged(var Message: TMessage); begin inherited; Canvas.Font := Font; CalcDrawingConsts; end; procedure TdxBarSubMenuControl.AdjustHintWindowPosition(var APos: TPoint; const ABoundsRect: TRect; AHeight: Integer); begin APos.Y := ABoundsRect.Bottom + HintOffset; if GetDesktopWorkArea(APos).Bottom - APos.Y < AHeight then APos.Y := ABoundsRect.Top - AHeight - HintOffset; end; procedure TdxBarSubMenuControl.CreateParams(var Params: TCreateParams); begin inherited CreateParams(Params); with Params do begin Style := WS_CLIPCHILDREN or WS_CLIPSIBLINGS or WS_POPUP; ExStyle := ExStyle or WS_EX_TOPMOST; WindowClass.Style := CS_DBLCLKS or CS_HREDRAW or CS_VREDRAW or CS_OWNDC or CS_SAVEBITS; if ParentWnd > 0 then WndParent := ParentWnd else WndParent := BarManager.Owner.Handle; end; end; procedure TdxBarSubMenuControl.CreateWnd; var AChangeXDirection, AChangeYDirection: Boolean; AAnimationInfo: TdxBarAnimationInfo; begin //ProcessPaintMessages; - destroys submenu because of PeekMessage CreateLightBrush; inherited CreateWnd; FOnShowLeft := Left; FOnShowTop := Top; IsActive := True; SetRecentItemCount; FTopIndex := -1; TopIndex := 0; SetSizeAndCheckBounds(AChangeXDirection, AChangeYDirection); // PlaySound(psMenuPopup); if FShowAnimation then with AAnimationInfo do begin RealLeft := Left; RealTop := Top; RealClientWidth := ClientWidth; RealClientHeight := ClientHeight; BorderWidth := Width - ClientWidth; BorderHeight := Height - ClientHeight; LeftDirection := ((FXDirection = xdLeft) and not AChangeXDirection) or ((FXDirection = xdRight) and AChangeXDirection); TopDirection := ((FYDirection = ydTop) and not AChangeYDirection) or ((FYDirection = ydBottom) and AChangeYDirection); AnimationType := FMenuAnimations; case AnimationType of maUnfold: begin FirstValue := ClientHeight - ClientWidth; if FirstValue > 0 then begin OldClientRect := Rect(0, 0, 0, FirstValue); Delta := ClientWidth; end else begin OldClientRect := Rect(0, 0, -FirstValue, 0); Delta := ClientHeight; end; Step := 8; end; maSlide: begin FirstValue := 0; OldClientRect := Rect(0, 0, ClientWidth, 0); Delta := ClientHeight; Step := 17; end; else begin FirstValue := 0; Delta := 128; Step := 1; end; end; AnimationMenu := Self; FAnimationThread := TdxBarAnimationThread.Create(AAnimationInfo); FAnimationThread.OnTerminate := OnTerminateAnimation; FAnimationThread.Resume; end; PlaySound(psMenuPopup); end; procedure TdxBarSubMenuControl.DestroyWindowHandle; begin if BarManager.Dragging and (BarManager.DraggingItemLink <> nil) and (ItemLinks.IndexOf(BarManager.DraggingItemLink) > -1) and (BarManager.DragInfo.DraggingItemLinkParentHandle = 0) then begin BarManager.DragInfo.DraggingItemLinkParentHandle := WindowHandle; Perform(WM_DESTROY, 0, 0); SetWindowLong(WindowHandle, GWL_WNDPROC, Longint(DefWndProc)); ShowWindow(WindowHandle, SW_HIDE); DestroyControls; WindowHandle := 0; end else inherited; end; procedure TdxBarSubMenuControl.DestroyWnd; begin if not HandleAllocated or (bsDestroyingWindow in FState) then Exit; Include(FState, bsDestroyingWindow); try TerminateAnimation; KillScrollTimer; KillExpandMenuTimer; //#DG if (ChildBar <> nil) and not ChildBar.FDestroyFlag and if ChildBar <> nil then ChildBar.DestroyWnd; if not FExpandingMenu then IsActive := False; inherited DestroyWnd; // ProcessPaintMessages; DoCloseUp; DestroyLightBrush; finally Exclude(FState, bsDestroyingWindow); end; end; procedure TdxBarSubMenuControl.DoCloseUp; begin CallNotify(FOnCloseUp, Self); end; procedure TdxBarSubMenuControl.DoPopup; begin CallNotify(FOnPopup, Self); end; procedure TdxBarSubMenuControl.Paint; begin if IsAnimationRunning or IsDestroying then Exit; SelectClipRgn(Canvas.Handle, 0); // because of CS_OWNDC Painter.SubMenuControlDrawClientBorder(Self, Canvas.Handle, ClientRect, ToolbarBrush); try DrawContent; finally DrawBar; end; end; procedure TdxBarSubMenuControl.NCPaint(DC: HDC); begin DoNCPaint(DC, NCRect); end; procedure TdxBarSubMenuControl.CalcControlsPositions; begin inherited; CalcItemRects(ptMenu, TopIndex); CalcLayout; end; procedure TdxBarSubMenuControl.CalcDrawingConsts; begin inherited CalcDrawingConsts; Painter.SubMenuControlCalcDrawingConsts(Canvas, FTextSize, FMenuArrowWidth, FMarkSize); end; procedure TdxBarSubMenuControl.CalcDragOverParameters(const ACursorPos: TPoint; out ADragOverItemLink: TdxBarItemLink; out AIsBeginGroup, AIsFirstPart, AIsVerticalDirection: Boolean); begin if not (UpArrowExists and MouseOnUpArrow or DownArrowExists and MouseOnDownArrow or MarkExists and MouseOnMark) then inherited CalcDragOverParameters(ACursorPos, ADragOverItemLink, AIsBeginGroup, AIsFirstPart, AIsVerticalDirection); end; procedure TdxBarSubMenuControl.CalcItemsRect; var AOffset: TRect; begin AOffset := GetItemsRectOffset; FItemsRect := Rect( AOffset.Left, AOffset.Top, ClientWidth - AOffset.Right, ClientHeight - AOffset.Bottom - MarkSize * Byte(MarkExists)); end; function TdxBarSubMenuControl.CanActiveChange: Boolean; begin Result := True; end; function TdxBarSubMenuControl.CanCustomizing: Boolean; begin Result := inherited CanCustomizing or (ItemLinks.Owner is TdxBarSubItem) and TdxBarSubItem(ItemLinks.Owner).AllowCustomizing or (ItemLinks.Owner is TdxBarCustomPopupMenu); end; function TdxBarSubMenuControl.CanDrawClippedItem(AItemRect: TRect): Boolean; begin Result := UseScrollButtons and (AItemRect.Top < Painter.SubMenuControlGetScrollBandBounds(Self, adDown).Top); end; function TdxBarSubMenuControl.CanShowHint: Boolean; begin Result := bboAllowShowHints in BehaviorOptions; end; function TdxBarSubMenuControl.CheckLockUpdate: Boolean; begin Result := inherited CheckLockUpdate; if Result and ((BarManager.FChangedSubMenuControl = nil) or IsChildBar(BarManager.FChangedSubMenuControl)) then BarManager.FChangedSubMenuControl := Self; end; function TdxBarSubMenuControl.ChildrenHaveShadows: Boolean; begin Result := False; end; procedure TdxBarSubMenuControl.CorrectVisibleItemsRectBottom; begin if UseScrollButtons and DownArrowExists then Dec(FVisibleItemsRect.Bottom, Painter.SubMenuControlGetScrollBandSize(Self)); end; procedure TdxBarSubMenuControl.CorrectVisibleItemsRectTop; begin if UseScrollButtons and UpArrowExists then Inc(FVisibleItemsRect.Top, Painter.SubMenuControlGetScrollBandSize(Self)); end; procedure TdxBarSubMenuControl.DoCreateControls; begin if not IsCustomizing then ExpandContainerItems; inherited DoCreateControls; end; procedure TdxBarSubMenuControl.DoDestroyControls; begin inherited DoDestroyControls; if not IsCustomizing then CollapseContainerItems; end; procedure TdxBarSubMenuControl.DoBarMouseLeave; begin DetachCaptionSelected := False; if UpArrowExists or DownArrowExists then DrawScrollArea; inherited; end; procedure TdxBarSubMenuControl.DoBarMouseMove(Shift: TShiftState; const APoint: TPoint; AItemControl: TdxBarItemControl); begin if not NotHandleMouseMove then begin TerminateAnimation; if not BarControlExists(Self) then Exit; end else if IsAnimationRunning then Exit; if WantMouse and (FSubItem <> nil) and (ParentBar <> nil) then ParentBar.SetMouseSelectedItem(FSubItem); if Detachable then DetachCaptionSelected := MouseOnDetachCaption; if MarkExists then if MouseOnMark then MarkState := msSelected else MarkState := msNone; if UpArrowExists and MouseOnUpArrow or DownArrowExists and MouseOnDownArrow then begin if (FScrollTimerId = 0) and not cxPointIsEqual(FLastMousePos, ClientToScreen(APoint)) then begin //#DG if SelectedControl = BarManager.SelectedItem then BarManager.FSelectedItem := nil; // otherwise BarManager will hide all SetKeySelectedItem(nil); FScrollTimerId := SetTimer(Handle, 1, GetScrollTime, nil); end; end else begin if (FScrollTimerId <> 0) and dxKillTimer(Handle, FScrollTimerId) then begin FLastMousePos := cxInvalidPoint; DrawScrollArea; end; inherited; end; end; procedure TdxBarSubMenuControl.DoNCPaint(DC: HDC; const ARect: TRect); begin Painter.SubMenuControlDrawBorder(Self, DC, ARect); end; procedure TdxBarSubMenuControl.DoHideAll; begin if ParentBar = nil then begin ChildBar := nil; Hide; ProcessPaintMessages; end else inherited; end; procedure TdxBarSubMenuControl.DoPaintItem(AControl: TdxBarItemControl; ACanvas: TcxCanvas; const AItemRect: TRect); var ASeparatorIndex: Integer; ANonRecent: Boolean; begin if IsRectEmpty(AItemRect) then Exit; ANonRecent := not Painter.IgnoreNonRecentColor and AControl.FNonRecent; if ANonRecent then begin PreparePalette(ACanvas.Handle); FBkBrush := FLightBrush; end else Painter.SubMenuControlPrepareBkBrush(Self, FBkBrush); if ViewInfo.IsAssociatedWithSeparator(AControl, ASeparatorIndex) then Painter.SubMenuControlDrawBeginGroup(Self, AControl, ACanvas, ViewInfo.SeparatorInfos[ASeparatorIndex].Bounds); Painter.SubMenuControlDrawItemFrame(Self, AControl, ACanvas.Handle, AItemRect, AControl.ItemLink.VisibleIndex); inherited DoPaintItem(AControl, ACanvas, AItemRect); if ANonRecent then UnpreparePalette(ACanvas.Handle); end; procedure TdxBarSubMenuControl.DoRepaintBar(ARecreateControls: Boolean); var AWasVisible, AChangeXDirection, AChangeYDirection, NeedRepaint: Boolean; PrevTopIndex: Integer; begin AWasVisible := IsWindowVisible(Handle); inherited DoRepaintBar(ARecreateControls); SetRecentItemCount; if (Left <> FOnShowLeft) or (Top <> FOnShowTop) then begin ShowWindow(Handle, SW_HIDE); Left := FOnShowLeft; Top := FOnShowTop; NeedRepaint := False; end else NeedRepaint := True; SetSizeAndCheckBounds(AChangeXDirection, AChangeYDirection); CalcControlsPositions; if UpArrowExists and not DownArrowExists then begin PrevTopIndex := FTopIndex; repeat Dec(FTopIndex); CalcControlsPositions; until DownArrowExists or (FTopIndex = 0); if DownArrowExists then Inc(FTopIndex); NeedRepaint := NeedRepaint or (FTopIndex <> PrevTopIndex); end; if AWasVisible then Show; if NeedRepaint then begin CalcControlsPositions; Invalidate; end; end; procedure TdxBarSubMenuControl.DoSetIsActive(AValue: Boolean); begin inherited; if not BarControlExists(Self) then Exit; if IsActive and BarManager.ShowRecentItemsFirst and not ShowFullMenus and BarManager.ShowFullMenusAfterDelay then SetExpandMenuTimer(dxBarSlowExpandMenuTime, True); end; procedure TdxBarSubMenuControl.DragOver(X, Y: Integer; var Accept: Boolean); begin SendMessage(Handle, WM_MOUSEMOVE, 0, MakeLParam(X, Y)); if FScrollTimerID > 0 then Accept := False; end; function TdxBarSubMenuControl.GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; begin Result := TdxBarSubMenuControlAccessibilityHelper; end; function TdxBarSubMenuControl.GetBeginGroupSize: Integer; begin Result := Painter.SubMenuControlBeginGroupSize; end; function TdxBarSubMenuControl.GetBehaviorOptions: TdxBarBehaviorOptions; begin Result := inherited GetBehaviorOptions + [bboAllowSelectWindowItemsWithoutFocusing, bboExtendItemWhenAlignedToClient] - [bboMouseCantUnselectNavigationItem]; end; function TdxBarSubMenuControl.GetBottomItemControl: TdxBarItemControl; begin Result := ItemLinks.VisibleItems[TopIndex + Max(MaxVisibleCount, 1) - 1].Control; end; function TdxBarSubMenuControl.GetDefaultItemHeight(AItem: TdxBarItemControl): Integer; var AItemHeight: Integer; begin AItemHeight := inherited GetDefaultItemHeight(AItem); case AItem.MenuItemSize of misNormal: Result := AItemHeight; else {misLarge} if ItemLinks.ItemShowDescriptions then Result := Trunc(AItemHeight * 2.5) // Result := Round(AItemHeight * 2.35) else Result := AItemHeight * 2; end; end; function TdxBarSubMenuControl.GetEditFont: TFont; begin if ParentBar = nil then if (ItemLinks.Owner is TdxBarCustomPopupMenu) and TdxBarCustomPopupMenu(ItemLinks.Owner).UseOwnFont then Result := TdxBarCustomPopupMenu(ItemLinks.Owner).FEditFont else Result := inherited GetEditFont else Result := ParentBar.GetEditFont; end; function TdxBarSubMenuControl.GetIsContextMenu: Boolean; begin Result := (OwnerWidth = 0) and (OwnerHeight = 0) or (ParentBar is TdxBarSubMenuControl) and TdxBarSubMenuControl(ParentBar).IsContextMenu; end; function TdxBarSubMenuControl.GetIsCustomizing: Boolean; begin if IsInternal or (GetItemByControl(FSubItem) is TdxBarSubItem) and TdxBarSubItem(GetItemByControl(FSubItem)).IsInternal then Result := False else Result := inherited GetIsCustomizing; end; function TdxBarSubMenuControl.GetIsMainMenu: Boolean; begin Result := False; end; function TdxBarSubMenuControl.GetIsShadowVisible: Boolean; begin Result := inherited GetIsShadowVisible and not FShowAnimation; end; function TdxBarSubMenuControl.GetItemControlOffset(AItemLink: TdxBarItemLink): Integer; begin Result := 0; if AItemLink.Control.FChangeRecentGroup and Painter.SubMenuControlIsOffsetRecentGroupNeeded then Inc(Result); if AItemLink.BeginGroup and not ((AItemLink.VisibleIndex = TopIndex) or UpArrowExists and (AItemLink.VisibleIndex = TopIndex + 1)) then Inc(Result, BeginGroupSize); end; function TdxBarSubMenuControl.GetItemRectEx(Item: TdxBarItemControl; IsBeginGroup: Boolean): TRect; var AIndex: Integer; begin Result := inherited GetItemRectEx(Item, IsBeginGroup); if Item <> nil then begin if Item.FChangeRecentGroup and Painter.SubMenuControlIsOffsetRecentGroupNeeded then Dec(Result.Top); if IsBeginGroup and Item.ItemLink.BeginGroup then begin AIndex := Item.ItemLink.VisibleIndex; if (AIndex > TopIndex) and not (UpArrowExists and (AIndex = TopIndex + 1)) then Dec(Result.Top, BeginGroupSize); end; end; end; function TdxBarSubMenuControl.GetPaintType: TdxBarPaintType; begin Result := ptMenu; end; function TdxBarSubMenuControl.GetSelectableObject: TPersistent; begin if (ParentBar <> nil) and (ParentBar.SelectedControl <> nil) then Result := ParentBar.SelectedControl.ItemLink else Result := ItemLinks.Owner; end; function TdxBarSubMenuControl.GetTextSize: Integer; begin Result := Painter.SubMenuControlTextSize(Canvas); end; function TdxBarSubMenuControl.GetTopItemControl: TdxBarItemControl; begin Result := ItemLinks.VisibleItems[TopIndex].Control; end; function TdxBarSubMenuControl.GetViewInfoClass: TCustomdxBarControlViewInfoClass; begin Result := TdxBarSubMenuControlViewInfo; end; procedure TdxBarSubMenuControl.HideByEscape; begin ClosedByEscape := True; Hide; end; function TdxBarSubMenuControl.HideOnClick: Boolean; begin Result := True; end; function TdxBarSubMenuControl.IsInternal: Boolean; begin Result := (ParentBar <> nil) and (ParentBar.IsInternal); //#DG end; function TdxBarSubMenuControl.IsMeaningParent(AWnd: HWND): Boolean; begin Result := (FOwnerControl <> nil) and (FOwnerControl.HandleAllocated) and (AWnd = FOwnerControl.Handle); end; function TdxBarSubMenuControl.IsPopup: Boolean; begin Result := True; end; function TdxBarSubMenuControl.IsVerticalDirection: Boolean; begin Result := True; end; procedure TdxBarSubMenuControl.SetFont; begin if ParentBar = nil then if ItemLinks.Owner is TdxBarCustomPopupMenu then Font := TdxBarCustomPopupMenu(ItemLinks.Owner).Font else Font := BarManager.Font else Font := ParentBar.Font; end; procedure TdxBarSubMenuControl.SetRecentItemCount; begin with ItemLinks do if BarManager.ShowRecentItemsFirst and not ShowFullMenus then RecentItemCount := MostRecentItemCount else RecentItemCount := -1; end; procedure TdxBarSubMenuControl.SetAccelSelectedItem(AItemControl: TdxBarItemControl; ADuplicate: Boolean); var AHidden: Boolean; begin AHidden := AItemControl.ItemLink.VisibleIndex = -1; if (BarManager.GetPaintStyle <> bmsStandard) and AHidden and (ADuplicate or not AItemControl.IsDestroyOnClick) then MarkState := msPressed; inherited; end; procedure TdxBarSubMenuControl.SetControlVisible(AControl: TdxBarItemControl); function ScrollNeeded(AScrollDirection: TcxArrowDirection): Boolean; var AIndex: Integer; begin AIndex := AControl.ItemLink.VisibleIndex; case AScrollDirection of adUp: Result := (AIndex < TopVisibleItemIndex) or (not IsRectEmpty(AControl.ItemBounds) and (AControl.ItemBounds.Top < VisibleItemsRect.Top)); else {adDown} Result := (AIndex > BottomVisibleItemIndex) or (not IsRectEmpty(AControl.ItemBounds) and (AControl.ItemBounds.Bottom > VisibleItemsRect.Bottom)); end; end; procedure Scroll(AScrollDirection: TcxArrowDirection); const AStep: array [TcxArrowDirection] of Integer = (-1, 1, 0, 0); begin repeat FTopIndex := Max(FTopIndex + AStep[AScrollDirection], 0); CalcControlsPositions; until not ScrollNeeded(AScrollDirection); InvalidateItemsRect; end; begin if UpArrowExists and ScrollNeeded(adUp) then Scroll(adUp) else if DownArrowExists and ScrollNeeded(adDown) then Scroll(adDown); end; procedure TdxBarSubMenuControl.SetSelectedControl(Value: TdxBarItemControl); begin if MarkState = msNone then begin KillExpandMenuTimer; if IsActive and BarManager.ShowRecentItemsFirst and not ShowFullMenus and BarManager.ShowFullMenusAfterDelay then SetExpandMenuTimer(dxBarSlowExpandMenuTime, False); end; if (Value <> nil) and not Value.FSelectedByMouse then SetControlVisible(Value); inherited SetSelectedControl(Value); end; procedure TdxBarSubMenuControl.SetSizeAndCheckBounds(out AChangeXDirection, AChangeYDirection: Boolean); var ASize: TSize; AWorkArea, ABounds: TRect; begin if (ParentBar = nil) or not ParentBar.CalcChildBarBounds(ABounds) then begin CalcBounds(ASize); AWorkArea := GetWorkArea(Point(Left, Top)); AChangeXDirection := False; AChangeYDirection := False; if Left + ASize.cx > AWorkArea.Right then if OwnerWidth = 0 then if (OwnerHeight = 0) and (Left - ASize.cx >= AWorkArea.Left) then begin Left := Left - ASize.cx; // for popupmenu AChangeXDirection := True; end else Left := AWorkArea.Right - ASize.cx else if Left - OwnerWidth - AWorkArea.Left > AWorkArea.Right - Left then begin Left := Left - OwnerWidth - ASize.cx; AChangeXDirection := True; end; if Left < AWorkArea.Left then if OwnerWidth = 0 then Left := AWorkArea.Left else if (FXDirection = xdLeft) and (AWorkArea.Right - (Left + ASize.cx + OwnerWidth) > Left + ASize.cx - AWorkArea.Left) then begin Left := Left + ASize.cx + OwnerWidth; AChangeXDirection := True; end; if Left + ASize.cx > AWorkArea.Right then Left := AWorkArea.Right - ASize.cx; if Left < AWorkArea.Left then Left := AWorkArea.Left; if Top + ASize.cy > AWorkArea.Bottom then if OwnerHeight = 0 then if (OwnerWidth = 0) and (Top - ASize.cy >= AWorkArea.Top) then // for popupmenu begin Top := Top - ASize.cy; AChangeYDirection := True; end else Top := AWorkArea.Bottom - ASize.cy else if Top - OwnerHeight - AWorkArea.Top > AWorkArea.Bottom - Top then begin Top := Top - OwnerHeight - ASize.cy; AChangeYDirection := True; end else ASize.cy := AWorkArea.Bottom - Top; if Top < AWorkArea.Top then if FYDirection = ydBottom then if AChangeYDirection and (OwnerHeight <> 0) then begin ASize.cy := ASize.cy - (AWorkArea.Top - Top); Top := AWorkArea.Top; end else begin Top := AWorkArea.Top; if Top + ASize.cy > AWorkArea.Bottom then ASize.cy := AWorkArea.Bottom - Top; end else if (OwnerHeight <> 0) and (AWorkArea.Bottom - (Top + ASize.cy + OwnerHeight) > Top + ASize.cy - AWorkArea.Top) then begin Top := Top + ASize.cy + OwnerHeight; if Top + ASize.cy > AWorkArea.Bottom then ASize.cy := AWorkArea.Bottom - Top; AChangeYDirection := True; end; ABounds := cxRectBounds(Left, Top, ASize.cx, ASize.cy); end; SetBounds(ABounds.Left, ABounds.Top, cxRectWidth(ABounds), cxRectHeight(ABounds)); end; procedure TdxBarSubMenuControl.ShowPopup(AItem: TdxBarItemControl); begin if not BarManager.IsCustomizing and (GetLinkByControl(AItem) <> nil) then BarDesignController.ShowCustomCustomizePopup(BarManager, InitCustomizationPopup, Painter, Self, GetLinkByControl(AItem)) else if (ItemLinks.Count = 0) and (ParentBar <> nil) then DoShowPopup(ParentBar.SelectedControlAtDesign) else inherited; end; procedure TdxBarSubMenuControl.TerminateAnimation; begin if FAnimationThread <> nil then TdxBarAnimationThread(FAnimationThread).TerminateAnimation; end; procedure TdxBarSubMenuControl.UpdateItem(AControl: TdxBarItemControl); begin PaintItem(AControl); end; procedure TdxBarSubMenuControl.InitCustomizationPopup(AItemLinks: TdxBarItemLinks); begin if ParentBar <> nil then ParentBar.InitCustomizationPopup(AItemLinks); end; function TdxBarSubMenuControl.CanDetach: Boolean; begin Result := Detachable and (FSubItem.Item.GetDetachingBar <> nil) and ((GetParentBarForBar(FSubItem.Parent) = nil) or (GetParentBarForBar(FSubItem.Parent) <> FSubItem.Item.GetDetachingBar.Control)); end; function TdxBarSubMenuControl.Detachable: Boolean; begin Result := (bboAllowDetach in BehaviorOptions) and (FSubItem <> nil) and FSubItem.Item.Detachable; end; function TdxBarSubMenuControl.DetachCaptionAreaSize: Integer; begin Result := Painter.SubMenuControlDetachCaptionAreaSize(Self); end; function TdxBarSubMenuControl.DetachCaptionRect: TRect; begin Result := NCRect; Painter.SubMenuControlOffsetDetachCaptionRect(Self, Result); with Result do Bottom := Top + DetachCaptionSize; end; function TdxBarSubMenuControl.MouseOnDetachCaption: Boolean; begin Result := PtInRect(DetachCaptionRect, cxPointOffset(GetMouseCursorPos, -Left, -Top)); end; procedure TdxBarSubMenuControl.DoDetachMenu; var ADetachingBar: TdxBar; ASubItem: TdxBarSubItemControl; NonDetachableArea: TRect; Success, Started: Boolean; PrevP, P: TPoint; CaptureWnd: HWND; Msg: TMsg; ABarCaptionAriaSize: Integer; begin FSubItem.Item.DoDetaching; if not CanDetach then Exit; ADetachingBar := FSubItem.Item.GetDetachingBar; ASubItem := FSubItem; NonDetachableArea := DetachCaptionRect; OffsetRect(NonDetachableArea, Left, Top); InflateRect(NonDetachableArea, DetachAreaDelta, DetachAreaDelta); Success := False; Started := False; PrevP := GetMouseCursorPos; ABarCaptionAriaSize := Painter.BarCaptionAreaSize; Include(BarDesignController.FDesignStates, dsKeyAlreadyProcessed); CaptureWnd := ParentBar.Handle; SetCapture(CaptureWnd); try while GetCapture = CaptureWnd do begin case Integer(GetMessage(Msg, 0, 0, 0)) of -1: Break; 0: begin PostQuitMessage(Msg.wParam); Break; end; end; case Msg.message of WM_KEYDOWN, WM_KEYUP: if Msg.wParam = VK_ESCAPE then begin ASubItem.ControlActivate(True); Break; end; WM_MOUSEMOVE: begin P := SmallPointToPoint(TSmallPoint(Msg.lParam)); Windows.ClientToScreen(Msg.hwnd, P); if (P.X <> PrevP.X) or (P.Y <> PrevP.Y) then begin if not Started and not PtInRect(NonDetachableArea, P) then begin ASubItem.ControlInactivate(True); if ADetachingBar.DockingStyle <> dsNone then begin ADetachingBar.Visible := False; ADetachingBar.DockingStyle := dsNone; end; if not ADetachingBar.Visible then begin ADetachingBar.FloatLeft := P.X - 100; ADetachingBar.FloatTop := P.Y - ABarCaptionAriaSize div 2; ADetachingBar.Visible := True; end; Started := True; end; if Started then if PtInRect(NonDetachableArea, P) then begin ADetachingBar.Visible := False; ASubItem.ControlActivate(True); Break; end else with ADetachingBar.Control do SetWindowPos(Handle, 0, P.X - Width div 2, P.Y - Painter.BarCaptionAreaSize div 2, 0, 0, SWP_NOZORDER or SWP_NOSIZE or SWP_NOACTIVATE); PrevP := P; end; end; WM_LBUTTONUP: begin Success := True; Break; end; else TranslateMessage(Msg); DispatchMessage(Msg); end; end; finally if GetCapture = CaptureWnd then ReleaseCapture; if Started then if Success then ADetachingBar.BarManager.HideAll else ADetachingBar.Visible := False; Exclude(BarDesignController.FDesignStates, dsKeyAlreadyProcessed); end; end; function TdxBarSubMenuControl.MarkArrowSize: Integer; begin Result := Painter.SubMenuControlMarkArrowSize(FMarkSize); end; function TdxBarSubMenuControl.MarkExists: Boolean; begin Result := BarManager.ShowRecentItemsFirst and (ItemLinks.VisibleItemCount < ItemLinks.CanVisibleItemCount); end; function TdxBarSubMenuControl.MarkRect: TRect; var AOffset: Integer; begin Result := ClientRect; AOffset := Painter.SubMenuControlMarkRectOffset(Self); with Result do begin Inc(Left, AOffset + BarSize); Dec(Right, AOffset); Dec(Bottom, AOffset); Top := Bottom - MarkSize; end; end; procedure TdxBarSubMenuControl.SetMarkState(Value: TdxBarMarkState); begin if IsCustomizing or not BarManager.ShowRecentItemsFirst then Exit; if (Value = msSelected) and (SelectedControl is TdxBarWinControl) and TdxBarWinControl(SelectedControl).Focused then Value := msNone; if FMarkState <> Value then begin FMarkState := Value; if Value = msPressed then ExpandMenu else cxInvalidateRect(Handle, MarkRect, False); if BarManager.ShowFullMenusAfterDelay then begin KillExpandMenuTimer; if (FMarkState = msSelected) and MouseOnMark then SetExpandMenuTimer(FHintWindow.ShowHintTime, True); end else if FMarkState = msSelected then BarManager.HintActivate(True, cxGetResourceString(@dxSBAR_EXPAND), Self) else BarManager.HintActivate(False, ''); end; end; function TdxBarSubMenuControl.DownArrowExists: Boolean; begin Result := (ItemLinks.VisibleItemCount - TopIndex > MaxVisibleCount) or (ItemLinks.VisibleItemCount > 0) and (ItemLinks[ItemLinks.VisibleItemCount - 1].ItemRect.Bottom > ItemsRect.Bottom); end; function TdxBarSubMenuControl.GetScrollTime: Integer; begin if UseScrollButtons then Result := dxBarSmoothScrollMenuTime else Result := dxBarScrollMenuTime; end; function TdxBarSubMenuControl.UpArrowExists: Boolean; begin Result := TopIndex > 0; end; function TdxBarSubMenuControl.UseScrollButtons: Boolean; begin Result := Painter.SubMenuControlUseScrollButtons; end; procedure TdxBarSubMenuControl.DoCalcSize(out ASize: TSize); begin ASize := GetItemsPaneSize; end; procedure TdxBarSubMenuControl.DoCorrectSize(var ASize: TSize); procedure IncByOffset(const AOffset: TRect); begin Inc(ASize.cx, AOffset.Left + AOffset.Right); Inc(ASize.cy, AOffset.Top + AOffset.Bottom); end; begin IncByOffset(GetClientOffset); IncByOffset(GetItemsRectOffset); end; procedure TdxBarSubMenuControl.DoShow; const Shows: array[Boolean] of Integer = (0, SWP_SHOWWINDOW); begin if (FMenuAnimations = maFade) and Assigned(AnimateWindowProc) and not IsWin95Or98 then begin ProcessPaintMessages; AnimateWindowProc(Handle, 150, AW_BLEND); end else begin SetWindowPos(Handle, 0, 0, 0, 0, 0, SWP_NOZORDER or SWP_NOMOVE or SWP_NOSIZE or SWP_NOACTIVATE or Shows[not FShowAnimation]); ProcessPaintMessages; end; end; procedure TdxBarSubMenuControl.DrawBar; begin if BarManager.Designing then FillGradientRect(Canvas.Handle, BarRect, 0, clBlue, False) else if GetSubMenuOwner <> nil then GetSubMenuOwner.DoPaintBar(Canvas.Canvas, BarRect) end; procedure TdxBarSubMenuControl.DrawContent; var I: Integer; AControl: TdxBarItemControl; begin CalcControlsPositions; if ItemLinks.CanVisibleItemCount > 0 then begin DrawScrollArea; for I := 0 to ItemLinks.VisibleItemCount - 1 do begin AControl := ItemLinks.VisibleItems[I].Control; AControl.RealVisibleChanging(ViewInfo.IsItemControlVisible(AControl)); end; for I := 0 to ViewInfo.ItemControlCount - 1 do begin AControl := ViewInfo.ItemControlViewInfos[I].Control; AControl.FLastInRow := False; PaintItem(AControl); Canvas.ExcludeClipRect(AControl.ViewInfo.Bounds); end; ItemLinks.VisibleItems[BottomVisibleItemIndex].Control.FLastInRow := True; end else FillBackground(Canvas.Handle, FItemsRect, ToolbarBrush, clNone, True); end; procedure TdxBarSubMenuControl.DrawScrollArea; procedure DrawBottomAreaBackground; var R: TRect; AControl: TdxBarItemControl; begin AControl := BottomItemControl; R := GetItemRectEx(AControl, True); R.Top := R.Bottom; R.Bottom := ItemsRect.Bottom; FillBackground(Canvas.Handle, R, ToolbarItemsBrush, clNone, True); end; begin Canvas.SaveClipRegion; try if UpArrowExists then Painter.SubMenuControlDrawScrollBand(Self, Canvas, adUp); if DownArrowExists then Painter.SubMenuControlDrawScrollBand(Self, Canvas, adDown); if MarkExists then Painter.SubMenuControlDrawMarkBand(Self, MarkRect, MarkDrawState = msSelected); DrawBottomAreaBackground; finally Canvas.RestoreClipRegion; end; end; procedure TdxBarSubMenuControl.FillBackground(DC: HDC; const ARect: TRect; ABrush: HBRUSH; AColor: TColor; AIsClientArea: Boolean); begin BarCanvas.BeginPaint(DC); try FillBackgroundEx(BarCanvas, ARect, ABrush, AColor, AIsClientArea); finally BarCanvas.EndPaint; end; end; procedure TdxBarSubMenuControl.DoFillBackgroundEx(ACanvas: TcxCanvas; const ARect: TRect; ABrush: HBRUSH; AColor: TColor; AIsClientArea: Boolean); begin Painter.SubMenuControlDrawBackground(Self, ACanvas, ARect, ABrush, AColor); end; procedure TdxBarSubMenuControl.FillBackgroundEx(ACanvas: TcxCanvas; const ARect: TRect; ABrush: HBRUSH; AColor: TColor; AIsClientArea: Boolean); begin ACanvas.SaveClipRegion; try ACanvas.SetClipRegion(TcxRegion.Create(ARect), roIntersect); DoFillBackgroundEx(ACanvas, ARect, ABrush, AColor, AIsClientArea); finally ACanvas.RestoreClipRegion; end; end; function TdxBarSubMenuControl.GetBackgroundBitmap: TBitmap; begin Result := BarManager.Backgrounds.SubMenu; if (ItemLinks.Owner is TdxBarCustomPopupMenu) and not TdxBarCustomPopupMenu(ItemLinks.Owner).BackgroundBitmap.Empty then Result := TdxBarCustomPopupMenu(ItemLinks.Owner).BackgroundBitmap; end; function TdxBarSubMenuControl.GetClientOffset: TRect; var AOffset: Integer; begin AOffset := Painter.SubMenuControlNCBorderSize; Result := Rect(AOffset, AOffset, AOffset, AOffset); if Detachable then Result.Top := Result.Top + DetachCaptionAreaSize; end; function TdxBarSubMenuControl.GetIndent1: Integer; begin // WARNING: sync with TdxBarButtonControl.GetDefaultHeight Result := Painter.SubMenuControlGetControlContentIndent(Self); end; function TdxBarSubMenuControl.GetIndent2: Integer; begin // WARNING: sync with TdxBarButtonControl.GetDefaultHeight if NeedShowGlyphAndCheckForItem then begin Result := TextSize; Painter.CorrectButtonControlDefaultHeight(Result); end else Result := 0; end; function TdxBarSubMenuControl.GetItemsRectOffset: TRect; begin Result := Painter.SubMenuControlContentRectOffset(Self); Result.Left := Result.Left + BarSize; end; function TdxBarSubMenuControl.IsTransparent: Boolean; begin Result := (ItemLinks.Owner is TdxBarCustomPopupMenu) and not TdxBarCustomPopupMenu(ItemLinks.Owner).BackgroundBitmap.Empty or not BarManager.Backgrounds.SubMenu.Empty or Painter.IsCompoundPainting; end; procedure TdxBarSubMenuControl.Hide; begin if not IsDestroying then begin Include(FState, bsHideAll); //#DG Destroying; DestroyWnd; Free; end; end; function TdxBarSubMenuControl.Kind: TdxBarKind; begin Result := bkSubMenu; end; procedure TdxBarSubMenuControl.Show; var AParentBar: TCustomdxBarControl; ARandom: Double; begin ClosedByEscape := False; DoPopup; AParentBar := GetParentBarForBar(Self); if AParentBar <> nil then FMenuAnimations := AParentBar.BarManager.MenuAnimations else FMenuAnimations := BarManager.MenuAnimations; // prepare AMenuAnimations if FMenuAnimations = maRandom then begin ARandom := Random(100); if ARandom < 33 then FMenuAnimations := maUnfold else if ARandom < 66 then FMenuAnimations := maSlide else FMenuAnimations := maFade; end; FShowAnimation := FShowAnimation and not (FMenuAnimations in [maNone, maFade]) and not ((ItemLinks.CanVisibleItemCount = 0) or BarManager.IsCustomizing); DoShow; end; procedure TdxBarSubMenuControlViewInfo.Calculate; procedure CalcSeparatorInfo(AIndex: Integer); var AItemLink: TdxBarItemLink; AItemRect: TRect; begin AItemLink := BarControl.ItemLinks.VisibleItems[AIndex]; AItemRect := AItemLink.Control.ViewInfo.Bounds; if not IsRectEmpty(AItemRect) and AItemLink.BeginGroup and (AIndex > BarControl.TopIndex) and not (BarControl.UpArrowExists and (AIndex = BarControl.TopIndex + 1)) then AddSeparatorInfo(BarControl.Painter.SubMenuControlBeginGroupRect(BarControl, AItemLink.Control, AItemRect), skHorizontal, AItemLink.Control); end; var AItemLink: TdxBarItemLink; I: Integer; AVisibleItemRect: TRect; begin inherited Calculate; if BarControl.ItemLinks.CanVisibleItemCount > 0 then begin for I := BarControl.TopVisibleItemIndex to BarControl.BottomVisibleItemIndex do begin AItemLink := BarControl.ItemLinks.VisibleItems[I]; AddItemControlViewInfo(AItemLink.Control.ViewInfo); AVisibleItemRect := BarControl.GetItemRect(AItemLink.Control); AVisibleItemRect.Bottom := Min(BarControl.VisibleItemsRect.Bottom, AVisibleItemRect.Bottom); IdxBarItemControlViewInfo(AItemLink.Control.ViewInfo).SetBounds(AVisibleItemRect); CalcSeparatorInfo(I); end; end; end; function TdxBarSubMenuControlViewInfo.GetBarControl: TdxBarSubMenuControl; begin Result := TdxBarSubMenuControl(FBarControl); end; { TdxBarInternalSubMenuControl } constructor TdxBarInternalSubMenuControl.Create(AOwner: TComponent); begin inherited; FItemLinks := TdxBarSubMenuControlItemLinks.Create(BarManager, Self); FItemLinks.Internal := True; FItemLinks.FBarControl := Self; end; destructor TdxBarInternalSubMenuControl.Destroy; begin FreeAndNil(FItemLinks); inherited Destroy; end; function TdxBarInternalSubMenuControl.GetIsCustomizing: Boolean; begin Result := False; end; function TdxBarInternalSubMenuControl.IsInternal: Boolean; begin Result := True; end; // IdxBarLinksOwner function TdxBarInternalSubMenuControl.CanContainItem(AItem: TdxBarItem; out AErrorText: string): Boolean; begin Result := True; end; function TdxBarInternalSubMenuControl.CreateBarControl: TCustomdxBarControl; begin Result := Self; end; function TdxBarInternalSubMenuControl.GetInstance: TComponent; begin Result := Self; end; function TdxBarInternalSubMenuControl.GetItemLinks: TdxBarItemLinks; begin Result := FItemLinks; end; { TdxBarCustomizingPopup } // TODO: remove to designer constructor TdxBarCustomizingPopup.Create(AOwner: TComponent); begin inherited Create(AOwner); FShowAnimation := False; end; procedure TdxBarCustomizingPopup.DoShowCustomizingPopup; begin BarManager.DoShowCustomizingPopup(FItemLinks) end; { TdxBarItemActionLink } procedure TdxBarItemActionLink.AssignClient(AClient: TObject); begin FClient := AClient as TdxBarItem; end; function TdxBarItemActionLink.IsCaptionLinked: Boolean; begin Result := inherited IsCaptionLinked and (FClient.Caption = (Action as TCustomAction).Caption); end; function TdxBarItemActionLink.IsCheckedLinked: Boolean; begin Result := inherited IsCheckedLinked and (FClient is TdxBarButton) and (TdxBarButton(FClient).Down = (Action as TCustomAction).Checked); end; function TdxBarItemActionLink.IsEnabledLinked: Boolean; begin Result := inherited IsEnabledLinked and (FClient.Enabled = (Action as TCustomAction).Enabled); end; function TdxBarItemActionLink.IsHelpContextLinked: Boolean; begin Result := inherited IsHelpContextLinked and (FClient.HelpContext = (Action as TCustomAction).HelpContext); end; function TdxBarItemActionLink.IsHintLinked: Boolean; begin Result := inherited IsHintLinked and ((FClient.Hint = (Action as TCustomAction).Hint) or FClient.IsHintFromCaption); end; function TdxBarItemActionLink.IsImageIndexLinked: Boolean; begin Result := inherited IsImageIndexLinked and (FClient.ActionImageIndex = (Action as TCustomAction).ImageIndex); end; function TdxBarItemActionLink.IsShortCutLinked: Boolean; begin Result := inherited IsShortCutLinked and (FClient.ShortCut = (Action as TCustomAction).ShortCut); end; function TdxBarItemActionLink.IsVisibleLinked: Boolean; function GetClientVisible: TdxBarItemVisible; begin if FClient.IsLoading then Result := FClient.FLoadedVisible else Result := FClient.Visible; end; begin Result := inherited IsVisibleLinked and (GetClientVisible = VisibleTodxBarVisible((Action as TCustomAction).Visible)); end; function TdxBarItemActionLink.IsOnExecuteLinked: Boolean; begin Result := inherited IsOnExecuteLinked and (@FClient.OnClick = @Action.OnExecute); end; procedure TdxBarItemActionLink.SetCaption(const Value: string); begin if IsCaptionLinked then FClient.Caption := Value; end; procedure TdxBarItemActionLink.SetChecked(Value: Boolean); begin if IsCheckedLinked and (FClient is TdxBarButton) then TdxBarButton(FClient).Down := Value; end; procedure TdxBarItemActionLink.SetEnabled(Value: Boolean); begin if IsEnabledLinked then FClient.Enabled := Value; end; procedure TdxBarItemActionLink.SetHelpContext(Value: THelpContext); begin if IsHelpContextLinked then FClient.HelpContext := Value; end; procedure TdxBarItemActionLink.SetHint(const Value: string); begin if IsHintLinked then FClient.Hint := Value; end; procedure TdxBarItemActionLink.SetImageIndex(Value: Integer); begin if IsImageIndexLinked then FClient.ActionImageIndex := Value; end; procedure TdxBarItemActionLink.SetShortCut(Value: TShortCut); begin if IsShortCutLinked then FClient.ShortCut := Value; end; procedure TdxBarItemActionLink.SetVisible(Value: Boolean); begin if IsVisibleLinked then FClient.Visible := VisibleTodxBarVisible(Value); end; procedure TdxBarItemActionLink.SetOnExecute(Value: TNotifyEvent); begin if IsOnExecuteLinked then FClient.OnClick := Value; end; { TdxBarItemStylesData } constructor TdxBarItemStylesData.Create(AStyleCount: Integer); var I: Integer; begin inherited Create(nil); FStyleCount := AStyleCount; SetLength(FStylesData, AStyleCount); for I := 0 to AStyleCount - 1 do begin FStylesData[I].AssignedValues := []; FStylesData[I].Style := nil; end; end; destructor TdxBarItemStylesData.Destroy; var I: Integer; begin FIsDestroying := True; for I := 0 to StyleCount - 1 do Styles[I] := nil; inherited Destroy; end; procedure TdxBarItemStylesData.StyleChanged(AStyle: TcxCustomStyle); begin InternalStyleChanged(TcxStyle(AStyle)); end; procedure TdxBarItemStylesData.StyleRemoved(AStyle: TcxCustomStyle); begin InternalStyleRemoved(TcxStyle(AStyle)); end; procedure TdxBarItemStylesData.DoChange(AChangeKind: TdxBarItemStyleChangeKind); begin if IsChangeEventLocked then begin if (AChangeKind <> FChangeKind) and (FChangeKind in [sckNone, sckDrawing]) then FChangeKind := AChangeKind; end else if Assigned(FOnChange) then FOnChange(AChangeKind); end; function TdxBarItemStylesData.GetStyle(AIndex: Integer): TcxStyle; begin Result := FStylesData[AIndex].Style; end; function TdxBarItemStylesData.GetStyleReferenceCount(AStyle: TcxStyle): Integer; var I: Integer; begin Result := 0; for I := 0 to StyleCount - 1 do if Styles[I] = AStyle then Inc(Result); end; procedure TdxBarItemStylesData.InternalSetStyle(AIndex: Integer; Value: TcxStyle); begin FStylesData[AIndex].Style := Value; end; procedure TdxBarItemStylesData.InternalStyleChanged(AIndex: Integer); procedure GetFontData(AFont: TFont; out AFontData: TFontData); begin AFontData.Height := AFont.Height; {$IFDEF DELPHI9} AFontData.Orientation := AFont.Orientation; {$ENDIF} AFontData.Pitch := AFont.Pitch; AFontData.Style := AFont.Style; AFontData.Charset := AFont.Charset; AFontData.Name := AFont.Name; end; function IsFontChanged(const APrevFontData: TFontData; AFont: TFont): Boolean; begin Result := (APrevFontData.Height <> AFont.Height){$IFDEF DELPHI9} or (APrevFontData.Orientation <> AFont.Orientation){$ENDIF} or (APrevFontData.Pitch <> AFont.Pitch) or (APrevFontData.Style <> AFont.Style) or (APrevFontData.Charset <> AFont.Charset) or (APrevFontData.Name <> AFont.Name); end; var AAssignedValues1, AAssignedValues2: TcxStyleValues; AColorChanged, AFontChanged, ATextColorChanged: Boolean; AStyle: TcxStyle; begin if IsDestroying then Exit; AStyle := Styles[AIndex]; AAssignedValues1 := FStylesData[AIndex].AssignedValues; AAssignedValues2 := []; if AStyle <> nil then AAssignedValues2 := AStyle.AssignedValues; AColorChanged := not (not (svColor in AAssignedValues1) and not (svColor in AAssignedValues2)); if AColorChanged and (svColor in AAssignedValues1) and (svColor in AAssignedValues2) then AColorChanged := ColorToRGB(FStylesData[AIndex].Color) <> ColorToRGB(AStyle.Color); AFontChanged := not (not (svFont in AAssignedValues1) and not (svFont in AAssignedValues2)); if AFontChanged and (svFont in AAssignedValues1) and (svFont in AAssignedValues2) then AFontChanged := IsFontChanged(FStylesData[AIndex].FontData, AStyle.Font); ATextColorChanged := not (not (svTextColor in AAssignedValues1) and not (svTextColor in AAssignedValues2)); if ATextColorChanged and (svTextColor in AAssignedValues1) and (svTextColor in AAssignedValues2) then ATextColorChanged := ColorToRGB(FStylesData[AIndex].TextColor) <> ColorToRGB(AStyle.TextColor); FStylesData[AIndex].AssignedValues := AAssignedValues2; if svColor in AAssignedValues2 then FStylesData[AIndex].Color := AStyle.Color; if svFont in AAssignedValues2 then GetFontData(AStyle.Font, FStylesData[AIndex].FontData); if svTextColor in AAssignedValues2 then FStylesData[AIndex].TextColor := AStyle.TextColor; if AFontChanged then DoChange(sckStructure) else if AColorChanged or ATextColorChanged then DoChange(sckDrawing); end; procedure TdxBarItemStylesData.InternalStyleChanged(AStyle: TcxStyle); var I: Integer; begin LockChangeEvent(True); try for I := 0 to StyleCount - 1 do if Styles[I] = AStyle then InternalStyleChanged(I); finally LockChangeEvent(False); end; end; procedure TdxBarItemStylesData.InternalStyleRemoved(AStyle: TcxStyle); var I: Integer; begin LockChangeEvent(True); try for I := 0 to StyleCount - 1 do if Styles[I] = AStyle then Styles[I] := nil; finally LockChangeEvent(False); end; end; function TdxBarItemStylesData.IsChangeEventLocked: Boolean; begin Result := FChangeEventLockCount > 0; end; procedure TdxBarItemStylesData.LockChangeEvent(ALock: Boolean); begin if ALock then begin if FChangeEventLockCount = 0 then FChangeKind := sckNone; Inc(FChangeEventLockCount); end else begin Dec(FChangeEventLockCount); if (FChangeEventLockCount = 0) and (FChangeKind <> sckNone) then DoChange(FChangeKind); end; end; procedure TdxBarItemStylesData.SetStyle(AIndex: Integer; Value: TcxStyle); var AStyleValue: TcxStyle; begin AStyleValue := Styles[AIndex]; if Value <> AStyleValue then begin InternalSetStyle(AIndex, Value); if (AStyleValue <> nil) and (GetStyleReferenceCount(AStyleValue) = 0) then AStyleValue.RemoveListener(Self); if (Value <> nil) and (GetStyleReferenceCount(Value) = 1) then Value.AddListener(Self); InternalStyleChanged(AIndex); end; end; { TdxBarCustomScreenTipBand } constructor TdxBarCustomScreenTipBand.Create(ABandType: TdxBarScreenTipBandType); begin inherited Create; FBandType := ABandType; FGlyph := TBitmap.Create; FGlyph.Transparent := True; FTextAlign := stbtaRight; end; destructor TdxBarCustomScreenTipBand.Destroy; begin FreeAndNil(FGlyph); inherited Destroy; end; procedure TdxBarCustomScreenTipBand.Assign(Source: TPersistent); begin if Source is TdxBarScreenTipBand then begin Text := TdxBarScreenTipBand(Source).Text; TextAlign := TdxBarScreenTipBand(Source).TextAlign; Glyph := TdxBarScreenTipBand(Source).Glyph; end else inherited; end; procedure TdxBarCustomScreenTipBand.Changed; begin if Assigned(FOnChange) then FOnChange(Self); end; function TdxBarCustomScreenTipBand.IsVisible(const AHintText: string): Boolean; begin Result := (Text <> '') or not Glyph.Empty; if not Result and (BandType = stbHeader) then Result := AHintText <> ''; end; procedure TdxBarCustomScreenTipBand.SetGlyph(Value: TBitmap); begin FGlyph.Assign(Value); Changed; end; procedure TdxBarCustomScreenTipBand.SetText(const Value: string); begin if FText <> Value then begin FText := Value; Changed; end; end; procedure TdxBarCustomScreenTipBand.SetTextAlign(Value: TdxBarScreenTipBandTextAlign); begin if FTextAlign <> Value then begin FTextAlign := Value; Changed; end; end; { TdxBarScreenTipBand } constructor TdxBarScreenTipBand.Create(AScreenTip: TdxBarScreenTip; ABandType: TdxBarScreenTipBandType); begin inherited Create(ABandType); FScreenTip := AScreenTip; end; function TdxBarScreenTipBand.GetFont: TFont; begin Result := ScreenTip.Collection.Repository.GetBandFont(BandType); end; { TdxBarScreenTipFooterBand } constructor TdxBarScreenTipFooterBand.Create( ARepository: TdxBarScreenTipRepository); begin inherited Create(stbFooter); FRepository := ARepository; end; function TdxBarScreenTipFooterBand.GetFont: TFont; begin Result := Repository.GetBandFont(BandType); end; { TdxBarScreenTip } constructor TdxBarScreenTip.Create(AOwner: TComponent); var I: TdxBarScreenTipBandType; begin inherited Create(AOwner); for I := Low(TdxBarScreenTipBandType) to High(TdxBarScreenTipBandType) do FBands[I] := TdxBarScreenTipBand.Create(Self, I); end; destructor TdxBarScreenTip.Destroy; var I: TdxBarScreenTipBandType; begin for I := Low(TdxBarScreenTipBandType) to High(TdxBarScreenTipBandType) do FreeAndNil(FBands[I]); inherited Destroy; end; procedure TdxBarScreenTip.Assign(Source: TPersistent); begin if Source is TdxBarScreenTip then begin Header := TdxBarScreenTip(Source).Header; Description := TdxBarScreenTip(Source).Description; Footer := TdxBarScreenTip(Source).Footer; UseHintAsHeader := TdxBarScreenTip(Source).UseHintAsHeader; UseStandardFooter := TdxBarScreenTip(Source).UseStandardFooter; Width := TdxBarScreenTip(Source).Width; end else inherited; end; function TdxBarScreenTip.GetCollectionFromParent(AParent: TComponent): TcxComponentCollection; begin Result := (AParent as TdxBarScreenTipRepository).Items; end; function TdxBarScreenTip.GetDisplayName: string; begin Result := Format('%s - ''%s''', [Name, Header.Text]); end; function TdxBarScreenTip.GetWidth: Integer; begin Result := Width; if Result = 0 then begin if not Description.Glyph.Empty then Result := WidthToCurrentDpi(318) else Result := WidthToCurrentDpi(210); end; end; procedure TdxBarScreenTip.SetName(const Value: TComponentName); var AChangeText: Boolean; begin AChangeText := not (csLoading in ComponentState) and (Name = Header.Text) and ((Owner = nil) or not (Owner is TControl) or not (csLoading in TControl(Owner).ComponentState)); inherited SetName(Value); if AChangeText then Header.Text := Value; end; function TdxBarScreenTip.GetBandForCalculation( Index: TdxBarScreenTipBandType): TdxBarCustomScreenTipBand; begin if FUseStandardFooter and (Index = stbFooter) then Result := Collection.Repository.StandardFooter else Result := GetBand(Ord(Index)); end; function TdxBarScreenTip.GetCollection: TdxBarScreenTipCollection; begin Result := TdxBarScreenTipCollection(inherited Collection); end; function TdxBarScreenTip.GetBand(Index: Integer): TdxBarScreenTipBand; begin Result := FBands[TdxBarScreenTipBandType(Index)]; end; procedure TdxBarScreenTip.SetBand(Index: Integer; Value: TdxBarScreenTipBand); begin FBands[TdxBarScreenTipBandType(Index)].Assign(Value); end; { TdxBarScreenTipCollection } constructor TdxBarScreenTipCollection.Create(AParentComponent: TComponent; AItemClass: TcxComponentCollectionItemClass); begin inherited Create(AParentComponent, AItemClass); FRepository := TdxBarScreenTipRepository(AParentComponent); end; function TdxBarScreenTipCollection.Add: TdxBarScreenTip; begin Result := TdxBarScreenTip(inherited Add); end; procedure TdxBarScreenTipCollection.SetItemName(AItem: TcxComponentCollectionItem); begin AItem.Name := CreateUniqueName(ParentComponent.Owner, ParentComponent, AItem, 'TdxBar', ''); end; procedure TdxBarScreenTipCollection.UpdateFonts; begin //FHeaderFont.Assign(FBarManager.Font); // FDescriptionFont.Assign(FBarManager.Font); // FFooterFont.Assign(FBarManager.Font); end; function TdxBarScreenTipCollection.GetItem(Index: Integer): TdxBarScreenTip; begin Result := TdxBarScreenTip(inherited Items[Index]); end; procedure TdxBarScreenTipCollection.SetItem(Index: Integer; Value: TdxBarScreenTip); begin Items[Index].Assign(Value); end; { TdxBarScreenTipRepository } constructor TdxBarScreenTipRepository.Create(AOwner: TComponent); begin inherited Create(AOwner); CreateFonts; FStandardFooter := TdxBarScreenTipFooterBand.Create(Self); FItems := CreateScreenTips; FShowDescription := True; end; destructor TdxBarScreenTipRepository.Destroy; var I: TdxBarScreenTipBandType; begin FreeAndNil(FItems); FreeAndNil(FStandardFooter); for I := Low(TdxBarScreenTipBandType) to High(TdxBarScreenTipBandType) do FreeAndNil(FFonts[I]); FreeAndNil(FSystemFont); inherited Destroy; end; procedure TdxBarScreenTipRepository.Assign(Source: TPersistent); begin if Source is TdxBarScreenTipRepository then begin Items := TdxBarScreenTipRepository(Source).Items; StandardFooter := TdxBarScreenTipRepository(Source).StandardFooter; DescriptionFont := TdxBarScreenTipRepository(Source).DescriptionFont; FooterFont := TdxBarScreenTipRepository(Source).FooterFont; HeaderFont := TdxBarScreenTipRepository(Source).HeaderFont; FAssignedFonts := TdxBarScreenTipRepository(Source).AssignedFonts; ShowDescription := TdxBarScreenTipRepository(Source).ShowDescription; end else inherited Assign(Source); end; function TdxBarScreenTipRepository.CreateScreenTips: TdxBarScreenTipCollection; begin Result := TdxBarScreenTipCollection.Create(Self, TdxBarScreenTip); end; function TdxBarScreenTipRepository.GetBandFont(ABandType: TdxBarScreenTipBandType): TFont; begin if ABandType in AssignedFonts then begin case ABandType of stbHeader: Result := HeaderFont; stbDescription: Result := DescriptionFont; else {stbFooter} Result := FooterFont; end; end else Result := GetSystemFont(ABandType); end; procedure TdxBarScreenTipRepository.GetChildren(Proc: TGetChildProc; Root: TComponent); var I: Integer; begin for I := 0 to Items.Count - 1 do if Items[I].Owner = Root then Proc(Items[I]); end; function TdxBarScreenTipRepository.GetFont(Index: Integer): TFont; begin Result := FFonts[TdxBarScreenTipBandType(Index)]; end; function TdxBarScreenTipRepository.GetSystemFont(ABandType: TdxBarScreenTipBandType): TFont; begin Result := FSystemFont; Result.Assign(Screen.HintFont); Result.Color := dxBarScreenTipFontColor; if ABandType in [stbHeader, stbFooter] then Result.Style := Result.Style + [fsBold]; end; function TdxBarScreenTipRepository.IsFontStored(Index: Integer): Boolean; begin Result := TdxBarScreenTipBandType(Index) in AssignedFonts; end; procedure TdxBarScreenTipRepository.CreateFonts; function CreateFont(ABandType: TdxBarScreenTipBandType): TFont; begin Result := TFont.Create; Result.Assign(Screen.HintFont); Result.Color := dxBarScreenTipFontColor; if ABandType in [stbHeader, stbFooter] then Result.Style := Result.Style + [fsBold]; Result.OnChange := FontChanged; end; var I: TdxBarScreenTipBandType; begin FSystemFont := TFont.Create; for I := Low(TdxBarScreenTipBandType) to High(TdxBarScreenTipBandType) do FFonts[I] := CreateFont(I); end; procedure TdxBarScreenTipRepository.FontChanged(Sender: TObject); var I: TdxBarScreenTipBandType; begin if csLoading in ComponentState then Exit; for I := Low(TdxBarScreenTipBandType) to High(TdxBarScreenTipBandType) do if FFonts[I] = Sender then Include(FAssignedFonts, I); end; procedure TdxBarScreenTipRepository.SetFont(Index: Integer; Value: TFont); begin FFonts[TdxBarScreenTipBandType(Index)].Assign(Value); end; procedure TdxBarScreenTipRepository.SetItems(AValue: TdxBarScreenTipCollection); begin FItems.Assign(AValue); end; procedure TdxBarScreenTipRepository.SetStandardFooter(Value: TdxBarScreenTipFooterBand); begin FStandardFooter.Assign(Value); end; { TdxBarCustomHintViewInfo } constructor TdxBarCustomHintViewInfo.Create(ABarManager: TdxBarManager); begin inherited Create; FBarManager := ABarManager; end; function TdxBarCustomHintViewInfo.IsScreenTip: Boolean; begin Result := False; end; procedure TdxBarCustomHintViewInfo.SetWindowDrawParams(AWindow: TdxBarHintWindow); begin AWindow.IsScreenTipWindow := IsScreenTip; AWindow.HandleNeeded; end; { TdxBarHintViewInfo } constructor TdxBarHintViewInfo.Create(ABarManager: TdxBarManager; const AHint, AShortCut: string; const ACursorPos: TPoint); begin inherited Create(ABarManager); if AHint <> '' then FText := AHint + AShortCut; FPos := ACursorPos; end; procedure TdxBarHintViewInfo.Calculate(ACanvas: TCanvas); var ASize: TSize; begin if FText <> '' then begin ASize := CalculateMinSize(ACanvas); CorrectMinSize(ASize); BoundsRect := cxRectBounds(0, 0, ASize.cx, ASize.cy); end else BoundsRect := cxEmptyRect; end; procedure TdxBarHintViewInfo.Paint(ACanvas: TCanvas); var R: TRect; begin R := BoundsRect; DrawEdge(ACanvas.Handle, R, BDR_RAISEDOUTER, BF_RECT); DrawText(ACanvas); end; procedure TdxBarHintViewInfo.CorrectMinSize(var ASize: TSize); begin Inc(ASize.cx, 2 * (1 + 2)); Inc(ASize.cy, 2 * (1 + 2)); end; function TdxBarHintViewInfo.GetTextRect: TRect; begin Result := cxRectInflate(BoundsRect, -3, -3, -1, -1); end; procedure TdxBarHintViewInfo.DrawText(ACanvas: TCanvas); var R: TRect; begin R := GetTextRect; cxDrawText(ACanvas.Handle, FText, R, DT_LEFT or DT_NOCLIP or DT_NOPREFIX or DT_WORDBREAK); end; procedure TdxBarHintViewInfo.SetWindowDrawParams(AWindow: TdxBarHintWindow); begin inherited SetWindowDrawParams(AWindow); AWindow.Caption := FText; SetWindowFont(AWindow); AWindow.Color := Application.HintColor; end; procedure TdxBarHintViewInfo.SetWindowFont(AWindow: TdxBarHintWindow); var NonClientMetrics: TNonClientMetrics; begin if (BarManager <> nil) and not BarManager.UseSystemFont then AWindow.Canvas.Font := BarManager.Font else begin NonClientMetrics.cbSize := SizeOf(NonClientMetrics); if SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, {$IFNDEF CLR}@{$ENDIF}NonClientMetrics, 0) then AWindow.Canvas.Font.Handle := CreateFontIndirect(NonClientMetrics.lfStatusFont) else AWindow.Canvas.Font.Size := 8; end; {$IFNDEF DELPHI6} AWindow.Canvas.Font.Color := clInfoText; {$ELSE} AWindow.Canvas.Font.Color := Screen.HintFont.Color; {$ENDIF} end; function TdxBarHintViewInfo.CalculateMinSize(ACanvas: TCanvas): TSize; var R: TRect; AWidth: Integer; begin AWidth := cxRectWidth(GetWorkArea(GetMouseCursorPos)); R := Rect(0, 0, AWidth, 0); cxDrawText(ACanvas.Handle, FText, R, DT_CALCRECT or DT_LEFT or DT_NOPREFIX or DT_WORDBREAK); Result := cxSize(R.Right, R.Bottom); end; { TdxBarLikeHintScreenTipViewInfo } procedure TdxBarLikeHintScreenTipViewInfo.CorrectMinSize(var ASize: TSize); begin inherited CorrectMinSize(ASize); Inc(ASize.cx, 5); Inc(ASize.cy, 5); end; function TdxBarLikeHintScreenTipViewInfo.GetTextRect: TRect; begin Result := cxRectInflate(BoundsRect, -5, -6, -6, -5); end; function TdxBarLikeHintScreenTipViewInfo.IsScreenTip: Boolean; begin Result := True; end; constructor TdxBarLikeHintScreenTipViewInfo.Create(ABarManager: TdxBarManager; ASkin: TObject; const AHint, AShortCut: string; const ACursorPos: TPoint); begin inherited Create(ABarManager, AHint, AShortCut, ACursorPos); FSkinnedObject := ASkin; end; procedure TdxBarLikeHintScreenTipViewInfo.Paint(ACanvas: TCanvas); begin ISkin.DrawBackground(ACanvas.Handle, BoundsRect, DXBAR_SCREENTIP); DrawText(ACanvas); end; function TdxBarLikeHintScreenTipViewInfo.GetISkin: IdxSkin; begin Supports(FSkinnedObject, IdxSkin, Result); end; { TdxBarScreenTipBandViewInfo } constructor TdxBarScreenTipBandViewInfo.Create(ABand: TdxBarCustomScreenTipBand; const AHintText, AShortCut: string); begin inherited Create; FBand := ABand; FHintText := AHintText; FShortCut := AShortCut; end; procedure TdxBarScreenTipBandViewInfo.Calculate(AWidth: Integer; var ATop: Integer; AHeight: Integer); begin FTop := ATop; FWidth := AWidth; if HasText then begin FTextBounds.Top := ATop + GetVertIndent; FTextBounds.Bottom := FTextBounds.Top + FTextSize.cy; FTextBounds.Left := GetHorzIndent; if Band.TextAlign = stbtaRight then begin if HasGlyph then Inc(FTextBounds.Left, GetAvailGlyphWidth + GetHorzIndent); FTextBounds.Right := AWidth - GetHorzIndent; end else FTextBounds.Right := FTextBounds.Left + FTextSize.cx; end; if HasGlyph then begin if FBand.BandType = stbDescription then FGlyphBounds.Top := ATop + GetVertIndent else FGlyphBounds.Top := ATop + (AHeight - FGlyphSize.cy) div 2; FGlyphBounds.Bottom := FGlyphBounds.Top + FGlyphSize.cy; if Band.TextAlign = stbtaRight then begin FGlyphBounds.Left := GetHorzIndent + (GetAvailGlyphWidth - FGlyphSize.cx) div 2; FGlyphBounds.Right := FGlyphBounds.Left + FGlyphSize.cx; end else begin FGlyphBounds.Right := Width - (GetHorzIndent + (GetAvailGlyphWidth - FGlyphSize.cx) div 2); FGlyphBounds.Left := FGlyphBounds.Right - FGlyphSize.cx; end; end; end; function TdxBarScreenTipBandViewInfo.GetHeight(ACanvas: TCanvas; const AWidth: Integer): Integer; function GetTextFlags: Integer; begin Result := DT_CALCRECT or DT_LEFT or DT_NOPREFIX; if Band.BandType = stbDescription then Result := Result or DT_WORDBREAK; end; var AvailWidth: Integer; R: TRect; begin Result := 0; if not (HasGlyph or HasText) then Exit; if HasGlyph then begin AvailWidth := GetAvailGlyphWidth; if Band.Glyph.Width < AvailWidth then begin Result := Band.Glyph.Height; FGlyphSize.cx := Band.Glyph.Width; end else begin Result := Round(AvailWidth * Band.Glyph.Height / Band.Glyph.Width); FGlyphSize.cx := AvailWidth; end; FGlyphSize.cy := Result; end else FGlyphSize := cxNullSize; if HasText then begin AvailWidth := AWidth; Dec(AvailWidth, 2 * GetHorzIndent); if HasGlyph then Dec(AvailWidth, GetAvailGlyphWidth + GetHorzIndent); ACanvas.Font.Assign(Band.Font); R := cxRectBounds(0, 0, AvailWidth, 0); cxDrawText(ACanvas.Handle, GetText, R, GetTextFlags); FTextSize.cx := R.Right; FTextSize.cy := R.Bottom; end else FTextSize := cxNullSize; Result := Max(FGlyphSize.cy, FTextSize.cy); Inc(Result, 2 * GetVertIndent); end; function TdxBarScreenTipBandViewInfo.IsVisible: Boolean; begin Result := HasText or HasGlyph; end; function TdxBarScreenTipBandViewInfo.GetAvailGlyphWidth: Integer; begin if Band.BandType = stbDescription then Result := WidthToCurrentDpi(108) - GetHorzIndent else Result := WidthToCurrentDpi(16); end; function TdxBarScreenTipBandViewInfo.GetHorzIndent: Integer; begin if Band.BandType = stbDescription then Result := WidthToCurrentDpi(14) else Result := WidthToCurrentDpi(6); end; function TdxBarScreenTipBandViewInfo.GetVertIndent: Integer; begin Result := 6; if FBand.BandType = stbFooter then Inc(Result, 3); Result := WidthToCurrentDpi(Result); end; function TdxBarScreenTipBandViewInfo.GetText: string; begin Result := Band.Text; if Band.BandType = stbHeader then begin if FHintText <> '' then Result := FHintText; Result := Result + FShortCut; end; end; function TdxBarScreenTipBandViewInfo.HasGlyph: Boolean; begin Result := not FBand.FGlyph.Empty; end; function TdxBarScreenTipBandViewInfo.HasText: Boolean; begin Result := GetText <> ''; end; function TdxBarScreenTipBandViewInfo.HeightToCurrentDpi(AValue: Integer): Integer; begin Result := Round(AValue * VertPixelsPerInch / 96); end; function TdxBarScreenTipBandViewInfo.WidthToCurrentDpi(AValue: Integer): Integer; begin Result := Round(AValue * HorzPixelsPerInch / 96); end; function TdxBarScreenTipBandViewInfo.HorzPixelsPerInch: Integer; var ADC: HDC; begin ADC := GetDC(0); Result := GetDeviceCaps(ADC, LOGPIXELSX); ReleaseDC(0, ADC); end; function TdxBarScreenTipBandViewInfo.VertPixelsPerInch: Integer; begin Result := Screen.PixelsPerInch; end; procedure TdxBarScreenTipBandViewInfo.Paint(ACanvas: TCanvas; ALightColor, ADarkColor: TColor); procedure DrawTextField(const AText: string; ARect: TRect); begin cxDrawText(ACanvas.Handle, AText, ARect, DT_LEFT {or DT_NOCLIP} or DT_NOPREFIX or DT_WORDBREAK); end; procedure DrawFooterLine(ALightColor, ADarkColor: TColor); var R: TRect; begin R := cxRect(5, Top, Width - 5, Top + 1); FillRectByColor(ACanvas.Handle, R, ADarkColor); OffsetRect(R, 0, 1); FillRectByColor(ACanvas.Handle, R, ALightColor); end; begin if HasText then begin ACanvas.Font.Assign(Band.Font); DrawTextField(GetText, TextBounds); end; if HasGlyph then ACanvas.StretchDraw(GlyphBounds, Band.Glyph); if Band.BandType = stbFooter then DrawFooterLine(ALightColor, ADarkColor); end; { TdxBarScreenTipViewInfo } constructor TdxBarScreenTipViewInfo.Create(AScreenTip: TdxBarScreenTip; ASkin: TObject; const AHintText: string; AShortCut: string = ''); begin inherited Create(BarManager); FScreenTip := AScreenTip; FSkinnedObject := ASkin; if (FScreenTip <> nil) and FScreenTip.UseHintAsHeader then FHintText := AHintText; FShortCut := AShortCut; end; destructor TdxBarScreenTipViewInfo.Destroy; begin DestroyBandViewInfos; inherited Destroy; end; procedure TdxBarScreenTipViewInfo.Calculate(ACanvas: TCanvas); var AHeight, ATop: Integer; ABand: TdxBarCustomScreenTipBand; ABandViewInfo: TdxBarScreenTipBandViewInfo; I: TdxBarScreenTipBandType; begin ATop := 0; FWidth := FScreenTip.GetWidth; DestroyBandViewInfos; for I := Low(TdxBarScreenTipBandType) to High(TdxBarScreenTipBandType) do begin ABand := FScreenTip.GetBandForCalculation(I); if ABand.IsVisible(FHintText) then begin ABandViewInfo := CreateBandViewInfo(ABand); AHeight := ABandViewInfo.GetHeight(ACanvas, FWidth); ABandViewInfo.Calculate(FWidth, ATop, AHeight); Inc(ATop, AHeight); SetLength(FBandViewInfos, Length(FBandViewInfos) + 1); FBandViewInfos[Length(FBandViewInfos) - 1] := ABandViewInfo; end; end; FBoundsRect := Rect(0, 0, FWidth, ATop); end; procedure TdxBarScreenTipViewInfo.Paint(ACanvas: TCanvas); var I: Integer; begin ISkin.DrawBackground(ACanvas.Handle, BoundsRect, DXBAR_SCREENTIP); for I := 0 to BandViewInfosCount - 1 do FBandViewInfos[I].Paint(ACanvas, clWhite, ISkin.GetPartColor(DXBAR_SCREENTIP_FOOTERLINE)); end; procedure TdxBarScreenTipViewInfo.DestroyBandViewInfos; var I: Integer; begin for I := 0 to BandViewInfosCount - 1 do FreeAndNil(FBandViewInfos[I]); FBandViewInfos := nil; end; function TdxBarScreenTipViewInfo.CreateBandViewInfo( ABand: TdxBarCustomScreenTipBand): TdxBarScreenTipBandViewInfo; begin Result := TdxBarScreenTipBandViewInfo.Create(ABand, FHintText, FShortCut); end; function TdxBarScreenTipViewInfo.IsScreenTip: Boolean; begin Result := True; end; function TdxBarScreenTipViewInfo.GetBandViewInfos(Index: Integer): TdxBarScreenTipBandViewInfo; begin if Index < BandViewInfosCount then Result := FBandViewInfos[Index] else Result := nil; end; function TdxBarScreenTipViewInfo.GetBandViewInfosCount: Integer; begin Result := Length(FBandViewInfos); end; function TdxBarScreenTipViewInfo.GetISkin: IdxSkin; begin Supports(FSkinnedObject, IdxSkin, Result); end; { TdxBarHintWindow } constructor TdxBarHintWindow.Create(AOwner: TComponent); begin inherited Create(AOwner); Color := clInfoBk; Canvas.Brush.Style := bsClear; DoubleBuffered := True; end; destructor TdxBarHintWindow.Destroy; begin FreeAndNil(FViewInfo); inherited Destroy; end; procedure TdxBarHintWindow.CorrectWindowPos(var P: TPoint); var AWorkArea: TRect; begin AWorkArea := GetWorkArea(P); if P.X + Width > AWorkArea.Right then P.X := AWorkArea.Right - Width; // if R.Top + Height > WorkArea.Bottom then // R.Top := P.Y - 5 * HintOffset div 2; if P.Y + Height > AWorkArea.Bottom then P.Y := P.Y - Height - HintOffset; if P.X < AWorkArea.Left then P.X := AWorkArea.Left; if P.Y < AWorkArea.Top then P.Y := AWorkArea.Top; end; procedure TdxBarHintWindow.CreateParams(var Params: TCreateParams); begin inherited CreateParams(Params); with Params do begin Style := WS_POPUP; if not IsScreenTipWindow then Style := Style or WS_DISABLED; WindowClass.Style := WindowClass.Style or CS_SAVEBITS; ExStyle := WS_EX_TOOLWINDOW or WS_EX_TOPMOST; // CS_DROPSHADOW requires Windows XP or above if CheckWin32Version(5, 1) then begin if IsScreenTipWindow then WindowClass.Style := WindowClass.style or $20000{= CS_DROPSHADOW}; end; end; end; function TdxBarHintWindow.GetHideHintTime: Integer; begin if FIsScreenTipWindow then Result := 200000 else Result := dxBarWaitForHideHintTime; end; function TdxBarHintWindow.GetShowHintTime: Integer; begin if FIsScreenTipWindow then Result := 900 else Result := dxBarWaitForShowHintTime; end; procedure TdxBarHintWindow.Paint; begin ClientWidth := cxRectWidth(FViewInfo.BoundsRect); ClientHeight := cxRectHeight(FViewInfo.BoundsRect); FViewInfo.Paint(Canvas); end; procedure TdxBarHintWindow.RecreateWindow; var AParams: TCreateParams; ATempClass: TWndClass; AClassRegistered: Boolean; begin if not IsWinXP then RecreateWnd else begin DestroyHandle; CreateParams(AParams); with AParams do begin AClassRegistered := Windows.GetClassInfo(WindowClass.hInstance, WinClassName, ATempClass); if AClassRegistered then Windows.UnregisterClass(WinClassName, HInstance); end; HandleNeeded; end; end; function TdxBarHintWindow.ActivateHint(ABarManager: TdxBarManager; const AHintText, AShortCut: string): Boolean; var P: TPoint; AHintKeeper: IdxBarHintKeeper; ABarControl: TCustomdxBarControl; begin FreeAndNil(FViewInfo); AHintKeeper := nil; ABarControl := nil; if not Supports(ABarManager.FHintObject, IdxBarHintKeeper, AHintKeeper) then if ABarManager.FHintObject is TCustomdxBarControl then ABarControl := TCustomdxBarControl(ABarManager.FHintObject); if AHintKeeper <> nil then FViewInfo := AHintKeeper.CreateHintViewInfo(AHintText, AShortCut) else if ABarControl <> nil then FViewInfo := ABarControl.Painter.CreateHintViewInfo(ABarManager, AHintText, AShortCut, nil) else FViewInfo := TdxBarHintViewInfo.Create(ABarManager, AHintText, AShortCut, GetMouseCursorPos); FViewInfo.SetWindowDrawParams(Self); FViewInfo.Calculate(Canvas); Width := cxRectWidth(FViewInfo.BoundsRect); Height := cxRectHeight(FViewInfo.BoundsRect); Result := (Width <> 0) or (Height <> 0); if Result then begin if AHintKeeper <> nil then P := AHintKeeper.GetHintPosition(GetMouseCursorPos, Height) else if ABarControl <> nil then P := ABarControl.Painter.GetBarItemContolHintPosition(ABarControl, ABarControl.MarkRect, GetMouseCursorPos, Height) else P := GetMouseCursorPos; CorrectWindowPos(P); SetWindowPos(Handle, HWND_TOPMOST, P.X, P.Y, 0, 0, SWP_NOSIZE or SWP_SHOWWINDOW or SWP_NOACTIVATE); cxInvalidateRect(Handle); end; end; procedure TdxBarHintWindow.SetIsScreenTipWindow(Value: Boolean); begin if IsScreenTipWindow <> Value then begin Visible := False; FIsScreenTipWindow := Value; RecreateWindow; end; end; procedure TdxBarHintWindow.WMNCHitTest(var Message: TWMNCHitTest); begin Message.Result := HTTRANSPARENT; end; procedure TdxBarHintWindow.WMShowWindow(var Message: TWMShowWindow); begin if not Message.Show then FreeAndNil(FViewInfo); end; procedure TdxBarHintWindow.WMSize(var Message: TWMSize); begin inherited; if FIsScreenTipWindow then SetWindowRgn(Handle, CreateRoundRectRgn(0, 0, Message.Width + 1, Message.Height + 1, 2, 2), True); end; { TdxBarItem } constructor TdxBarItem.Create(AOwner: TComponent); begin inherited Create(AOwner); FBarManager := GetBarManagerByComponent(AOwner); if (FBarManager = nil) and (dxBarManagerList.Count > 0) then FBarManager := TdxBarManager(dxBarManagerList[0]); if BarManager <> nil then BarManager.FItems.Add(Self); FLinks := TList.Create; FStylesData := TdxBarItemStylesData.Create(GetStyleCount); FStylesData.OnChange := InternalStyleChanged; FEnabled := True; FGlyph := dxBarCreateBitmap(OnGlyphChanged); FLargeGlyph := dxBarCreateBitmap(OnLargeGlyphChanged); FImageIndex := -1; FLargeImageIndex := -1; FGlyphLayout := glTop; FCanSelect := True; FCategory := -1; FLoadedVisible := ivAlways; FMergeKind := mkAdd; FVisible := ivAlways; end; destructor TdxBarItem.Destroy; begin //#DG BarDesignController.DeselectIfSelected(Self); FreeAndNil(FStylesData); FreeAndNil(FLinks); FreeAndNil(FActionLink); FreeAndNil(FLargeGlyph); FreeAndNil(FGlyph); cxClearObjectLinks(Self); inherited Destroy; end; procedure TdxBarItem.BeforeDestruction; begin inherited; CallNotify(FOnDestroy, Self); DestroyLinks; end; function TdxBarItem.GetAction: TBasicAction; begin if FActionLink = nil then Result := nil else Result := FActionLink.Action; end; function TdxBarItem.GetActiveLink: TdxBarItemLink; begin if GetItemByLink(BarManager.LastSelectedLinkAtDesign) = Self then Result := BarManager.LastSelectedLinkAtDesign else if LinkCount > 0 then Result := Links[0] else Result := nil; end; function TdxBarItem.GetActuallyVisible: Boolean; begin Result := ((Visible = ivAlways) and (InternalActuallyVisible or BarManager.IsCustomizing) or (Visible = ivInCustomizing) and BarManager.IsCustomizing); end; function TdxBarItem.GetCurItemLink: TdxBarItemLink; var I: Integer; begin Result := nil; for I := 0 to LinkCount - 1 do if (Links[I].Control <> nil) and Links[I].Control.IsActive then begin Result := Links[I]; Break; end; end; function TdxBarItem.GetFlat: Boolean; begin // TODO: obsolete Result := BarManager.Flat; end; function TdxBarItem.GetIndex: Integer; begin Result := BarManager.FItems.IndexOf(Self); end; function TdxBarItem.GetIsDesigning: Boolean; begin Result := csDesigning in ComponentState; end; function TdxBarItem.GetIsDestroying: Boolean; begin Result := csDestroying in ComponentState; end; function TdxBarItem.GetIsLoading: Boolean; begin Result := csLoading in ComponentState; end; function TdxBarItem.GetLinkCount: Integer; begin Result := FLinks.Count; end; function TdxBarItem.GetLinks(Index: Integer): TdxBarItemLink; begin Result := nil; if (Index > -1) and (Index < LinkCount) then Result := TdxBarItemLink(FLinks[Index]); end; function TdxBarItem.GetPainterClass: TdxBarPainterClass; begin Result := BarManager.PainterClass; end; function TdxBarItem.GetVisibleForUser: Boolean; var I: Integer; begin Result := True; for I := 0 to LinkCount - 1 do if Links[I].CanVisibleIndex <> -1 then Exit; Result := False; end; procedure TdxBarItem.SetAction(Value: TBasicAction); begin if Action <> Value then if Value = nil then FreeAndNil(FActionLink) else begin if csLoading in Value.ComponentState then BarManager.LockDesignerModified(True); try if FActionLink = nil then FActionLink := GetActionLinkClass.Create(Self); FActionLink.Action := Value; FActionLink.OnChange := DoActionChange; ActionChange(Value, csLoading in Value.ComponentState); Value.FreeNotification(Self); finally if csLoading in Value.ComponentState then BarManager.LockDesignerModified(False, False); end; end; end; procedure TdxBarItem.SetAlign(Value: TdxBarItemAlign); begin if FAlign <> Value then begin FAlign := Value; UpdateEx; end; end; procedure TdxBarItem.SetCategory(Value: Integer); begin if IsLoading then FCategory := Value else if (BarManager <> nil) and (Value > -1) and (Value < BarManager.Categories.Count) then begin FCategory := Value; Changed(True); end; end; procedure TdxBarItem.SetDescription(Value: string); begin if FDescription <> Value then begin FDescription := Value; Changed; end; end; procedure TdxBarItem.SetGlyph(Value: TBitmap); begin FGlyph.Assign(Value); end; procedure TdxBarItem.SetGlyphLayout(Value: TdxBarGlyphLayout); begin if FGlyphLayout <> Value then begin FGlyphLayout := Value; UpdateEx; end; end; procedure TdxBarItem.SetIndex(Value: Integer); begin if Index <> Value then BarManager.ItemList.Move(Index, Value); end; procedure TdxBarItem.SetLargeGlyph(Value: TBitmap); begin FLargeGlyph.Assign(Value); end; procedure TdxBarItem.SetMergeOrder(Value: Integer); begin if Value < 0 then Value := 0; FMergeOrder := Value; end; procedure TdxBarItem.SetPaintStyle(Value: TdxBarPaintStyle); begin if FPaintStyle <> Value then begin FPaintStyle := Value; if not IsLoading then PaintStyleChanged; end; end; procedure TdxBarItem.SetScreenTip(Value: TdxBarScreenTip); begin if FScreenTip <> Value then begin if FScreenTip <> nil then FScreenTip.RemoveFreeNotification(Self); FScreenTip := Value; if FScreenTip <> nil then FScreenTip.FreeNotification(Self); end; end; procedure TdxBarItem.SetShowCaption(Value: Boolean); begin if FShowCaption <> Value then begin FShowCaption := Value; if not IsLoading then UpdateEx; end; end; procedure TdxBarItem.SetShortCut(Value: TShortCut); begin if FShortCut <> Value then begin FShortCut := Value; if not IsLoading then ShortCutChanged; end; end; procedure TdxBarItem.DestroyLinks; function HasItemLinkOnUnlockedBar: Boolean; var I: Integer; begin Result := False; for I := 0 to LinkCount - 1 do if (Links[I].BarControl is TdxBarControl) and not TdxBarControl(Links[I].BarControl).Bar.BarManager.IsUpdateLocked then begin Result := True; Break; end; end; var Item: TdxBarItemLink; ALock: Boolean; begin ALock := not BarManager.IsDestroying and HasItemLinkOnUnlockedBar; if ALock then BarManager.BeginUpdate; try while LinkCount > 0 do begin Item := TdxBarItemLink(FLinks.Last); FLinks.Remove(Item); Item.Free; end; finally if ALock then BarManager.EndUpdate; end; end; procedure TdxBarItem.DoActionChange(Sender: TObject); begin if Sender = Action then ActionChange(Sender, False); end; function TdxBarItem.IsEnabledStored: Boolean; begin Result := (FActionLink = nil) or not FActionLink.IsEnabledLinked; end; function TdxBarItem.IsHelpContextStored: Boolean; begin Result := (ActionLink = nil) or not FActionLink.IsHelpContextLinked; end; function TdxBarItem.IsHintStored: Boolean; begin Result := (FActionLink = nil) or not FActionLink.IsHintLinked; end; function TdxBarItem.IsImageIndexStored: Boolean; begin Result := (FActionLink = nil) or not FActionLink.IsImageIndexLinked; end; function TdxBarItem.IsShortCutStored: Boolean; begin Result := (FActionLink = nil) or not FActionLink.IsShortCutLinked; end; function TdxBarItem.IsVisibleStored: Boolean; begin Result := (FActionLink = nil) or not FActionLink.IsVisibleLinked; end; function TdxBarItem.IsOnClickStored: Boolean; begin Result := (FActionLink = nil) or not FActionLink.IsOnExecuteLinked; end; function TdxBarItem.GetHintFromCaption: string; var P: Integer; begin Result := Caption; P := Pos('&', Result); if P > 0 then Delete(Result, P, 1); P := Pos('...', Result); if P > 0 then Delete(Result, P, 3); end; procedure TdxBarItem.OnGlyphChanged(Sender: TObject); begin GlyphChanged; end; procedure TdxBarItem.OnLargeGlyphChanged(Sender: TObject); begin LargeGlyphChanged; end; procedure TdxBarItem.AssignTo(Dest: TPersistent); begin if Dest is TCustomAction then with TCustomAction(Dest) do begin Caption := Self.Caption; if Self is TdxBarButton then Checked := TdxBarButton(Self).Down; Enabled := Self.Enabled; HelpContext := Self.HelpContext; Hint := Self.Hint; ImageIndex := Self.ImageIndex; ShortCut := Self.ShortCut; case Self.Visible of ivNever: Visible := False; ivAlways: Visible := True; end; OnExecute := Self.OnClick; end else inherited AssignTo(Dest); end; function TdxBarItem.GetEnabled: Boolean; begin if not BarManager.Designing and BarManager.IsCustomizing and (Category > -1) then Result := True else Result := FEnabled; end; function TdxBarItem.GetWidth: Integer; begin Result := FWidth; end; procedure TdxBarItem.Loaded; begin inherited; if Action <> nil then ActionChange(Action, True); CallNotify(FOnCreate, Self); end; procedure TdxBarItem.Notification(AComponent: TComponent; Operation: TOperation); begin inherited Notification(AComponent, Operation); if Operation = opRemove then begin if AComponent = Action then Action := nil; if AComponent = FScreenTip then FScreenTip := nil; end; end; procedure TdxBarItem.ReadState(Reader: TReader); begin inherited ReadState(Reader); if Reader.Parent is TdxBarManager then begin FBarManager := TdxBarManager(Reader.Parent); BarManagerChanged; end; end; procedure TdxBarItem.SelectionChanged; var I: Integer; begin BarDesignController.SynchronizeLastSelectedItem; for I := 0 to LinkCount - 1 do RepaintItemControl(Links[I].Control); end; procedure TdxBarItem.SetName(const NewName: TComponentName); begin inherited; if not ((csDesigning in ComponentState) and (NewName = '')) then Changed; end; procedure TdxBarItem.SetEnabled(Value: Boolean); begin if FEnabled <> Value then begin FEnabled := Value; if not IsLoading then EnabledChanged; end; end; procedure TdxBarItem.SetVisible(Value: TdxBarItemVisible); begin if IsLoading then FLoadedVisible := Value else if FVisible <> Value then begin FVisible := Value; VisibleChanged; end; end; procedure TdxBarItem.SetWidth(Value: Integer); begin if (FWidth <> Value) and (Value >= 0) then begin FWidth := Value; WidthChanged; end; end; procedure TdxBarItem.Invalidate; begin Update; end; function TdxBarItem.IsComplex: Boolean; begin Result := LinkCount > 1; end; function TdxBarItem.CanDelete(ADestruction: Boolean = False): Boolean; begin Result := ((LinkCount > 0) and not ADestruction) or BarManager.CanDeleteComponent(Self); end; procedure TdxBarItem.ExecuteCustomizationAction(ABasicAction: TdxBarCustomizationAction); begin if (LinkCount = 1) and (GetSelectableItem(Links[0]) <> BarDesignController.LastSelectedItem) then Links[0].ExecuteCustomizationAction(ABasicAction); end; procedure TdxBarItem.GetMasterObjects(AList: TdxObjectList); begin AList.Add(BarManager.Owner); end; function TdxBarItem.GetNextSelectableItem: IdxBarSelectableItem; function GetNextLink(AItemLink: TdxBarItemLink): TdxBarItemLink; begin if AItemLink <> nil then Result := AItemLink.GetNext else Result := nil; end; function GetNextItem(AItemLink: TdxBarItemLink): TdxBarItem; var ANext: TdxBarItemLink; begin Result := nil; ANext := AItemLink; repeat ANext := GetNextLink(ANext); if GetItemByLink(ANext) <> Self then begin Result := GetItemByLink(ANext); Break; end; until (ANext = nil) or (ANext = AItemLink); end; begin Result := GetNextItem(GetActiveLink); end; function TdxBarItem.GetSelectableParent: TPersistent; begin if GetActiveLink <> nil then Result := GetActiveLink.GetSelectableParent else Result := nil; end; function TdxBarItem.GetSupportedActions: TdxBarCustomizationActions; begin if BarManager.Designing then begin if BarDesignController.IsItemLinkCustomized then Result := [caReset, caDelete, caDeleteItem, caDeleteLink, caChangeCaption, caChangePosition, caChangeViewLevels, caChangeBeginGroup, caChangeVisible, caChangeRecentList] else Result := [caDelete]; end else Result := [caReset, caDeleteLink, caChangeCaption, caChangeBeginGroup]; end; procedure TdxBarItem.DeleteSelection(var AReference: IdxBarSelectableItem; ADestruction: Boolean); begin if ADestruction or (LinkCount = 0) then inherited else DestroyLinks; end; function TdxBarItem.SelectParentComponent: Boolean; begin if GetActiveLink <> nil then Result := GetActiveLink.SelectParentComponent else Result := False; end; procedure TdxBarItem.ActionChange(Sender: TObject; CheckDefaults: Boolean); begin if Action is TCustomAction then with TCustomAction(Sender) do begin FCheckDefaults := CheckDefaults; try if not CheckDefaults or (Self.Caption = '') then Self.Caption := Caption; finally FCheckDefaults := False; end; if (Self is TdxBarButton) and (not CheckDefaults or (TdxBarButton(Self).Down = False)) then TdxBarButton(Self).Down := Checked; if not CheckDefaults or (Self.Enabled = True) then Self.Enabled := Enabled; if not CheckDefaults or (Self.HelpContext = 0) then Self.HelpContext := HelpContext; if not CheckDefaults or (Self.Hint = '') then Self.Hint := Hint; if not CheckDefaults or (Self.ActionImageIndex = -1) then Self.ActionImageIndex := ImageIndex; if not CheckDefaults or (Self.ShortCut = scNone) then Self.ShortCut := ShortCut; if not CheckDefaults or (Self.Visible = ivAlways) then Self.Visible := VisibleTodxBarVisible(Visible); if not CheckDefaults or not Assigned(Self.OnClick) then Self.OnClick := OnExecute; end; end; procedure TdxBarItem.BarManagerChanged; begin end; function TdxBarItem.CanBeOnToolbar(AToolbar: TdxBar; out AErrorText: string): Boolean; begin Result := True; end; function TdxBarItem.CanChangePaintStyle: Boolean; begin Result := False; end; function TdxBarItem.CanClicked: Boolean; begin Result := True; end; function TdxBarItem.CanMergeWith(AItem: TdxBarItem): Boolean; begin Result := InternalCanMergeWith(AItem) and AItem.InternalCanMergeWith(Self); end; function TdxBarItem.CurImageIndexLinked: Boolean; begin Result := IsImageIndexLinked(GetCurImages, ImageIndex) end; procedure TdxBarItem.DrawCustomizingImage(ACanvas: TCanvas; const ARect: TRect; AState: TOwnerDrawState); begin dxBarCustomizingForm.PainterClass.DrawButtonOrSubItem(ACanvas, ARect, Self, GetTextOf(Caption), odSelected in AState); end; procedure TdxBarItem.DrawCustomizingImageContent(ACanvas: TCanvas; const ARect: TRect; ASelected: Boolean); begin ACanvas.Brush.Color := clWindow; ACanvas.FillRect(ARect); end; function TdxBarItem.GetActionLinkClass: TdxBarItemActionLinkClass; begin Result := TdxBarItemActionLink; end; function TdxBarItem.GetActionImageIndex: Integer; begin Result := ImageIndex; end; procedure TdxBarItem.SetActionImageIndex(Value: Integer); begin ImageIndex := Value; end; function TdxBarItem.GetControlClass(AIsVertical: Boolean): TdxBarItemControlClass; var I: Integer; begin Result := nil; for I := 0 to RegdxItemList.Count - 1 do if ClassInfo = RegdxItemList.Items[I].FItemClass.ClassInfo then begin Result := RegdxItemList.Items[I].FItemControlClass; Break; end; end; function TdxBarItem.GetHidden: Boolean; begin Result := False; end; function TdxBarItem.GetItemLinks: TdxBarItemLinks; begin Result := nil; end; class function TdxBarItem.GetStyleCount: Integer; begin Result := 1; end; function TdxBarItem.GetStyleValue(AIndex: Integer): TcxStyle; begin Result := StylesData.Styles[AIndex]; end; function TdxBarItem.HasAccel(AItemLink: TdxBarItemLink): Boolean; begin Result := Enabled;//True end; function TdxBarItem.HasControls: Boolean; var I: Integer; begin Result := True; for I := 0 to LinkCount - 1 do if Links[I].Control <> nil then Exit; Result := False; end; procedure TdxBarItem.HideControl(AControl: TdxBarItemControl); begin end; function TdxBarItem.InternalActuallyVisible: Boolean; begin Result := True; end; function TdxBarItem.InternalCanMergeWith(AItem: TdxBarItem): Boolean; begin Result := False; end; function TdxBarItem.IsHintFromCaption: Boolean; begin Result := GetShortHint(Hint) = GetHintFromCaption; end; function TdxBarItem.IsImageIndexLinked(AImageList: TCustomImageList; AImageIndex: Integer): Boolean; begin Result := IsImageAssigned(AImageList, AImageIndex); end; function TdxBarItem.IsStyleColorSupported: Boolean; begin Result := False; end; function TdxBarItem.NeedToBeHidden: Boolean; begin Result := False; end; procedure TdxBarItem.ObjectNotification(AOperation: TOperation; AObject: TObject); begin end; procedure TdxBarItem.Recalculate; var I: Integer; begin for I := 0 to LinkCount - 1 do if Links[I].Control <> nil then with Links[I].Control do PartsChanged; end; procedure TdxBarItem.SetImageIndex(Value: Integer); begin if FImageIndex <> Value then begin FImageIndex := Value; GlyphChanged; end; end; procedure TdxBarItem.SetLargeImageIndex(Value: Integer); begin if FLargeImageIndex <> Value then begin FLargeImageIndex := Value; LargeGlyphChanged; end; end; procedure TdxBarItem.SetStyleValue(AIndex: Integer; Value: TcxStyle); begin StylesData.Styles[AIndex] := Value; end; procedure TdxBarItem.ShowDefaultEventHandler; begin BarManager.ShowDefaultEventHandler(Self); end; procedure TdxBarItem.Update; var I: Integer; begin for I := 0 to LinkCount - 1 do if Links[I].Control <> nil then with Links[I].Control do if not IsSelected or not Parent.IsActive then Repaint; end; procedure TdxBarItem.UpdateEx(AParentKinds: TdxBarKinds = [bkBarControl, bkBarQuickControl, bkSubMenu]); var I: Integer; begin for I := 0 to LinkCount - 1 do if Links[I].Control <> nil then with Links[I].Control do if (Parent.Kind in AParentKinds) and (not IsSelected or not Parent.IsActive) then Parent.RepaintBar; end; function TdxBarItem.UseHotImages: Boolean; begin Result := False; end; function TdxBarItem.UseLargeImages: Boolean; begin Result := (ImageIndex > -1) or (LargeImageIndex > -1); end; procedure TdxBarItem.CaptionChanged; var I: Integer; begin for I := 0 to LinkCount - 1 do if not (udCaption in Links[I].UserDefine) and (Links[I].Control <> nil) then Links[I].Control.CaptionChanged; Changed; end; procedure TdxBarItem.EnabledChanged; var I: Integer; begin for I := 0 to LinkCount - 1 do if Links[I].Control <> nil then begin Links[I].Control.ResetCachedValues(False); Links[I].Control.EnabledChanged; end; end; procedure TdxBarItem.GlyphChanged; var I: Integer; begin for I := 0 to LinkCount - 1 do if not (udGlyph in Links[I].UserDefine) and (Links[I].Control <> nil) then Links[I].Control.ResetCachedValues(True); for I := 0 to LinkCount - 1 do if not (udGlyph in Links[I].UserDefine) and (Links[I].Control <> nil) then Links[I].Control.GlyphChanged; Changed; end; procedure TdxBarItem.HotGlyphChanged; var I: Integer; begin for I := 0 to LinkCount - 1 do if Links[I].Control <> nil then begin Links[I].Control.ResetCachedValues(False); Links[I].Control.HotGlyphChanged; end; end; procedure TdxBarItem.InternalStyleChanged(AChangeKind: TdxBarItemStyleChangeKind); procedure DoItemLinkChange(ALink: TdxBarItemLink); begin if AChangeKind = sckDrawing then ALink.Control.CalcDrawingConsts else begin ALink.DestroyControl; ALink.CreateControl; end; end; procedure DoItemChange; begin if AChangeKind = sckDrawing then Update else UpdateEx; end; var I: Integer; begin if not (csDestroying in ComponentState) then begin for I := 0 to LinkCount - 1 do if Links[I].Control <> nil then DoItemLinkChange(Links[I]); DoItemChange; end; end; procedure TdxBarItem.LargeGlyphChanged; var I: Integer; begin for I := 0 to LinkCount - 1 do if Links[I].Control <> nil then Links[I].Control.ResetCachedValues(True); for I := 0 to LinkCount - 1 do if Links[I].Control <> nil then Links[I].Control.LargeGlyphChanged; Changed; end; procedure TdxBarItem.PaintStyleChanged; begin // do nothing end; procedure TdxBarItem.ShortCutChanged; begin UpdateEx([bkSubMenu]); Changed; end; procedure TdxBarItem.VisibleChanged; var I: Integer; begin if IsDesigning then Exit; BarManager.BeginUpdate; try for I := 0 to LinkCount - 1 do begin Links[I].Owner.RefreshVisibilityLists; if ActuallyVisible then begin Links[I].BringToTopInRecentList(False); if Links[I].Control = nil then Links[I].CreateControl; if Links[I].Control <> nil then Links[I].Control.VisibleChanged; end else begin Links[I].SendToBottomInRecentList; if Links[I].Control <> nil then begin Links[I].Control.VisibleChanged; Links[I].DestroyControl; end; end; end; finally BarManager.EndUpdate; Changed; end; end; procedure TdxBarItem.WidthChanged; begin // do nothing end; function TdxBarItem.GetCaption: string; begin Result := FCaption; end; function TdxBarItem.IsCaptionStored: Boolean; begin Result := (FActionLink = nil) or not FActionLink.IsCaptionLinked; end; procedure TdxBarItem.SetCaption(const Value: string); var AMakeHint: Boolean; S: string; begin if FCaption <> Value then begin AMakeHint := not FCheckDefaults and not (Self is TCustomdxBarSubItem) and ((Hint = '') or IsHintFromCaption); FCaption := Value; if not IsLoading then begin if AMakeHint then begin S := GetHintFromCaption; if Pos('|', Hint) = 0 then Hint := S else Hint := S + '|' + GetLongHint(Hint); end; CaptionChanged; end; end; end; procedure TdxBarItem.CheckLinks(ASource: TCustomIniFile; const ABaseSection: string); begin // do nothing end; procedure TdxBarItem.LoadFromIni(ASource: TCustomIniFile; const ABaseSection: string; AStoringKind: TdxBarStoringKind); begin // do nothing end; procedure TdxBarItem.LoadUsageData(ASource: TCustomIniFile; const ABaseSection: string); begin // do nothing end; procedure TdxBarItem.SaveToIni(ADestination: TCustomIniFile; const ABaseSection: string; AStoringKind: TdxBarStoringKind); begin // do nothing end; procedure TdxBarItem.GetTextViewParams(out AViewParams: TcxViewParams); begin GetViewParams(Style, AViewParams); end; procedure TdxBarItem.GetViewParams(AStyle: TcxStyle; out AViewParams: TcxViewParams); begin AViewParams := DefaultViewParams; if AStyle <> nil then begin if svBitmap in AStyle.AssignedValues then AViewParams.Bitmap := AStyle.Bitmap; if svColor in AStyle.AssignedValues then AViewParams.Color := AStyle.Color; if svFont in AStyle.AssignedValues then AViewParams.Font := AStyle.Font; if svTextColor in AStyle.AssignedValues then AViewParams.TextColor := AStyle.TextColor; end; end; class function TdxBarItem.GetNewCaption: string; begin Result := dxSBAR_NEWITEMCAPTION; end; procedure TdxBarItem.Click; begin if CanClicked then DirectClick; end; procedure TdxBarItem.DirectClick; begin if Enabled then try BarManager.DoClickItem(Self); DoClick; except Application.HandleException(Self); end; end; procedure TdxBarItem.DoClick; begin if Assigned(FOnClick) and ((Action = nil) or (@FOnClick <> @Action.OnExecute)) then FOnClick(Self) else if not IsDesigning and (FActionLink <> nil) then FActionLink.Execute{$IFDEF DELPHI6}(Self){$ENDIF}; end; function TdxBarItem.GetParentComponent: TComponent; begin if HasParent then Result := FBarManager else Result := nil; end; function TdxBarItem.HasParent: Boolean; begin Result := FCategory > -1; end; procedure TdxBarItem.SetParentComponent(AParent: TComponent); begin if not IsLoading then begin FBarManager := AParent as TdxBarManager; BarManagerChanged; end; end; function TdxBarItem.GetCurImages: TCustomImageList; begin Result := BarManager.Images; end; { TdxBarLabel } constructor TdxBarLabel.Create(AOwner: TComponent); begin inherited; FShowCaption := True; end; { TdxBarSeparator } function TdxBarSeparator.CanBeOnToolbar(AToolbar: TdxBar; out AErrorText: string): Boolean; begin Result := False; AErrorText := dxSBAR_CANTPLACESEPARATOR; end; class function TdxBarSeparator.GetNewCaption: string; begin Result := dxSBAR_NEWSEPARATORCAPTION; end; function TdxBarSeparator.GetSupportedActions: TdxBarCustomizationActions; begin Result := inherited GetSupportedActions - [caChangeRecentList]; end; { TdxBarWindowItem } function TdxBarWindowItem.GetCurText: string; begin if CurItemLink = nil then Result := Text else if CurItemLink.Control is TdxBarWinControl then Result := TdxBarWinControl(CurItemLink.Control).Text; end; function TdxBarWindowItem.GetFocusedItemLink: TdxBarItemLink; begin if (CurItemLink <> nil) and (CurItemLink.Control is TdxBarWinControl) and TdxBarWinControl(CurItemLink.Control).Focused then Result := CurItemLink else Result := nil; end; procedure TdxBarWindowItem.SetCurText(Value: string); begin if CurItemLink = nil then Text := Value else if CurItemLink.Control is TdxBarWinControl then TdxBarWinControl(CurItemLink.Control).Text := Value; end; function TdxBarWindowItem.CanClicked: Boolean; begin Result := False; end; procedure TdxBarWindowItem.Change; begin if not IsLoading and Assigned(FOnChange) then FOnChange(Self); end; procedure TdxBarWindowItem.CurChange; begin CallNotify(FOnCurChange, Self); end; procedure TdxBarWindowItem.DoEnter; begin CallNotify(FOnEnter, Self); end; procedure TdxBarWindowItem.DoExit; begin CallNotify(FOnExit, Self); end; function TdxBarWindowItem.GetControlClass(AIsVertical: Boolean): TdxBarItemControlClass; begin if AIsVertical then Result := TdxBarButtonControl else Result := inherited GetControlClass(AIsVertical); end; function TdxBarWindowItem.GetText: string; begin Result := FText; end; procedure TdxBarWindowItem.KeyDown(var Key: Word; Shift: TShiftState); begin if Assigned(FOnKeyDown) then FOnKeyDown(Self, Key, Shift); end; procedure TdxBarWindowItem.KeyPress(var Key: Char); begin if Assigned(FOnKeyPress) then FOnKeyPress(Self, Key); end; procedure TdxBarWindowItem.KeyUp(var Key: Word; Shift: TShiftState); begin if Assigned(FOnKeyUp) then FOnKeyUp(Self, Key, Shift); end; procedure TdxBarWindowItem.SetText(Value: string); begin if FText <> Value then begin FText := Value; { if (CurItemLink <> nil) and (CurItemLink.Control is TdxBarWinControl) then TdxBarWinControl(CurItemLink.Control).Text := FText;} Update; Change; Update; end; end; procedure TdxBarWindowItem.SetFocus(ACheckBarControlVisibility: Boolean = False); var I: Integer; begin for I := 0 to LinkCount - 1 do with Links[I] do if Control is TdxBarWinControl and (not ACheckBarControlVisibility or IsWindowVisible(BarControl.Handle)) then begin (BarControl as TdxBarControl).BarGetFocus(Control); Control.Click(False); Break; end; end; { TdxBarButton } var ABarSubItemTimer: TdxBarButtonLikeControl; ABarSubMenuTimerID: UINT; constructor TdxBarButton.Create(AOwner: TComponent); begin inherited Create(AOwner); FCloseSubMenuOnClick := True; FDropDownEnabled := True; FUnclickAfterDoing := True; end; function TdxBarButton.GetButtonStyle: TdxBarButtonStyle; begin if FInternalStates = [] then Result := bsDefault else if FInternalStates = [bstChecked] then Result := bsChecked else if FInternalStates = [bstDropDown] then Result := bsDropDown else Result := bsCheckedDropDown; end; procedure TdxBarButton.SetAllowAllUp(Value: Boolean); var I: Integer; begin if FAllowAllUp <> Value then begin FAllowAllUp := Value; if GroupIndex <> 0 then with BarManager do for I := 0 to ItemCount - 1 do if (Items[I] is TdxBarButton) and (TdxBarButton(Items[I]).GroupIndex = GroupIndex) then TdxBarButton(Items[I]).FAllowAllUp := FAllowAllUp; end; end; procedure TdxBarButton.SetButtonStyle(Value: TdxBarButtonStyle); begin if ButtonStyle <> Value then begin case Value of bsDefault: FInternalStates := []; bsChecked: FInternalStates := [bstChecked]; bsDropDown: FInternalStates := [bstDropDown]; bsCheckedDropDown: FInternalStates := [bstChecked, bstDropDown]; end; Down := False; if not IsLoading then UpdateEx; Changed; end; end; procedure TdxBarButton.SetDown; var DownedButton: TdxBarButton; function GetDownedButton: TdxBarButton; var I: Integer; begin with BarManager do for I := 0 to ItemCount - 1 do if Items[I] is TdxBarButton then begin Result := TdxBarButton(Items[I]); with Result do if (bstChecked in FInternalStates) and (GroupIndex = Self.GroupIndex) and Down then Exit; end; Result := nil; end; function AnotherDownedButtonExists: Boolean; var I: Integer; begin Result := True; with BarManager do for I := 0 to ItemCount - 1 do if (Items[I] <> Self) and (Items[I] is TdxBarButton) then with TdxBarButton(Items[I]) do if (bstChecked in FInternalStates) and (GroupIndex = Self.GroupIndex) and Down then Exit; Result := False; end; begin if (FDown <> Value) and ((bstChecked in FInternalStates) or not Value) then begin if not IsLoading and (bstChecked in FInternalStates) and (GroupIndex <> 0) then if Value then DownedButton := GetDownedButton else if not AllowAllUp and not AnotherDownedButtonExists then Exit else DownedButton := nil else DownedButton := nil; FDown := Value; if not IsLoading then begin Update; if DownedButton <> nil then DownedButton.Down := False; end; end; end; procedure TdxBarButton.SetDropDownEnabled(Value: Boolean); begin if FDropDownEnabled <> Value then begin FDropDownEnabled := Value; if not IsLoading then Update; end; end; procedure TdxBarButton.SetDropDownMenu(Value: TdxBarPopupMenu); begin if Value <> FDropDownMenu then begin if (Value <> nil) and Value.GetItemLinks.IsReferencedBy(Self) then raise Exception.Create(cxGetResourceString(@dxSBAR_RECURSIVEMENUS)) else begin FDropDownMenu := Value; if Value <> nil then Value.FreeNotification(Self); end; end; end; procedure TdxBarButton.SetGroupIndex; begin if FGroupIndex <> Value then begin if not (bstChecked in FInternalStates) then Value := 0; FGroupIndex := Value; Down := False; end; end; procedure TdxBarButton.SetLowered(Value: Boolean); begin if FLowered <> Value then begin FLowered := Value; if not IsLoading then UpdateEx; end; end; function TdxBarButton.IsDownStored: Boolean; begin Result := (FActionLink = nil) or not FActionLink.IsCheckedLinked; end; function TdxBarButton.CanChangePaintStyle: Boolean; begin Result := True; end; procedure TdxBarButton.DoDropDown(AControl: TdxBarButtonControl; X, Y: Integer; ByMouse: Boolean); var R: TRect; begin if FDropDownMenu <> nil then begin if AControl.HasShadow then R := AControl.Parent.GetItemScreenRect(AControl) else R := Rect(0, 0, 0, 0); FDropDownMenu.FOwnerItemControl := AControl; try with AControl, ItemBounds do if (Parent.Kind = bkSubMenu) or Parent.IsRealVertical then FDropDownMenu.PopupEx(X, Y, Right - Left, 0, FShowAnimation, @R, False, AControl.Parent) else FDropDownMenu.PopupEx(X, Y, 0, Bottom - Top, FShowAnimation, @R, False, AControl.Parent); finally FDropDownMenu.FOwnerItemControl := nil; end; with FDropDownMenu.SubMenuControl do begin FDropDownButton := AControl; if not ByMouse and (ItemLinks.First <> nil) then SetKeySelectedItem(ItemLinks.First.Control); end; if AControl.Parent.Kind = bkSubMenu then AControl.Parent.ChildBar := FDropDownMenu.SubMenuControl; end; end; function TdxBarButton.HasAccel(AItemLink: TdxBarItemLink): Boolean; begin Result := inherited HasAccel(AItemLink) and (not (AItemLink.Owner.Owner is TdxBar) or (AItemLink.PaintStyle in [psCaption, psCaptionGlyph]) or (AItemLink.Control <> nil) and (TdxBarButtonControl(AItemLink.Control).PaintStyle in [psCaption, psCaptionGlyph])); end; procedure TdxBarButton.Notification(AComponent: TComponent; Operation: TOperation); begin inherited; if (Operation = opRemove) and (AComponent = DropDownMenu) then DropDownMenu := nil; end; procedure TdxBarButton.PaintStyleChanged; var I: Integer; begin for I := 0 to LinkCount - 1 do if not (udPaintStyle in Links[I].UserDefine) and (Links[I].Control <> nil) then TdxBarButtonControl(Links[I].Control).PaintStyleChanged; end; // IdxBarLinksOwner function TdxBarButton.CanContainItem(AItem: TdxBarItem; out AErrorText: string): Boolean; begin Result := (DropDownMenu <> nil) and DropDownMenu.CanContainItem(AItem, AErrorText); end; function TdxBarButton.CreateBarControl: TCustomdxBarControl; begin if DropDownMenu <> nil then Result := DropDownMenu.CreateBarControl else Result := nil; end; function TdxBarButton.GetItemLinks: TdxBarItemLinks; begin if DropDownMenu <> nil then Result := DropDownMenu.ItemLinks else Result := inherited GetItemLinks; end; function TdxBarButton.GetSupportedActions: TdxBarCustomizationActions; begin Result := inherited GetSupportedActions + [caChangeButtonPaintStyle]; if BarManager.Designing then Include(Result, caChangeButtonGroup); end; class function TdxBarButton.GetNewCaption: string; begin Result := dxSBAR_NEWBUTTONCAPTION; end; procedure TdxBarButton.Click; begin if Enabled and (bstChecked in FInternalStates) then Down := not Down; inherited Click; end; { TdxBarApplicationMenuButtonItem } constructor TdxBarApplicationMenuButtonItem.Create(AOwner: TdxBarApplicationMenuButton); begin inherited Create(nil); FOwner := AOwner; BarDesignController.RemoveItemFromBarManagerList(Self); end; procedure TdxBarApplicationMenuButtonItem.Assign(ASource: TPersistent); var AItem: TdxBarButton; begin if ASource is TdxBarButton then begin AItem := TdxBarButton(ASource); Caption := AItem.Caption; Enabled := AItem.Enabled; Glyph := AItem.Glyph; Hint := AItem.Hint; ImageIndex := AItem.ImageIndex; ScreenTip := AItem.ScreenTip; Visible := AItem.Visible; OnClick := AItem.OnClick; end else inherited Assign(ASource); end; procedure TdxBarApplicationMenuButtonItem.Notification(AComponent: TComponent; Operation: TOperation); begin inherited Notification(AComponent, Operation); if (Operation = opRemove) and (AComponent = FOwner.Item) then FOwner.Item := nil; end; procedure TdxBarApplicationMenuButtonItem.SetVisible(Value: TdxBarItemVisible); begin if FVisible <> Value then begin FVisible := Value; VisibleChanged; end; end; procedure TdxBarApplicationMenuButtonItem.VisibleChanged; var I: Integer; begin for I := 0 to LinkCount - 1 do begin Links[I].Owner.RefreshVisibilityLists; if Links[I].Control = nil then Links[I].CreateControl; if Links[I].Control <> nil then Links[I].Control.VisibleChanged; end; end; procedure TdxBarApplicationMenuButtonItem.WidthChanged; var I: Integer; begin for I := 0 to LinkCount - 1 do if Links[I].Control <> nil then Links[I].Control.WidthChanged; end; { TcxCustomBarEdit } constructor TdxCustomBarEdit.Create(AOwner: TComponent); begin inherited Create(AOwner); FWidth := 100; end; procedure TdxCustomBarEdit.ReadState(Reader: TReader); begin if not FGlyphLoaded then // the same as in cxButtonEdit begin Glyph := nil; FGlyphLoaded := True; end; inherited; end; procedure TdxCustomBarEdit.DrawCustomizingImage(ACanvas: TCanvas; const ARect: TRect; AState: TOwnerDrawState); begin dxBarCustomizingForm.PainterClass.DrawEdit(ACanvas, ARect, Self, odSelected in AState, False); end; procedure TdxCustomBarEdit.GetEditViewParams(out AViewParams: TcxViewParams); begin GetViewParams(StyleEdit, AViewParams); end; class function TdxCustomBarEdit.GetStyleCount: Integer; begin Result := 2; end; function TdxCustomBarEdit.HasAccel(AItemLink: TdxBarItemLink): Boolean; begin Result := inherited HasAccel(AItemLink) and (FShowCaption or not (AItemLink.Owner.Owner is TdxBar)); end; procedure TdxCustomBarEdit.SetWidth(Value: Integer); begin if (FWidth <> Value) and (Value > 0) then begin FWidth := Value; if not IsLoading then WidthChanged; end; end; procedure TdxCustomBarEdit.WidthChanged; var I: Integer; begin for I := 0 to LinkCount - 1 do if not (udWidth in Links[I].UserDefine) and (Links[I].Control <> nil) then Links[I].Control.WidthChanged; end; { TdxBarEdit } procedure TdxBarEdit.SetMaxLength(Value: Integer); begin FMaxLength := Value; if FMaxLength <= 0 then FMaxLength := 0; end; procedure TdxBarEdit.DrawInterior(ABarEditControl: TdxBarEditControl; ACanvas: TCanvas; R: TRect; ItemLink: TdxBarItemLink); begin ABarEditControl.Painter.EditDrawInterior(ABarEditControl, Self, ACanvas, R, ItemLink); end; { TCustomdxBarCombo } function TCustomdxBarCombo.GetDroppedDown: Boolean; begin if CurItemLink = nil then Result := False else if CurItemLink.Control is TCustomdxBarComboControl then Result := TCustomdxBarComboControl(CurItemLink.Control).DroppedDown else Result := False; end; function TCustomdxBarCombo.GetShowEditor: Boolean; begin Result := not EmptyWindow; end; procedure TCustomdxBarCombo.SetDroppedDown(Value: Boolean); begin if (CurItemLink <> nil) and (CurItemLink.Control is TCustomdxBarComboControl) then TCustomdxBarComboControl(CurItemLink.Control).DroppedDown := Value; end; procedure TCustomdxBarCombo.SetShowEditor(Value: Boolean); begin EmptyWindow := not Value; end; procedure TCustomdxBarCombo.AfterDropDown; begin end; procedure TCustomdxBarCombo.CheckDropDownPoint(var X, Y: Integer); var R: TRect; ControlWidth, ControlHeight, DropDownWindowWidth, DropDownWindowHeight: Integer; begin if DropDownWindow > 0 then with R do begin with CurItemLink.ItemRect do begin ControlWidth := Right - Left; ControlHeight := Bottom - Top; end; GetWindowRect(DropDownWindow, R); DropDownWindowWidth := Right - Left; DropDownWindowHeight := Bottom - Top; R := GetWorkArea(Point(X, Y)); if (CurItemLink.BarControl is TdxBarSubMenuControl) or CurItemLink.BarControl.IsRealVertical then begin if (X + DropDownWindowWidth > Right) and (X - ControlWidth - Left > Right - X) then Dec(X, ControlWidth + DropDownWindowWidth); if Y + DropDownWindowHeight > Bottom then Y := Bottom - DropDownWindowHeight; end else begin if X + DropDownWindowWidth > Right then X := Right - DropDownWindowWidth; if (Y + DropDownWindowHeight > Bottom) and (Y - ControlHeight - Top > Bottom - Y) then Dec(Y, ControlHeight + DropDownWindowHeight); end; if X < Left then X := Left; if Y < Top then Y := Top; end; end; function TCustomdxBarCombo.CheckKeyForDropDownWindow(Key: Word; Shift: TShiftState): Boolean; begin Result := (Key <> VK_ESCAPE) and (Key <> VK_RETURN) and (Key <> VK_TAB); if Assigned(FOnCheckKeyForDropDownWindow) then FOnCheckKeyForDropDownWindow(Self, Key, Shift, Result); end; procedure TCustomdxBarCombo.CloseUp; begin if DropDownWindow <> 0 then ShowWindow(DropDownWindow, SW_HIDE); CallNotify(FOnCloseUp, Self); end; procedure TCustomdxBarCombo.DrawCustomizingImage(ACanvas: TCanvas; const ARect: TRect; AState: TOwnerDrawState); begin dxBarCustomizingForm.PainterClass.DrawEdit(ACanvas, ARect, Self, odSelected in AState, True); end; procedure TCustomdxBarCombo.DropDown(X, Y: Integer); begin CallNotify(FOnDropDown, Self); if DropDownWindow <> 0 then begin InitDropDownWindow; CheckDropDownPoint(X, Y); SetWindowPos(DropDownWindow, 0, X, Y, 0, 0, SWP_NOZORDER or SWP_NOSIZE or SWP_NOACTIVATE); SetWindowPos(DropDownWindow, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE or SWP_NOSIZE or SWP_SHOWWINDOW or SWP_NOACTIVATE or SWP_FRAMECHANGED); AfterDropDown; end; end; function TCustomdxBarCombo.GetDropDownWindow: HWND; begin Result := 0; if Assigned(FOnGetDropDownWindow) then FOnGetDropDownWindow(Self, Result); end; procedure TCustomdxBarCombo.InitDropDownWindow; begin end; procedure TCustomdxBarCombo.InternalInitDropDownWindow(ADropDownWindow: TWinControl); var ABkColor, ATextColor: COLORREF; AEditControl: TdxBarCustomEditControl; begin AEditControl := TdxBarCustomEditControl(CurItemLink.Control); TControlAccess(ADropDownWindow).Font := AEditControl.EditFont; AEditControl.Painter.EditGetColors(AEditControl, ATextColor, ABkColor); TControlAccess(ADropDownWindow).Color := ABkColor; TControlAccess(ADropDownWindow).Font.Color := ATextColor; end; { TdxBarCustomCombo } constructor TdxBarCustomCombo.Create(AOwner: TComponent); begin inherited Create(AOwner); FDropDownCount := 8; FItemIndex := -1; FItems := TStringList.Create; TStringList(FItems).OnChange := ItemsChanged; FListBox := TdxBarDropDownListBox.Create(Self); with TdxBarDropDownListBox(FListBox) do begin FCombo := Self; OnDrawItem := ListBoxDrawItem; OnMeasureItem := ListBoxMeasureItem; end; end; destructor TdxBarCustomCombo.Destroy; begin FreeAndNil(FListBox); FreeAndNil(FItems); inherited Destroy; end; function TdxBarCustomCombo.GetCurItemIndex: Integer; begin if FocusedItemLink = nil then Result := ItemIndex else Result := TdxBarComboControl(FocusedItemLink.Control).LocalItemIndex; end; function TdxBarCustomCombo.GetItemsHeight(Index: Integer): Integer; begin MeasureItem(Index, Result); end; procedure TdxBarCustomCombo.SetCurItemIndex(Value: Integer); begin if FocusedItemLink = nil then ItemIndex := Value else TdxBarComboControl(FocusedItemLink.Control).LocalItemIndex := Value; end; procedure TdxBarCustomCombo.SetItemIndex(Value: Integer); var AText: string; begin if FItemIndex <> Value then begin FItemIndex := Value; if (FItemIndex < 0) or (FItemIndex > Items.Count - 1) then FItemIndex := -1; if FItemIndex = -1 then AText := '' else AText := Items[FItemIndex]; if Text = AText then begin Update; Change; Update; end else Text := AText; end; end; procedure TdxBarCustomCombo.SetItems(Value: TStrings); begin FItems.Assign(Value); end; procedure TdxBarCustomCombo.SetSorted(Value: Boolean); begin if FSorted <> Value then begin FSorted := Value; TStringList(FItems).Sorted := FSorted; FItemIndex := FItems.IndexOf(Text); end; end; procedure TdxBarCustomCombo.CheckLocalPos; var AText: string; AItemIndex: Integer; begin if (CurItemLink = nil) or not (CurItemLink.Control is TdxBarComboControl) then Exit; AText := TdxBarComboControl(CurItemLink.Control).Text; AItemIndex := TdxBarComboControl(CurItemLink.Control).LocalItemIndex; if not ((0 <= AItemIndex) and (AItemIndex < Items.Count) and (Items[AItemIndex] = AText)) then AItemIndex := GetNearestItemIndex(AText); TdxBarComboControl(CurItemLink.Control).FLocalItemIndex := AItemIndex; if DroppedDown then if (AItemIndex > -1) and (AnsiCompareText(AText, Items[AItemIndex]) = 0) then ListBox.ItemIndex := AItemIndex else begin ListBox.ItemIndex := -1; ListBox.TopIndex := AItemIndex; end; end; procedure TdxBarCustomCombo.ItemsChanged(Sender: TObject); begin if ItemIndex > Items.Count - 1 then ItemIndex := -1 else Update; end; procedure TdxBarCustomCombo.ListBoxDrawItem(Control: TWinControl; Index: Integer; Rect: TRect; State: TOwnerDrawState); begin DrawItem(TdxBarEditControl(CurItemLink.Control), Index, Rect, State); end; procedure TdxBarCustomCombo.ListBoxMeasureItem(Control: TWinControl; Index: Integer; var Height: Integer); begin MeasureItem(Index, Height); end; procedure TdxBarCustomCombo.AfterDropDown; begin with TdxBarDropDownListBox(ListBox) do if LeftButtonPressed then begin SetCapture(Handle); WaitForCapture := True; end else WaitForCapture := False; end; function TdxBarCustomCombo.CheckKeyForDropDownWindow(Key: Word; Shift: TShiftState): Boolean; begin Result := (Shift = []) and ((Key = VK_UP) or (Key = VK_DOWN) or (Key = VK_PRIOR) or (Key = VK_NEXT)); end; procedure TdxBarCustomCombo.CloseUp; begin inherited; FListBox.Parent := nil; end; procedure TdxBarCustomCombo.CurChange; begin inherited; CheckLocalPos; end; procedure TdxBarCustomCombo.DrawInterior(ABarEditControl: TdxBarEditControl; ACanvas: TCanvas; R: TRect; ItemLink: TdxBarItemLink); var AIndex: Integer; begin FCanvas := ACanvas; try if FocusedItemLink = ItemLink then AIndex := TdxBarComboControl(CurItemLink.Control).LocalItemIndex else AIndex := ItemIndex; FInteriorIsDrawing := True; try DrawItem(ABarEditControl, AIndex, R, []); finally FInteriorIsDrawing := False; end; finally FCanvas := nil; end; end; procedure TdxBarCustomCombo.DrawItem(ABarEditControl: TdxBarEditControl; AIndex: Integer; ARect: TRect; AState: TOwnerDrawState); begin if Assigned(FOnDrawItem) then FOnDrawItem(Self, AIndex, ARect, AState) else ABarEditControl.Painter.CustomComboDrawItem(Self, Canvas, AIndex, ARect, AState, FInteriorIsDrawing); if odFocused in AState then DrawFocusRect(Canvas.Handle, ARect); // for hiding focus rect end; procedure TdxBarCustomCombo.DropDown(X, Y: Integer); begin FListBox.Parent := CurItemLink.Control.Parent; //BarManager.MainForm; inherited; CheckLocalPos; end; function TdxBarCustomCombo.GetCanvas: TCanvas; begin if FCanvas <> nil then Result := FCanvas else Result := FListBox.Canvas; end; function TdxBarCustomCombo.GetDropDownWidth: Integer; var I, ItemWidth: Integer; begin Result := DropDownWidth; if Result <= 0 then begin if CurItemLink <> nil then Result := cxRectWidth(TdxBarComboControl(CurItemLink.Control).GetEditRect) - 2 * 2; if DropDownCount < Items.Count then Dec(Result, GetSystemMetrics(SM_CXVSCROLL)); for I := 0 to Items.Count - 1 do begin MeasureItemWidth(I, ItemWidth); if ItemWidth > Result then Result := ItemWidth; end; end; Inc(Result, 2 + 2); if DropDownCount < Items.Count then Inc(Result, GetSystemMetrics(SM_CXVSCROLL)); end; function TdxBarCustomCombo.GetDropDownWindow: HWND; begin Result := inherited GetDropDownWindow; if Result = 0 then Result := FListBox.Handle; end; function TdxBarCustomCombo.GetNearestItemIndex(AText: string): Integer; var AItem: string; FoundChars, I, J: Integer; begin AText := AnsiUpperCase(AText); FoundChars := 0; Result := -1; for I := 0 to Items.Count - 1 do begin AItem := AnsiUpperCase(Items[I]); if Copy(AItem, 1, FoundChars) = Copy(AText, 1, FoundChars) then for J := FoundChars + 1 to Length(AText) do if (J <= Length(AItem)) and (AItem[J] = AText[J]) then begin FoundChars := J; Result := I; if J = Length(AText) then Exit; end else Break; end; end; procedure TdxBarCustomCombo.InitDropDownWindow; var AWidth, AHeight, I: Integer; begin InternalInitDropDownWindow(FListBox); FListBox.Canvas.Font := TdxBarDropDownListBox(FListBox).Font; FListBox.Items.Assign(Items); AWidth := GetDropDownWidth; if DropDownCount > Items.Count then I := Items.Count else I := DropDownCount; AHeight := 2 * 2; for I := 0 to I - 1 do Inc(AHeight, ItemsHeight[I]); SetWindowPos(FListBox.Handle, 0, 0, 0, AWidth, AHeight, SWP_NOZORDER or SWP_NOMOVE or SWP_NOACTIVATE); end; procedure TdxBarCustomCombo.MeasureItem(AIndex: Integer; var AHeight: Integer); begin if ItemHeight <= 0 then AHeight := Canvas.TextHeight('Qq') else AHeight := ItemHeight; if Assigned(FOnMeasureItem) then FOnMeasureItem(Self, AIndex, AHeight); end; procedure TdxBarCustomCombo.MeasureItemWidth(AIndex: Integer; var AWidth: Integer); begin AWidth := 1 + Canvas.TextWidth(Items[AIndex]) + 1; end; procedure TdxBarCustomCombo.SetText(Value: string); begin if (FItemIndex = -1) or (Items[FItemIndex] <> Value) then FItemIndex := Items.IndexOf(Value); inherited; end; { TCustomdxBarSubItem } constructor TCustomdxBarSubItem.Create(AOwner: TComponent); begin inherited Create(AOwner); FItemLinks := TdxBarSubMenuControlItemLinks.Create(BarManager, Self); FShowCaption := True; end; destructor TCustomdxBarSubItem.Destroy; begin DetachingBar := -1; FreeAndNil(FItemLinks); inherited Destroy; end; function TCustomdxBarSubItem.GetDetachingBarIndex: Integer; begin if FDetachingBar = nil then Result := -1 else Result := FDetachingBar.Index; end; function TCustomdxBarSubItem.GetItemOptions: TdxBarItemOptions; begin Result := FItemLinks.ItemOptions; end; procedure TCustomdxBarSubItem.SetBarSize(Value: Integer); begin if Value < 0 then Value := 0; FBarSize := Value; end; procedure TCustomdxBarSubItem.SetDetachingBar(Value: Integer); begin if (BarManager.Bars = nil) or (Value < -1) or (Value > BarManager.Bars.Count - 1) then Value := -1; if DetachingBar <> Value then begin if FDetachingBar <> nil then FDetachingBar.RemoveFreeNotification(Self); if Value = -1 then FDetachingBar := nil else FDetachingBar := BarManager.Bars[Value]; if FDetachingBar <> nil then FDetachingBar.AddFreeNotification(Self); end; end; procedure TCustomdxBarSubItem.SetIsInternal(Value: Boolean); begin if FIsInternal <> Value then begin FIsInternal := Value; FItemLinks.Internal := Value; end; end; procedure TCustomdxBarSubItem.SetItemLinks(Value: TdxBarItemLinks); begin FItemLinks.Assign(Value); end; procedure TCustomdxBarSubItem.SetItemOptions(Value: TdxBarItemOptions); begin FItemLinks.ItemOptions := Value; end; procedure TCustomdxBarSubItem.BarManagerChanged; begin if FItemLinks <> nil then FItemLinks.FBarManager := BarManager; end; function TCustomdxBarSubItem.CanClicked: Boolean; begin Result := False; end; procedure TCustomdxBarSubItem.DoCloseUp; begin CallNotify(FOnCloseUp, Self); end; procedure TCustomdxBarSubItem.DoDetaching; begin CallNotify(FOnDetaching, Self); end; procedure TCustomdxBarSubItem.DoPopup; begin CallNotify(FOnPopup, Self); end; function TCustomdxBarSubItem.HasDesignTimeLinks: Boolean; begin Result := True; end; procedure TCustomdxBarSubItem.InternalDropDown( AItemControl: TdxBarSubItemControl; AByMouse: Boolean); begin if AByMouse then AItemControl.Parent.SetMouseSelectedItem(AItemControl); AItemControl.Parent.BarGetFocus(AItemControl); AItemControl.DropDown(AByMouse); end; function TCustomdxBarSubItem.IsShortCut(AShortCut: TShortCut): Boolean; begin Result := FItemLinks.IsShortCut(AShortCut); end; procedure TCustomdxBarSubItem.ObjectNotification(AOperation: TOperation; AObject: TObject); begin inherited; if (AOperation = opRemove) and (AObject = FDetachingBar) then DetachingBar := -1; end; procedure TCustomdxBarSubItem.CheckLinks(ASource: TCustomIniFile; const ABaseSection: string); begin LoadFromIni(ASource, ABaseSection, skIni); LoadUsageData(ASource, ABaseSection); ItemLinks.CheckLinks(ASource, ABaseSection); end; function TCustomdxBarSubItem.GetIniSection(const ABaseSection: string): string; begin Result := ABaseSection + 'SubItem_' + Name; end; procedure TCustomdxBarSubItem.LoadFromIni(ASource: TCustomIniFile; const ABaseSection: string; AStoringKind: TdxBarStoringKind); begin if (Name <> '') and (ASource.ReadInteger(GetIniSection(ABaseSection), 'ItemLinkCount', -1) > -1) then ItemLinks.LoadFromIni(ASource, GetIniSection(ABaseSection), AStoringKind); end; procedure TCustomdxBarSubItem.LoadUsageData(ASource: TCustomIniFile; const ABaseSection: string); begin ItemLinks.LoadUsageData(ASource, GetIniSection(ABaseSection)); end; procedure TCustomdxBarSubItem.SaveToIni(ADestination: TCustomIniFile; const ABaseSection: string; AStoringKind: TdxBarStoringKind); begin if Name <> '' then ItemLinks.SaveToIni(ADestination, GetIniSection(ABaseSection), AStoringKind); end; // IdxBarLinksOwner function TCustomdxBarSubItem.CanContainItem(AItem: TdxBarItem; out AErrorText: string): Boolean; begin Result := (GetOwnedLinks(AItem) = nil) or not GetOwnedLinks(AItem).IsReferencedBy(Self); if not Result then AErrorText := cxGetResourceString(@dxSBAR_RECURSIVEMENUS); end; function TCustomdxBarSubItem.CreateBarControl: TCustomdxBarControl; begin if CurItemLink <> nil then Result := TdxBarSubMenuControl.Create(CurItemLink.BarManager) else Result := TdxBarSubMenuControl.Create(BarManager); end; function TCustomdxBarSubItem.GetItemLinks: TdxBarItemLinks; begin Result := FItemLinks; end; // IdxBarSubMenuOwner function TCustomdxBarSubItem.GetBarSize: Integer; begin Result := FBarSize; end; procedure TCustomdxBarSubItem.DoPaintBar(Canvas: TCanvas; const R: TRect); begin if Assigned(FOnPaintBar) then FOnPaintBar(Self, Canvas, R); end; function TCustomdxBarSubItem.GetDetachingBar: TdxBar; begin Result := FDetachingBar; end; procedure TCustomdxBarSubItem.DropDown(AByMouse: Boolean = False); var I: Integer; begin for I := 0 to LinkCount - 1 do with Links[I] do if Control is TdxBarSubItemControl and IsWindowVisible(BarControl.Handle) then begin InternalDropDown(TdxBarSubItemControl(Control), AByMouse); Break; end; end; { TdxBarSubItem } constructor TdxBarSubItem.Create(AOwner: TComponent); begin inherited; FAllowCustomizing := True; end; class function TdxBarSubItem.GetNewCaption: string; begin Result := dxSBAR_NEWSUBITEMCAPTION; end; function TdxBarSubItem.HasDesignTimeLinks: Boolean; begin Result := inherited HasDesignTimeLinks and not IsInternal; end; function TdxBarSubItem.InternalCanMergeWith(AItem: TdxBarItem): Boolean; begin Result := AItem is TdxBarSubItem; end; { TCustomdxBarContainerItem } destructor TCustomdxBarContainerItem.Destroy; begin if FNeedClearItemList then ClearItemList; inherited; end; procedure TCustomdxBarContainerItem.AddListedItemLinks(AItemLinks: TdxBarItemLinks; AIndex: Integer; FirstCall: Boolean; CallingItemLink: TdxBarItemLink); begin if FNeedClearItemList then ClearItemList; if FirstCall and Assigned(FOnGetData) then begin FInOnGetData := True; try FOnGetData(Self); finally FInOnGetData := False; end; end; end; procedure TCustomdxBarContainerItem.DeleteListedItemLinks(AItemLinks: TdxBarItemLinks; AIndex: Integer); begin end; procedure TCustomdxBarContainerItem.ClearItemList; begin FNeedClearItemList := False; end; function TCustomdxBarContainerItem.HideWhenRun: Boolean; begin Result := True; end; function TCustomdxBarContainerItem.InternalActuallyVisible: Boolean; begin Result := Assigned(FOnGetData); end; procedure TCustomdxBarContainerItem.ItemsChanged(AItemLinks: TObject); begin if not FInOnGetData and not ResettingToolbar then VisibleChanged; end; procedure TCustomdxBarContainerItem.NeedClearItemList; begin FNeedClearItemList := True; end; { TdxBarListItem } constructor TdxBarListItem.Create(AOwner: TComponent); begin inherited; FItems := TStringList.Create; TStringList(FItems).OnChange := ItemsChanged; FItemIndex := -1; FItemList := TList.Create; FShowNumbers := True; end; destructor TdxBarListItem.Destroy; begin FreeAndNil(FItemList); FreeAndNil(FItems); inherited; end; function TdxBarListItem.GetDataIndex: Integer; var I: Integer; begin Result := -1; if (0 <= FItemIndex) and (FItemIndex < Items.Count) then for I := 0 to FItemIndex do if Items[I] <> ListItemSeparator then Inc(Result); end; procedure TdxBarListItem.SetDataIndex(Value: Integer); var J, I: Integer; begin if Items.Count = 0 then I := -1 else begin J := -1; for I := 0 to Items.Count - 1 do begin if Items[I] <> ListItemSeparator then Inc(J); if J = Value then Break; end; end; ItemIndex := I; end; procedure TdxBarListItem.SetItems(Value: TStrings); begin FItems.Assign(Value); end; procedure TdxBarListItem.ClickItem(Sender: TObject); begin FItemIndex := TComponent(Sender).Tag; DirectClick; end; procedure TdxBarListItem.AddListedItemLinks(AItemLinks: TdxBarItemLinks; AIndex: Integer; FirstCall: Boolean; CallingItemLink: TdxBarItemLink); var I, CurIndex: Integer; IsBeginGroup, ItemListExists: Boolean; begin inherited; IsBeginGroup := False; ItemListExists := FItemList.Count > 0; CurIndex := 0; for I := 0 to Items.Count - 1 do if Items[I] = ListItemSeparator then IsBeginGroup := True else begin if not ItemListExists then begin FItemList.Add(TdxBarButton.Create(BarManager.Owner)); with TdxBarButton(FItemList[CurIndex]) do begin Action := Self.Action; if ShowCheck and (I{CurIndex} = FItemIndex) then begin ButtonStyle := bsChecked; Down := True; end; if FShowNumbers then begin if CurIndex < 9 then FCaption := IntToStr(CurIndex + 1) else FCaption := Chr(Ord('A') + CurIndex - 9); FCaption := '&' + FCaption + ' '; end else FCaption := ''; FCaption := FCaption + GetDisplayText(Items[I]); Hint := GetDisplayHint(Items[I]); Tag := I; //CurIndex; OnClick := ClickItem; Enabled := Self.Enabled; end; end; with AItemLinks.Add do begin FOriginalItemLink := CallingItemLink; Index := AIndex + CurIndex; Item := TdxBarItem(FItemList[CurIndex]); if (CurIndex = 0) or IsBeginGroup then BeginGroup := True; Synchronize(CallingItemLink); end; IsBeginGroup := False; Inc(CurIndex); end; end; procedure TdxBarListItem.ClearItemList; begin if (FItemList <> nil) and (FItemList.Count > 0) and (TdxBarItem(FItemList.First).LinkCount = 0) then while FItemList.Count > 0 do begin TdxBarItem(FItemList.Last).Free; FItemList.Delete(FItemList.Count - 1); end; inherited; end; procedure TdxBarListItem.DeleteListedItemLinks(AItemLinks: TdxBarItemLinks; AIndex: Integer); var I: Integer; begin inherited; for I := 0 to Items.Count - 1 do if Items[I] <> ListItemSeparator then AItemLinks[AIndex].Free; end; function TdxBarListItem.GetDisplayHint(const AText: string): string; begin Result := ''; end; function TdxBarListItem.GetDisplayText(const AText: string): string; begin Result := AText; end; function TdxBarListItem.InternalActuallyVisible: Boolean; begin Result := inherited InternalActuallyVisible or (Items.Count > 0); end; procedure TdxBarListItem.DirectClick; begin if CurItemLink = nil then inherited; end; { TdxBarContainerItem } constructor TdxBarContainerItem.Create(AOwner: TComponent); begin inherited; FItemLinks.OnChange := ItemsChanged; end; procedure TdxBarContainerItem.AddListedItemLinks(AItemLinks: TdxBarItemLinks; AIndex: Integer; FirstCall: Boolean; CallingItemLink: TdxBarItemLink); var I: Integer; begin inherited; if AItemLinks = ItemLinks then Exit; AItemLinks.BeginUpdate; try for I := 0 to FItemLinks.CanVisibleItemCount - 1 do with AItemLinks.Add do begin FOriginalItemLink := CallingItemLink; Assign(FItemLinks.CanVisibleItems[I]); Index := AIndex + I; if (I = 0) and HideWhenRun then BeginGroup := True; Synchronize(FOriginalItemLink); end; finally AItemLinks.EndUpdate; end; end; procedure TdxBarContainerItem.DeleteListedItemLinks(AItemLinks: TdxBarItemLinks; AIndex: Integer); var I: Integer; begin inherited; if AItemLinks = ItemLinks then Exit; for I := 0 to FItemLinks.CanVisibleItemCount - 1 do AItemLinks[AIndex].Free; end; function TdxBarContainerItem.InternalActuallyVisible: Boolean; begin Result := inherited InternalActuallyVisible or IsItemsExist; end; function TdxBarContainerItem.InternalCanMergeWith(AItem: TdxBarItem): Boolean; begin Result := AItem is TdxBarContainerItem; end; function TdxBarContainerItem.IsItemsExist: Boolean; var I: Integer; AItemExists: Boolean; begin Result := ItemLinks.Count > 0; if Result then // check empty items begin AItemExists := False; for I := 0 to ItemLinks.Count - 1 do if ItemLinks[I].Item <> nil then begin AItemExists := True; Break; end; if AItemExists then begin Result := False; for I := 0 to ItemLinks.Count - 1 do if (ItemLinks[I].Item <> nil) and ItemLinks[I].Item.ActuallyVisible then begin Result := True; Break; end; end; end; end; { TdxBarExtraPaneListItem } procedure TdxBarExtraPaneListItem.AddListedItemLinks(AItemLinks: TdxBarItemLinks; AIndex: Integer; FirstCall: Boolean; CallingItemLink: TdxBarItemLink); var AHeader: TdxBarItem; begin inherited; AHeader := TdxBarLabel.Create(BarManager.Owner); FItemList.Add(AHeader); AHeader.Caption := Caption; with AItemLinks.Add do begin FOriginalItemLink := CallingItemLink; Index := AIndex; Item := AHeader; Synchronize(CallingItemLink); end; end; function TdxBarExtraPaneListItem.GetDisplayHint(const AText: string): string; begin Result := AText; end; function TdxBarExtraPaneListItem.GetDisplayText(const AText: string): string; begin Result := ChangeFileExt(ExtractFileName(AText), ''); end; function TdxBarExtraPaneListItem.InternalActuallyVisible: Boolean; begin Result := inherited InternalActuallyVisible or (Caption <> ''); end; { TdxBarItemControlDrawParams } constructor TdxBarItemControlDrawParams.Create(ABarItemControl: TdxBarItemControl); begin inherited Create; FBarItemControl := ABarItemControl; end; procedure TdxBarItemControlDrawParams.SetViewSize(Value: TdxBarItemControlViewSize); begin if FViewSize <> Value then begin FViewSize := Value; if FBarItemControl <> nil then FBarItemControl.ResetCachedValues(False); end; end; { TdxBarEditLikeControlDrawParams } function TdxBarEditLikeControlDrawParams.GetBarEditControl: TdxBarEditControl; begin Result := TdxBarEditControl(BarItemControl); end; { TdxBarStaticLikeControlDrawParams } function TdxBarStaticLikeControlDrawParams.GetBarStaticControl: TdxBarCustomStaticControl; begin Result := TdxBarCustomStaticControl(BarItemControl); end; { TdxBarItemControlViewInfo } constructor TdxBarItemControlViewInfo.Create(AControl: TdxBarItemControl); begin inherited Create(nil); FControl := AControl; FAllowedViewLevels := Control.ViewLevels; FMinPossibleViewLevel := GetMinViewLevel(Control.PossibleViewLevels); FViewLevelForButtonGroup := GetMinViewLevel(FAllowedViewLevels); if FViewLevelForButtonGroup = ivlLargeIconWithText then FViewLevelForButtonGroup := FMinPossibleViewLevel; ResetCachedValues; end; destructor TdxBarItemControlViewInfo.Destroy; begin if not Control.Parent.IsDestroying then Control.Parent.ViewInfo.RemoveItemControlViewInfo(Self); inherited Destroy; end; procedure TdxBarItemControlViewInfo.ResetCachedValues; var AViewLevel: TdxBarItemRealViewLevel; begin for AViewLevel := Low(TdxBarItemRealViewLevel) to High(TdxBarItemRealViewLevel) do FViewLevelInfos[AViewLevel].Calculated := False; end; // IdxBarItemControlViewInfo function TdxBarItemControlViewInfo.GetAlign: TdxBarItemAlign; begin Result := Control.Item.Align; end; function TdxBarItemControlViewInfo.GetAllowedViewLevels: TdxBarItemViewLevels; begin Result := FAllowedViewLevels; end; function TdxBarItemControlViewInfo.GetBounds: TRect; begin Result := FBounds; end; function TdxBarItemControlViewInfo.GetColumnRowCount: Integer; begin Result := FColumnRowCount; end; function TdxBarItemControlViewInfo.GetPosition: TdxBarItemPosition; begin Result := Control.ItemLink.Position; end; function TdxBarItemControlViewInfo.GetPositionInButtonGroup: TdxBarButtonGroupPosition; begin if Control.CanBePartOfButtonGroup then Result := Control.ItemLink.ButtonGroup else Result := bgpNone; end; function TdxBarItemControlViewInfo.GetRealPositionInButtonGroup: TdxBarButtonGroupRealPosition; begin Result := FRealPositionInButtonGroup; end; function TdxBarItemControlViewInfo.GetRow: Integer; begin Result := FRow; end; function TdxBarItemControlViewInfo.GetViewLevel: TdxBarItemViewLevel; begin Result := FViewLevel; end; function TdxBarItemControlViewInfo.GetViewLevelForButtonGroup: TdxBarItemRealViewLevel; begin Result := FViewLevelForButtonGroup; end; function TdxBarItemControlViewInfo.GetWidth( AViewLevel: TdxBarItemRealViewLevel): Integer; begin if not (AViewLevel in GetAllowedViewLevels) then raise Exception.Create('Testing! The level is not allowed'); if not FViewLevelInfos[AViewLevel].Calculated then begin FViewLevelInfos[AViewLevel].Width := Control.GetWidthByViewLevel(AViewLevel); FViewLevelInfos[AViewLevel].Calculated := True; end; Result := FViewLevelInfos[AViewLevel].Width; end; function TdxBarItemControlViewInfo.HasSeparator: Boolean; begin Result := Control.ItemLink.BeginGroup; // TODO check end; procedure TdxBarItemControlViewInfo.SetBounds(const Value: TRect); begin FBounds := Value; end; procedure TdxBarItemControlViewInfo.SetColumnRowCount(Value: Integer); begin FColumnRowCount := Value; end; procedure TdxBarItemControlViewInfo.SetRealPositionInButtonGroup( Value: TdxBarButtonGroupRealPosition); begin FRealPositionInButtonGroup := Value; end; procedure TdxBarItemControlViewInfo.SetRow(Value: Integer); begin FRow := Value; end; procedure TdxBarItemControlViewInfo.SetViewLevel( Value: TdxBarItemViewLevel); begin FViewLevel := Value; end; { TdxCashedImageOptions } constructor TdxCashedImageOptions.Create; begin inherited; FGlyph := TcxBitmap.Create; end; destructor TdxCashedImageOptions.Destroy; begin FreeAndNil(FGlyph); inherited; end; procedure TdxCashedImageOptions.Cash(const ARect: TRect; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; ADrawMode: TcxImageDrawMode; ATransparentColor: TColor; ASmoothImage, AUseLeftBottomPixelAsTransparent: Boolean); var AClientRect: TRect; begin AClientRect := cxRect(0, 0, cxRectWidth(ARect), cxRectHeight(ARect)); FGlyph.SetSize(AClientRect.Right, AClientRect.Bottom); cxDrawImage(FGlyph.Canvas.Handle, AClientRect, AClientRect, AGlyph, AImages, AImageIndex, ADrawMode, ASmoothImage, 0, ATransparentColor, AUseLeftBottomPixelAsTransparent); FCashedDrawMode := ADrawMode; FCashedImages := AImages; FCashedGlyph := AGlyph; FCashed := True; end; function TdxCashedImageOptions.IsCashed(ADrawMode: TcxImageDrawMode; AGlyph: TBitmap; AImages: TCustomImageList): Boolean; begin Result := FCashed and (FCashedDrawMode = ADrawMode) and ((AGlyph <> nil) and (FCashedGlyph = AGlyph) or (AGlyph = nil) and (FCashedImages = AImages)) and not FGlyph.Empty; end; { TdxBarItemControl } constructor TdxBarItemControl.Create(AItemLink: TdxBarItemLink); begin inherited Create; FItemLink := AItemLink; FParent := AItemLink.BarControl; FDrawParams := GetDrawParamsClass.Create(Self); FCashedImageOptions := TdxCashedImageOptions.Create; FViewInfo := GetViewInfoClass.Create(Self); CalcDrawingConsts; FHotPartIndex := icpNone; CalcDrawParams; IdxBarItemControlViewInfo(ViewInfo).SetViewLevel(Parent.GetItemControlDefaultViewLevel(Self)); end; destructor TdxBarItemControl.Destroy; begin AccessibilityHelperOwnerObjectDestroyed(FIAccessibilityHelper); if CanFade then GetFader.Remove(Self); //#DG if (BarManager <> nil) and (BarManager.FSelectedItem = Self) then BarManager.FSelectedItem := nil; if FItemLink <> nil then FItemLink.FControl := nil; if (FParent <> nil) and not BarManager.IsDestroying and (FParent.SelectedControl = Self) and not BarManager.IsCustomizing then if (FItemLink <> nil) and (FItemLink.VisibleIndex <> -1) then FParent.SetMouseSelectedItem(nil) else FParent.SelectedLink := nil; DeleteGDIObject(FBkBrush); cxClearObjectLinks(Self); FreeAndNil(FViewInfo); FreeAndNil(FCashedImageOptions); FreeAndNil(FDrawParams); inherited Destroy; end; procedure TdxBarItemControl.DoCalculateParts; begin CalcDrawParams(False); CalcParts; end; function TdxBarItemControl.FindPartAtPos(APoint: TPoint): Integer; var I: Integer; begin if not PtInRect(ItemBounds, APoint) then Result := icpNone else begin Result := icpNonClient; for I := Low(FParts) to High(FParts) do if PtInRect(FParts[I], APoint) then begin Result := I; Break; end; end; end; function TdxBarItemControl.GetAlign: TdxBarItemAlign; begin Result := Item.Align; if (Result <> iaLeft) and not Parent.CanAlignControl(Self) then Result := iaLeft; end; function TdxBarItemControl.GetBarManager: TdxBarManager; begin if FItemLink <> nil then Result := FItemLink.BarManager else Result := nil; end; function TdxBarItemControl.GetBkBrush: HBRUSH; begin Result := FBkBrush; if Result = 0 then Result := Parent.BkBrush; end; function TdxBarItemControl.GetCanvas: TcxCanvas; begin Result := Parent.Canvas; end; function TdxBarItemControl.GetFlat: Boolean; begin // TODO: obsolete Result := Parent.Flat; end; function TdxBarItemControl.GetIAccessibilityHelper: IdxBarAccessibilityHelper; begin if FIAccessibilityHelper = nil then FIAccessibilityHelper := GetAccessibilityHelper(GetAccessibilityHelperClass.Create(Self)); Result := FIAccessibilityHelper; end; function TdxBarItemControl.GetIsSelected: Boolean; begin Result := (FParent <> nil) and (FParent.SelectedControl = Self) and (Enabled or not FSelectedByMouse); end; function TdxBarItemControl.GetItem: TdxBarItem; begin Result := GetItemByLink(FItemLink); end; function TdxBarItemControl.GetItemBounds: TRect; begin Result := ItemLink.ItemRect; end; function TdxBarItemControl.GetPainterClass: TdxBarPainterClass; begin Result := TdxBarPainterClass(Painter.ClassType); end; function TdxBarItemControl.GetRealHeight: Integer; var ASavedFont: TdxBarSavedFont; begin PrepareCanvasFont(0, Item.Style, ASavedFont); try Result := GetHeight; if (Align = iaClient) and Parent.IsRealVertical then if Parent.IsVertical then Result := MinWidth else Result := MinHeight; finally RestoreCanvasFont(ASavedFont); end; end; function TdxBarItemControl.GetRealWidth: Integer; var ASavedFont: TdxBarSavedFont; begin PrepareCanvasFont(0, Item.Style, ASavedFont); try Result := GetWidth; if (Align = iaClient) and not Parent.IsRealVertical or (Result < MinWidth) then Result := MinWidth; finally RestoreCanvasFont(ASavedFont); end; end; function TdxBarItemControl.GetShowDescription: Boolean; begin Result := (ItemLink.Owner.ItemSize = misLarge) and ItemLink.Owner.ItemShowDescriptions; end; function TdxBarItemControl.GetSubMenuParent: TdxBarSubMenuControl; begin Result := Parent as TdxBarSubMenuControl; end; function TdxBarItemControl.GetUnclickAfterDoing: Boolean; begin if Item is TdxBarButton then Result := Item.UnclickAfterDoing else Result := True; end; function TdxBarItemControl.InternalGetPossibleViewLevels: TdxBarItemViewLevels; begin Result := GetPossibleViewLevels; if Result = [] then raise Exception.Create(ClassName + '.GetPossibleViewLevels = []'); end; procedure TdxBarItemControl.SetPressed(Value: Boolean); begin if FPressed <> Value then begin FPressed := Value; PressedChanged; end; end; //IUnknown function TdxBarItemControl._AddRef: Integer; begin Result := -1; end; function TdxBarItemControl._Release: Integer; begin Result := -1; end; function TdxBarItemControl.QueryInterface(const IID: TGUID; out Obj): HResult; const E_NOINTERFACE = HResult($80004002); begin if GetInterface(IID, Obj) then Result := 0 else Result := E_NOINTERFACE; end; //IdxFadingObject function TdxBarItemControl.CanFade: Boolean; begin Result := GetFader <> nil; end; procedure TdxBarItemControl.DrawBitmap(ABitmap: TBitmap); begin Canvas.Draw(ItemBounds.Left, ItemBounds.Top, ABitmap); end; procedure TdxBarItemControl.GetFadingParams( out AFadeOutImage, AFadeInImage: TBitmap; var AFadeInStageCount, AFadeInStageInterval, AFadeOutStageCount, AFadeOutStageInterval: Integer); begin { AFadeOutImage := TBitmap.Create; AFadeOutImage.Width := cxRectWidth(ItemBounds); AFadeOutImage.Height := cxRectHeight(ItemBounds); AFadeInImage := TBitmap.Create; AFadeInImage.Width := cxRectWidth(ItemBounds); AFadeInImage.Height := cxRectHeight(ItemBounds); FDrawParams.Canvas.Canvas.Handle := AFadeInImage.Canvas.Handle; Paint(Rect(0, 0, AFadeInImage.Width, AFadeInImage.Height), GetPaintType); FDrawParams.Canvas.Canvas.Handle := 0; } end; function TdxBarItemControl.GetFader: TdxFader; begin Result := Parent.GetFader; end; // IdxBarHintKeeper function TdxBarItemControl.DoHint(var ANeedDeactivate: Boolean; out AHintText: string; out AShortCut: string): Boolean; var Action: TBasicAction; begin Result := False; ANeedDeactivate := False; AShortCut := ''; AHintText := ''; if (Parent <> nil) and Parent.CanShowHint and (Parent.ItemAtMousePos = Self) then begin AHintText := GetShortHint(Hint); AShortCut := GetShortCutToHint(ShortCut); Action := Item.Action; if Action is TCustomAction then if not TCustomAction(Action).DoHint(AHintText) then begin ANeedDeactivate := True; Exit; end; Result := True; end; end; function TdxBarItemControl.CreateHintViewInfo(const AHintText, AShortCut: string): TdxBarCustomHintViewInfo; begin Result := Parent.CreateHintViewInfo(AHintText, AShortCut, Item.ScreenTip); end; function TdxBarItemControl.GetEnabled: Boolean; begin if Item <> nil then Result := Item.Enabled else Result := False; end; function TdxBarItemControl.GetHintPosition(const ACursorPos: TPoint; AHeight: Integer): TPoint; begin Result := Parent.GetHintPosition(ViewInfo.Bounds, ACursorPos, AHeight); end; procedure TdxBarItemControl.BeginGroupChanged; begin FParent.RepaintBar; end; procedure TdxBarItemControl.CaptionChanged; begin if Align = iaClient then Repaint else FParent.RepaintBar; end; procedure TdxBarItemControl.EnabledChanged; begin if not Enabled and (Parent.SelectedControl = Self) then Parent.SelectedLink := nil; Repaint; end; procedure TdxBarItemControl.GlyphChanged; function GlyphAreaWidthChanged: Boolean; begin Result := (IdxBarItemControlViewInfo(ViewInfo).GetAllowedViewLevels <> ViewLevels) or ((cpIcon in FDrawParams.ViewStructure) <> (cpIcon in GetViewStructure)); end; begin if GlyphAreaWidthChanged then Parent.RepaintBar else Repaint; end; procedure TdxBarItemControl.HotGlyphChanged; begin // do nothing end; procedure TdxBarItemControl.LargeGlyphChanged; begin if FDrawParams.ViewSize = cvsLarge then if FDrawParams.PaintType <> ptMenu then Parent.RepaintBar else Repaint; end; procedure TdxBarItemControl.PartsChanged; begin DoCalculateParts; Repaint; end; procedure TdxBarItemControl.PaintStyleChanged; begin // do nothing end; procedure TdxBarItemControl.ParentVisibleChange(AIsShowing: Boolean); begin // do nothing end; procedure TdxBarItemControl.PressedChanged; begin if not FPressed then Repaint; end; procedure TdxBarItemControl.RealVisibleChanging(AVisible: Boolean); begin end; procedure TdxBarItemControl.VisibleChanged; begin FParent.RepaintBar; end; procedure TdxBarItemControl.WidthChanged; begin if Parent is TdxBarControl then Parent.RepaintBar; end; procedure TdxBarItemControl.ResetCachedValues(AFull: Boolean); begin if AFull then ViewInfo.ResetCachedValues; FCashedImageOptions.Cashed := False; end; procedure TdxBarItemControl.BeforeDestroyParentHandle; begin end; function TdxBarItemControl.CanBePartOfButtonGroup: Boolean; begin Result := False; end; function TdxBarItemControl.CanClicked: Boolean; begin Result := True; end; function TdxBarItemControl.CanCustomize: Boolean; begin Result := (BarManager = Item.BarManager) or (csAncestor in BarManager.ComponentState); end; function TdxBarItemControl.CanDeselect(ABarManager: TdxBarManager): Boolean; begin Result := CanHide; end; function TdxBarItemControl.CanHide: Boolean; begin Result := True; end; function TdxBarItemControl.CanMouseSelect: Boolean; begin Result := CanSelect; end; function TdxBarItemControl.CanSelect: Boolean; begin Result := not IsSelectionForbidden; end; function TdxBarItemControl.CanShowShortCut: Boolean; begin Result := ItemLink.Owner.ItemShowShortCuts; end; function TdxBarItemControl.CanVisuallyPressed: Boolean; begin Result := not Parent.HideOnClick; end; procedure TdxBarItemControl.CheckHotTrack(APoint: TPoint); var ACurrentHotPart: Integer; begin if Enabled then begin ACurrentHotPart := FindPartAtPos(APoint); if ACurrentHotPart <> FHotPartIndex then begin FHotPartIndex := ACurrentHotPart; Repaint; end; end else FHotPartIndex := icpNone; end; procedure TdxBarItemControl.Click(AByMouse: Boolean; AKey: Char = #0); var AParent: TCustomdxBarControl; begin if Enabled then begin AParent := Parent; ControlClick(AByMouse, AKey); if BarControlExists(AParent) and AParent.IsControlExists(Self) then ControlUnclick(AByMouse); end; end; procedure TdxBarItemControl.ControlActivate(Immediately: Boolean); begin FIsActive := True; end; procedure TdxBarItemControl.ControlInactivate(Immediately: Boolean); begin FIsActive := False; end; procedure TdxBarItemControl.ControlClick(AByMouse: Boolean; AKey: Char = #0); begin end; procedure TdxBarItemControl.ControlUnclick(ByMouse: Boolean); var AItem: TdxBarItem; AItemLink: TdxBarItemLink; AllowClick, AIsDestroyOnClick, AllowPressed: Boolean; // AParent: TCustomdxBarControl; ALinkSelf, ALinkItem: TcxObjectLink; begin if (Self is TdxBarButtonControl) and (Parent.Kind = bkSubMenu) then PlaySound(psMenuCommand); AItemLink := FItemLink.RealItemLink; AItem := FItemLink.Item; AllowClick := CanClicked; AIsDestroyOnClick := IsDestroyOnClick; // AParent := Parent; try if AIsDestroyOnClick then begin AItemLink.BringToTopInRecentList(True); // for TCustomdxBarContainerItem: if AItemLink <> FItemLink then FItemLink.BringToTopInRecentList(True); end; except end; ALinkSelf := cxAddObjectLink(Self); AllowPressed := UnclickAfterDoing and (not AIsDestroyOnClick or CanVisuallyPressed); if AllowPressed then Pressed := True; try if AIsDestroyOnClick then Parent.HideAll else if AItemLink = nil then AItemLink := FItemLink; if AllowClick then begin ALinkItem := cxAddObjectLink(AItem); AItem.FClickItemLink := AItemLink; try AItem.DirectClick; finally if ALinkItem.Ref <> nil then AItem.FClickItemLink := nil; cxRemoveObjectLink(ALinkItem); end; end; finally if (ALinkSelf.Ref <> nil) and AllowPressed {and BarControlExists(AParent)} then Pressed := False; cxRemoveObjectLink(ALinkSelf); end; end; procedure TdxBarItemControl.ControlGetFocus(AIsSelected: Boolean; var AProcessed: Boolean); begin Parent.IsDowned := False; Parent.SetKeySelectedItem(Self); end; procedure TdxBarItemControl.DblClick; begin end; function TdxBarItemControl.DrawSelected: Boolean; begin Result := IsSelected; end; function TdxBarItemControl.GetSelectableObject: TPersistent; begin Result := ItemLink; end; function TdxBarItemControl.WantsDblClick: Boolean; begin Result := BarManager.Designing or IsExpandable; end; procedure TdxBarItemControl.KeyDown(var Key: Word; Shift: TShiftState); begin end; procedure TdxBarItemControl.KeyUp(var Key: Word; Shift: TShiftState); begin end; procedure TdxBarItemControl.KeyPress(var Key: Char); begin end; procedure TdxBarItemControl.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin // do nothing; end; procedure TdxBarItemControl.MouseEnter(Shift: TShiftState; X, Y: Integer); begin CheckHotTrack(Point(X, Y)); end; procedure TdxBarItemControl.MouseLeave; begin CheckHotTrack(Point(-1, -1)); end; procedure TdxBarItemControl.MouseMove(Shift: TShiftState; X, Y: Integer); begin CheckHotTrack(Point(X, Y)); end; procedure TdxBarItemControl.MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin // do nothing; end; function TdxBarItemControl.WantsKey(Key: Word): Boolean; begin Result := False; end; function TdxBarItemControl.GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; begin Result := TdxBarItemControlAccessibilityHelper; end; function TdxBarItemControl.GetPossibleViewLevels: TdxBarItemViewLevels; begin Result := [ivlSmallIconWithText]; if IconAssigned(cvsSmall) then Include(Result, ivlSmallIcon); end; function TdxBarItemControl.GetViewLevels: TdxBarItemViewLevels; begin Result := PossibleViewLevels; if Result * ItemLink.GetAllowedViewLevels <> [] then Result := Result * ItemLink.GetAllowedViewLevels; end; function TdxBarItemControl.GetViewStructure: TdxBarItemControlViewStructure; begin case ViewInfo.ViewLevel of ivlLargeIconWithText, ivlSmallIconWithText: begin Result := [cpText]; if IconAssigned(GetViewSize) then Include(Result, cpIcon); end; ivlSmallIcon: if IconAssigned(GetViewSize) then Result := [cpIcon] else Result := []; ivlControlOnly: Result := []; ivlDefault: Result := GetDefaultViewStructure; end; end; function TdxBarItemControl.GetDefaultViewStructure: TdxBarItemControlViewStructure; begin Result := []; end; function TdxBarItemControl.GetViewSize: TdxBarItemControlViewSize; begin case ViewInfo.ViewLevel of ivlLargeIconWithText: Result := cvsLarge; ivlSmallIconWithText, ivlSmallIcon: Result := cvsSmall; else Result := GetDefaultViewSize; end; end; function TdxBarItemControl.GetDefaultViewSize: TdxBarItemControlViewSize; begin if MenuItemSize = misLarge then Result := cvsLarge else if BarManager.LargeIcons then Result := cvsMedium else Result := cvsSmall; end; function TdxBarItemControl.GetPaintType: TdxBarPaintType; begin Result := Parent.GetPaintType; end; function TdxBarItemControl.GetPartCount: Integer; begin Result := 1; end; function TdxBarItemControl.GetViewInfoClass: TdxBarItemControlViewInfoClass; begin Result := TdxBarItemControlViewInfo; end; function TdxBarItemControl.GrayScale: Boolean; begin Result := False; end; function TdxBarItemControl.HasIcon(AViewSize: TdxBarItemControlViewSize; AViewStructure: TdxBarItemControlViewStructure): Boolean; begin Result := IconAssigned(AViewSize) and (cpIcon in AViewStructure); end; function TdxBarItemControl.IconAssigned(AViewSize: TdxBarItemControlViewSize): Boolean; var ACurrentGlyph: TBitmap; ACurrentImageIndex: Integer; ACurrentImages: TCustomImageList; begin Result := GetCurrentImage(AViewSize, False, ACurrentGlyph, ACurrentImages, ACurrentImageIndex); end; procedure TdxBarItemControl.FrameAndFillRect(DC: HDC; var R: TRect; Enabled, Selected, Pressed: Boolean); begin Painter.FrameAndFillRect(Self, DC, R, Enabled, Selected, Pressed); end; procedure TdxBarItemControl.GetArrowParams(out ABrush: HBRUSH; out AArrowColor: COLORREF); begin Painter.GetArrowParams(FDrawParams, ABrush, AArrowColor); end; function TdxBarItemControl.GetCaption: string; begin if FItemLink <> nil then Result := FItemLink.Caption else Result := ''; end; function TdxBarItemControl.GetControl: TControl; begin Result := nil; end; function TdxBarItemControl.GetDrawParamsClass: TdxBarItemControlDrawParamsClass; begin Result := TdxBarItemControlDrawParams; end; function TdxBarItemControl.GetGlyph: TBitmap; begin if FItemLink <> nil then Result := FItemLink.Glyph else Result := nil; end; function TdxBarItemControl.GetImageEnabled(APaintType: TdxBarPaintType): Boolean; begin Result := Enabled or (FDrawParams.ViewSize <> cvsLarge) and (BarManager.DisabledImages <> nil) and not IsGlyphAssigned(Glyph) or (FDrawParams.ViewSize = cvsLarge) and (BarManager.DisabledLargeImages <> nil) and not IsGlyphAssigned(LargeGlyph); end; function TdxBarItemControl.GetImageIndex: Integer; begin Result := Item.ImageIndex; end; function TdxBarItemControl.GetImageList(AViewSize: TdxBarItemControlViewSize; AInToolbar: Boolean): TCustomImageList; var AUseLarge: Boolean; begin AUseLarge := AInToolbar and BarManager.LargeIcons and BarManager.IsLargeImagesForLargeIcons or (AViewSize = cvsLarge); if AUseLarge then Result := LargeImages else Result := Images; end; function TdxBarItemControl.GetImages: TCustomImageList; begin if not Enabled and (BarManager.DisabledImages <> nil) then Result := BarManager.DisabledImages else Result := BarManager.Images; end; function TdxBarItemControl.GetHint; begin if Item <> nil then Result := Item.Hint else Result := ''; end; function TdxBarItemControl.GetHotImages: TCustomImageList; begin Result := FItemLink.Item.BarManager.HotImages; end; function TdxBarItemControl.GetLargeGlyph: TBitmap; begin Result := Item.LargeGlyph; end; function TdxBarItemControl.GetLargeImageIndex: Integer; begin Result := Item.LargeImageIndex; end; function TdxBarItemControl.GetLargeImages: TCustomImageList; begin if not Enabled and (BarManager.DisabledLargeImages <> nil) then Result := BarManager.DisabledLargeImages else Result := BarManager.LargeImages; end; function TdxBarItemControl.GetMenuItemSize: TdxBarMenuItemSize; begin Result := ItemLink.Owner.ItemSize; end; function TdxBarItemControl.GetPainter: TdxBarPainter; begin Result := Parent.Painter; end; function TdxBarItemControl.GetShortCut; begin if Item <> nil then Result := Item.ShortCut else Result := 0; end; function TdxBarItemControl.GetTextAreaOffset: Integer; begin Result := Painter.TextAreaOffset(Self); end; procedure TdxBarItemControl.CalcDrawParams(AFull: Boolean = True); begin if AFull then begin FDrawParams.Caption := Caption; FDrawParams.Description := Item.Description; FDrawParams.ShortCut := ''; FDrawParams.PaintType := GetPaintType; FDrawParams.Enabled := Enabled; FDrawParams.CanSelect := CanSelect; FDrawParams.DrawSelected := DrawSelected; FDrawParams.IsDropDown := IsDropDown; FDrawParams.HotPartIndex := FHotPartIndex; FDrawParams.IsCustomizing := FParent.IsCustomizing; FDrawParams.SelectedByKey := DrawSelected and not FSelectedByMouse; end; FDrawParams.Canvas := Canvas; FDrawParams.ViewSize := GetViewSize; FDrawParams.ViewStructure := GetViewStructure; FDrawParams.DefaultButtonSize := Painter.GetButtonSize(BarManager.GlyphSize, GetTextSize); end; procedure TdxBarItemControl.CalcParts; var I: Integer; begin SetLength(FParts, GetPartCount); for I := Low(FParts) to High(FParts) do FParts[I] := ItemBounds; end; procedure TdxBarItemControl.CalcDrawingConsts; var ASavedFont: TdxBarSavedFont; begin PrepareCanvasFont(0, Item.Style, ASavedFont); try DoCalcDrawingConsts; finally RestoreCanvasFont(ASavedFont); end; end; procedure TdxBarItemControl.DoCalcDrawingConsts; var ATextViewParams: TcxViewParams; begin DeleteGDIObject(FBkBrush); if Item.IsStyleColorSupported then begin Item.GetTextViewParams(ATextViewParams); if ATextViewParams.Color <> clDefault then FBkBrush := CreateSolidBrush(ColorToRGB(ATextViewParams.Color)); end; FTextSize := Parent.GetTextSize; end; procedure TdxBarItemControl.DoPaint(ARect: TRect; PaintType: TdxBarPaintType); var ASavedFont: TdxBarSavedFont; begin if not IsRectEmpty(ARect) then begin PrepareCanvasFont(0, Item.Style, ASavedFont); try CalcDrawParams; Paint(ARect, PaintType); finally RestoreCanvasFont(ASavedFont); end; end; end; procedure TdxBarItemControl.Paint(ARect: TRect; PaintType: TdxBarPaintType); begin end; procedure TdxBarItemControl.PrepareCanvasFont(ABaseFont: HFONT; AStyle: TcxStyle; out ASavedFont: TdxBarSavedFont); var ABaseLogFont, ALogFont: TLogFont; begin ASavedFont.Saved := (AStyle <> nil) and (svFont in AStyle.AssignedValues) or (ABaseFont <> 0); if ASavedFont.Saved then begin cxGetFontData(Canvas.Font.Handle, ASavedFont.LogFont); if ABaseFont <> 0 then cxGetFontData(ABaseFont, ABaseLogFont) else ABaseLogFont := ASavedFont.LogFont; if (AStyle <> nil) and (svFont in AStyle.AssignedValues) then begin cxGetFontData(AStyle.Font.Handle, ALogFont); ALogFont.lfEscapement := ABaseLogFont.lfEscapement; ALogFont.lfOrientation := ALogFont.lfEscapement; ALogFont.lfOutPrecision := ABaseLogFont.lfOutPrecision; Canvas.Font.Handle := CreateFontIndirect(ALogFont); end else Canvas.Font.Handle := CreateFontIndirect(ABaseLogFont); end; end; procedure TdxBarItemControl.RestoreCanvasFont(const ASavedFont: TdxBarSavedFont); begin if ASavedFont.Saved then Canvas.Font.Handle := CreateFontIndirect(ASavedFont.LogFont); end; function TdxBarItemControl.GetOwnedBarControl: TCustomdxBarControl; begin Result := nil; end; function TdxBarItemControl.GetCaptionWidth: Integer; var ASavedFont: TdxBarSavedFont; begin PrepareCanvasFont(0, Item.Style, ASavedFont); try Result := cxRectWidth(Painter.GetControlCaptionRect(FDrawParams)); finally RestoreCanvasFont(ASavedFont); end; end; function TdxBarItemControl.GetCurrentImage(AViewSize: TdxBarItemControlViewSize; ASelected: Boolean; out ACurrentGlyph: TBitmap; out ACurrentImages: TCustomImageList; out ACurrentImageIndex: Integer): Boolean; function GetCurrentImageIndex: Integer; begin if (AViewSize = cvsLarge) and (LargeImageIndex <> -1) then Result := LargeImageIndex else Result := ImageIndex; end; begin if AViewSize = cvsLarge then ACurrentGlyph := Item.LargeGlyph else ACurrentGlyph := Glyph; if not IsGlyphAssigned(ACurrentGlyph) then ACurrentGlyph := nil; ACurrentImages := GetImageList(AViewSize, GetPaintType <> ptMenu); ACurrentImageIndex := GetCurrentImageIndex; Result := IsGlyphAssigned(ACurrentGlyph) or Item.IsImageIndexLinked(ACurrentImages, ACurrentImageIndex); if not Result then begin ACurrentGlyph := Parent.GetDefaultItemGlyph; Result := IsGlyphAssigned(ACurrentGlyph); end; end; function TdxBarItemControl.GetGlyphSize(AViewSize: TdxBarItemControlViewSize; ASelected: Boolean = False): TSize; var ACurrentGlyph: TBitmap; ACurrentImages: TCustomImageList; ACurrentImageIndex: Integer; begin if not GetCurrentImage(AViewSize, ASelected, ACurrentGlyph, ACurrentImages, ACurrentImageIndex) then begin if AViewSize = cvsLarge then Result := cxClasses.Size(20, 20) else Result := cxClasses.Size(BarManager.GlyphSize, BarManager.GlyphSize); end else if ACurrentGlyph = nil then Result := cxClasses.Size(ACurrentImages.Width, ACurrentImages.Height) else Result := cxClasses.Size(ACurrentGlyph.Width, ACurrentGlyph.Height); end; function TdxBarItemControl.GetIndents(ADrawAreaType: TdxBarItemControlPart): TRect; begin Result := Painter.ItemControlGetIndents(FDrawParams, ADrawAreaType); end; function TdxBarItemControl.GetRotationDependentHeight(ASourceSize: TSize): Integer; begin if IsRotated then Result := ASourceSize.cx else Result := ASourceSize.cy; end; function TdxBarItemControl.GetRotationDependentWidth(ASourceSize: TSize): Integer; begin if IsRotated then Result := ASourceSize.cy else Result := ASourceSize.cx; end; function TdxBarItemControl.GetTextExtent(const AText: string): TSize; var ASavedFont: TdxBarSavedFont; begin PrepareCanvasFont(0, Item.Style, ASavedFont); try Result := Parent.Canvas.TextExtent(AText); finally RestoreCanvasFont(ASavedFont); end; end; function TdxBarItemControl.GetTextHeight: Integer; begin Result := GetTextExtent('Qq').cy; end; function TdxBarItemControl.GetTextSize: Integer; begin if (Item.Style <> nil) and (svFont in Item.Style.AssignedValues) then Result := FTextSize else Result := Parent.TextSize; end; function TdxBarItemControl.GetTextWidth(const AText: string): Integer; begin Result := GetTextExtent(AText).cx; end; function TdxBarItemControl.GetCaptionAreaWidth: Integer; function GetTailAreaSize: Integer; begin Result := Painter.GetTailAreaSize(FDrawParams); end; function GetShortCutAreaSize: Integer; begin if CanShowShortCut and (ShortCut <> 0) then Result := Parent.TextSize - 6 + GetTextWidth(FDrawParams.ShortCut) else Result := 0; end; var ADescriptionWidth: Integer; begin if cpText in FDrawParams.ViewStructure then begin if FDrawParams.PaintType = ptMenu then begin Result := GetCaptionWidth + GetShortCutAreaSize; if (MenuItemSize = misLarge) and ShowDescription and (FDrawParams.Description <> '') then begin ADescriptionWidth := cxRectWidth(cxGetTextRect(Canvas.Handle, FDrawParams.Description, 2)); Result := Max(Result, ADescriptionWidth); end; Inc(Result, GetIndents(cpText).Left + GetIndents(cpText).Right); Inc(Result, GetTailAreaSize); end else begin Result := GetCaptionWidth; if cpIcon in FDrawParams.ViewStructure then Inc(Result, Painter.GetControlTextIndents.Left) else Inc(Result, GetControlCaptionOffset * 2); end end else Result := 0; end; function TdxBarItemControl.GetControlAreaWidth: Integer; begin Result := 0; end; function TdxBarItemControl.GetGlyphAreaWidth: Integer; begin if FDrawParams.PaintType = ptMenu then Result := Parent.IconAreaSize else if cpIcon in FDrawParams.ViewStructure then Result := GetRotationDependentWidth(FDrawParams.DefaultButtonSize) else Result := 0; end; function TdxBarItemControl.GetControlCaptionOffset: Integer; begin Result := Parent.Font.Size div 2; end; function TdxBarItemControl.GetDefaultHeight: Integer; begin if Parent.Kind = bkSubMenu then Result := GetDefaultHeightInSubMenu else if IsRotated then Result := InternalGetDefaultWidth else Result := InternalGetDefaultHeight; end; function TdxBarItemControl.GetDefaultWidth: Integer; begin if FDrawParams.PaintType = ptMenu then Result := GetDefaultWidthInSubMenu else if IsRotated then Result := InternalGetDefaultHeight else Result := InternalGetDefaultWidth; end; function TdxBarItemControl.GetDefaultWidthHorzLayout: Integer; begin Result := GetGlyphAreaWidth + GetCaptionAreaWidth + GetControlAreaWidth; end; function TdxBarItemControl.GetDefaultWidthVertLayout: Integer; var W: Integer; begin Result := GetRotationDependentWidth(GetGlyphSize(cvsLarge)); if cpText in FDrawParams.ViewStructure then begin W := 3 + GetCaptionWidth + 3; if Item.GlyphLayout in [glLeft, glRight] then Inc(Result, W) else Result := Max(Result, W); end; Inc(Result, 1 + 4 + 4 + 1); end; function TdxBarItemControl.GetDefaultHeightInSubMenu: Integer; begin Result := Parent.GetDefaultItemHeight(Self); Painter.CorrectButtonControlDefaultHeight(Result); end; function TdxBarItemControl.GetDefaultWidthInSubMenu: Integer; begin Result := GetDefaultWidthHorzLayout; Painter.CorrectButtonControlDefaultWidth(Result); end; function TdxBarItemControl.GetMinHeight: Integer; begin Result := 1; end; function TdxBarItemControl.GetMinWidth: Integer; begin Result := 1; end; function TdxBarItemControl.GetHeight: Integer; begin CalcDrawParams(False); Result := GetDefaultHeight; end; function TdxBarItemControl.GetWidth: Integer; begin CalcDrawParams(False); Result := GetDefaultWidth; end; function TdxBarItemControl.GetWidthByViewLevel( AViewLevel: TdxBarItemRealViewLevel): Integer; var APrevViewLevel: TdxBarItemViewLevel; begin APrevViewLevel := ViewInfo.ViewLevel; try IdxBarItemControlViewInfo(ViewInfo).SetViewLevel(AViewLevel); Result := Width; finally IdxBarItemControlViewInfo(ViewInfo).SetViewLevel(APrevViewLevel); end; end; function TdxBarItemControl.InternalGetDefaultHeight: Integer; begin if FDrawParams.ViewSize = cvsLarge then Result := GetLargeHeight else Result := GetSmallHeight; end; function TdxBarItemControl.GetLargeHeight: Integer; var H: Integer; begin Result := GetRotationDependentHeight(GetGlyphSize(cvsLarge)); if cpText in FDrawParams.ViewStructure then begin H := GetTextHeight; if Item.GlyphLayout in [glTop, glBottom] then Inc(Result, H + 1) else Result := Max(Result, H); end; Inc(Result, 1 + 2 + 2 + 1); end; function TdxBarItemControl.GetSmallHeight: Integer; begin Result := 0; if cpText in FDrawParams.ViewStructure then Result := Max(Result, GetTextSize); if cpIcon in FDrawParams.ViewStructure then Result := Max(Result, GetRotationDependentHeight(FDrawParams.DefaultButtonSize)); end; function TdxBarItemControl.InternalGetDefaultWidth: Integer; begin if FDrawParams.ViewSize = cvsLarge then Result := GetDefaultWidthVertLayout else Result := GetDefaultWidthHorzLayout; end; function TdxBarItemControl.HasHint: Boolean; begin Result := (Hint <> '') and (Parent is TdxBarControl); end; function TdxBarItemControl.HasShadow: Boolean; begin Result := FParent.ChildrenHaveShadows; end; function TdxBarItemControl.HotPartWantMouse: Boolean; begin Result := WantMouse; end; function TdxBarItemControl.IsBkColorAssigned: Boolean; begin Result := FBkBrush <> 0; end; function TdxBarItemControl.IsChildWindow(AWnd: HWND): Boolean; begin Result := IsChildEx(Parent.Handle, AWnd); end; function TdxBarItemControl.IsDestroyOnClick: Boolean; begin Result := True; end; function TdxBarItemControl.IsDropDown: Boolean; begin Result := False; end; function TdxBarItemControl.IsExpandable: Boolean; begin Result := False; end; function TdxBarItemControl.IsInvertTextColor: Boolean; begin Result := False; end; function TdxBarItemControl.IsMenuItem: Boolean; begin Result := False; end; function TdxBarItemControl.IsRotated: Boolean; begin Result := Parent.IsVertical; end; function TdxBarItemControl.IsSelectionForbidden: Boolean; begin Result := (Parent.IsCustomizing and (BarManager <> Item.BarManager) and not (csAncestor in BarManager.ComponentState)); end; function TdxBarItemControl.MousePressed: Boolean; var R: TRect; P: TPoint; begin R := Parent.GetItemRect(Self); P := Parent.ScreenToClient(GetMouseCursorPos); Result := Enabled and PtInRect(R, P); if Result then if InMouseHook then Result := LeftButtonPressed else Result := GetKeyState(VK_LBUTTON) < 0; end; function TdxBarItemControl.NeedCaptureMouse: Boolean; begin Result := False; end; function TdxBarItemControl.WantMouse: Boolean; begin Result := CanSelect or CanClicked; end; procedure TdxBarItemControl.CheckNonRecent; begin if Parent.Kind = bkSubMenu then SubMenuParent.FNonRecent := FNonRecent; end; procedure TdxBarItemControl.UncheckNonRecent; begin if Parent.Kind = bkSubMenu then SubMenuParent.FNonRecent := False; end; procedure TdxBarItemControl.BeginResize(APoint: TPoint); begin // do nothing end; function TdxBarItemControl.CanResize(APoint: TPoint): Boolean; begin Result := False; end; procedure TdxBarItemControl.EndResize(AAllowResize: Boolean); begin // do nothing end; procedure TdxBarItemControl.Resizing(APoint: TPoint); begin // do nothing end; class function TdxBarItemControl.HasWindow: Boolean; begin Result := False; end; function TdxBarItemControl.IsDroppedDown: Boolean; begin Result := False; end; procedure TdxBarItemControl.Repaint; begin Parent.UpdateItem(Self); end; { TdxBarCustomStaticControl} function TdxBarCustomStaticControl.CanClicked: Boolean; begin Result := False; end; function TdxBarCustomStaticControl.CanSelect: Boolean; begin Result := inherited CanSelect and BarManager.IsCustomizing; end; function TdxBarCustomStaticControl.GetDefaultViewStructure: TdxBarItemControlViewStructure; begin Result := []; if Item.ShowCaption then Result := [cpText]; if IconAssigned(GetViewSize) then Include(Result, cpIcon); end; function TdxBarCustomStaticControl.GetDrawParamsClass: TdxBarItemControlDrawParamsClass; begin Result := TdxBarStaticLikeControlDrawParams; end; procedure TdxBarCustomStaticControl.Paint(ARect: TRect; PaintType: TdxBarPaintType); begin Painter.DrawStaticGlyphAndCaption(DrawParams, ARect); end; function TdxBarCustomStaticControl.GetDrawParams: TdxBarStaticLikeControlDrawParams; begin Result := TdxBarStaticLikeControlDrawParams(FDrawParams); end; { TdxBarSeparatorControl } procedure TdxBarSeparatorControl.CalcDrawParams(AFull: Boolean = True); begin inherited; DrawParams.IsTop := ItemLink.VisibleIndex = 0; end; function TdxBarSeparatorControl.GetIndents(ADrawAreaType: TdxBarItemControlPart): TRect; begin Result := Painter.SeparatorControlGetIndents(DrawParams, ADrawAreaType); end; function TdxBarSeparatorControl.GetMenuItemSize: TdxBarMenuItemSize; begin Result := misNormal; end; function TdxBarSeparatorControl.GetGlyphAreaWidth: Integer; begin Result := 0; end; function TdxBarSeparatorControl.GetDefaultHeightInSubMenu: Integer; const ASeparatorsCount: array [Boolean] of Integer = (2, 1); begin if cpText in DrawParams.ViewStructure then Result := inherited GetDefaultHeightInSubMenu + Painter.SubMenuGetSeparatorSize * ASeparatorsCount[DrawParams.IsTop] else Result := Parent.BeginGroupSize end; function TdxBarSeparatorControl.GetDefaultWidthInSubMenu: Integer; begin Result := inherited GetDefaultWidthInSubMenu; end; function TdxBarSeparatorControl.GetMinWidth: Integer; begin Result := Parent.IconAreaSize + Painter.GetTailAreaSize(FDrawParams); end; function TdxBarSeparatorControl.InternalGetDefaultHeight: Integer; begin Result := GetTextSize; end; function TdxBarSeparatorControl.InternalGetDefaultWidth: Integer; begin Result := Parent.BeginGroupSize; end; procedure TdxBarSeparatorControl.PrepareCanvasFont(ABaseFont: HFONT; AStyle: TcxStyle; out ASavedFont: TdxBarSavedFont); begin Canvas.Font.Style := [fsBold]; end; procedure TdxBarSeparatorControl.RestoreCanvasFont(const ASavedFont: TdxBarSavedFont); begin Canvas.Font.Style := []; end; function TdxBarSeparatorControl.GetDefaultViewStructure: TdxBarItemControlViewStructure; begin if (DrawParams.PaintType = ptMenu) and Item.ShowCaption then Result := [cpText] else Result := []; end; function TdxBarSeparatorControl.GetDrawParamsClass: TdxBarItemControlDrawParamsClass; begin Result := TdxBarSeparatorControlDrawParams; end; procedure TdxBarSeparatorControl.Paint(ARect: TRect; PaintType: TdxBarPaintType); begin Painter.DrawSeparatorControl(DrawParams, ARect); end; function TdxBarSeparatorControl.GetDrawParams: TdxBarSeparatorControlDrawParams; begin Result := TdxBarSeparatorControlDrawParams(FDrawParams); end; { TdxBarWinControl } procedure TdxBarWinControl.DefaultHandler(var Message); begin inherited; if Handle <> 0 then with TMessage(Message) do Result := CallWindowProc(FPrevDefWndProc, Handle, Msg, WParam, LParam); end; class function TdxBarWinControl.HasWindow: Boolean; begin Result := True; end; function TdxBarWinControl.HandleAllocated: Boolean; begin Result := Handle <> 0; end; function TdxBarWinControl.DoCallKeyboardHook(wParam: WParam; lParam: LParam): Boolean; begin DontCallNextKeybHook := True; try Result := dxBarKeyboardHook(0, WParam, LParam) = 1; finally DontCallNextKeybHook := False; end; end; function TdxBarWinControl.GetItem: TdxBarWindowItem; begin Result := TdxBarWindowItem(ItemLink.Item); end; function TdxBarWinControl.GetWindowRect: TRect; begin if Enabled and not Item.EmptyWindow then Result := FWindowRect else Result := cxEmptyRect; end; procedure TdxBarWinControl.SetWindowRect(const Value: TRect); var R: TRect; begin FWindowRect := Value; if IsWindowVisible(Handle) then begin Windows.GetWindowRect(Handle, R); if not EqualRect(R, FWindowRect) then begin with WindowRect do SetWindowPos(Handle, 0, Left, Top, Right - Left, Bottom - Top, SWP_NOZORDER or SWP_NOACTIVATE {SWP_SHOWWINDOW}); if (Self is TdxBarEditControl) then Painter.EditControlPrepareEditWnd(TdxBarEditControl(Self), Handle); end; end; end; function TdxBarWinControl.CanClicked: Boolean; begin Result := FParent.IsVertical; end; function TdxBarWinControl.CanDeselect(ABarManager: TdxBarManager): Boolean; begin Result := inherited CanDeselect(ABarManager) and ((BarManager = ABarManager) or IsMDIForm(ABarManager.MasterForm) and IsMDIChild(BarManager.MasterForm) and not FFocusing); end; function TdxBarWinControl.CanSelect: Boolean; begin Result := inherited CanSelect and Item.CanSelect; end; procedure TdxBarWinControl.ControlInactivate(Immediately: Boolean); begin inherited; Focused := False; end; procedure TdxBarWinControl.ControlClick(AByMouse: Boolean; AKey: Char = #0); begin Focused := True; inherited; ActivateEdit(AByMouse, AKey); end; procedure TdxBarWinControl.ControlGetFocus(AIsSelected: Boolean; var AProcessed: Boolean); begin if AIsSelected and Focused then begin AProcessed := True; if not PtInRect(WindowRect, GetMouseCursorPos) then TransferMessage(Parent.Handle, Parent.FCurrentMessage); end else inherited end; procedure TdxBarWinControl.EnabledChanged; begin Focused := False; inherited; end; function TdxBarWinControl.GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; begin Result := TdxBarWinControlAccessibilityHelper; end; function TdxBarWinControl.IsChildWindow(AWnd: HWND): Boolean; begin Result := inherited IsChildWindow(AWnd) or IsChildEx(Handle, AWnd); end; function TdxBarWinControl.IsDestroyOnClick: Boolean; begin Result := False; end; function TdxBarWinControl.IsWindowEnabled: Boolean; begin Result := Parent.IsWindowEnabled and (not HandleAllocated or Windows.IsWindowEnabled(Handle)); end; procedure TdxBarWinControl.KeyDown(var Key: Word; Shift: TShiftState); function IsSysKeyDown: Boolean; begin Result := (Key = VK_F10) or (Key = VK_MENU) or (ssAlt in Shift); end; var ALinkSelf: TcxObjectLink; begin if IsSysKeyDown then SysKeyDown(Key, Shift) else begin ALinkSelf := cxAddObjectLink(Self); try Item.KeyDown(Key, Shift); if ALinkSelf.Ref = nil then Key := 0; case Key of VK_ESCAPE: begin DoEscape; Key := 0; end; VK_RETURN: begin DoEnter; Key := 0; end; VK_TAB: begin DoNavigation; Key := 0; end; end; finally cxRemoveObjectLink(ALinkSelf); end; end; end; procedure TdxBarWinControl.KeyPress(var Key: Char); begin Item.KeyPress(Key); end; procedure TdxBarWinControl.KeyUp(var Key: Word; Shift: TShiftState); function IsSysKeyUp: Boolean; begin Result := (Key = VK_MENU) or (ssAlt in Shift); end; begin if IsSysKeyUp then SyskeyUp(Key, Shift) else Item.KeyUp(Key, Shift); end; function TdxBarWinControl.ClientToParent(const APoint: TPoint): TPoint; begin Result := APoint; MapWindowPoint(Handle, Parent.Handle, Result); end; function TdxBarWinControl.ParentToClient(const APoint: TPoint): TPoint; begin Result := APoint; MapWindowPoint(Parent.Handle, Handle, Result); end; procedure TdxBarWinControl.CreateInnerEdit; begin if Handle <> 0 then begin FDefWndProc := MakeObjectInstance(WndProc); FPrevDefWndProc := Pointer(SetWindowLong(Handle, GWL_WNDPROC, Longint(FDefWndProc))); end; end; procedure TdxBarWinControl.DestroyInnerEdit(AFullDestroy: Boolean = True); begin if Handle <> 0 then begin Focused := False; SetWindowLong(Handle, GWL_WNDPROC, Longint(FPrevDefWndProc)); FreeObjectInstance(FDefWndProc); FDefWndProc := nil; end; end; procedure TdxBarWinControl.DoEnter; var AHandle: HWND; AParent: TCustomdxBarControl; begin AHandle := Handle; AParent := Parent; if (ItemLink.RealItemLink <> nil) then ItemLink.RealItemLink.BringToTopInRecentList(True); StoreDisplayValue; if IsWindowVisible(AHandle) then begin AParent.SetKeySelectedItem(nil); KillBeep(AHandle); AParent.HideAll; end; end; procedure TdxBarWinControl.DoEscape; begin Parent.SetKeySelectedItem(nil); KillBeep(Handle); Parent.AfterControlEscape(Self); end; procedure TdxBarWinControl.DoNavigation; begin StoreDisplayValue; if IsWindowVisible(Handle) then begin KillBeep(Handle); BarNavigationController.HandleKey(VK_TAB); end; end; function TdxBarWinControl.DoKeyDown(var Message: TWMKey): Boolean; begin KeyDown(Message.CharCode, KeyDataToShiftState(Message.KeyData)); Result := (Message.CharCode = 0); end; function TdxBarWinControl.DoKeyPress(var Message: TWMKey): Boolean; var Ch: Char; begin Ch := Char(Message.CharCode); KeyPress(Ch); Message.CharCode := Word(Ch); Result := (Ch = #0); end; function TdxBarWinControl.DoKeyUp(var Message: TWMKey): Boolean; begin KeyUp(Message.CharCode, KeyDataToShiftState(Message.KeyData)); Result := (Message.CharCode = 0); end; procedure TdxBarWinControl.DoKillFocus(var Message: TMessage); begin KillFocus(Message.WParam); end; procedure TdxBarWinControl.DoMouseDown(var Message: TWMMouse; AButton: TMouseButton; AShift: TShiftState); var APoint: TPoint; begin MouseDown(AButton, KeysToShiftState(Message.Keys), Message.XPos, Message.YPos); if mbRight = AButton then begin APoint := ClientToParent(Point(Message.XPos, Message.YPos)); SendMessage(Parent.Handle, WM_RBUTTONDOWN, Message.Keys, MakeLParam(APoint.X, APoint.Y)); end; end; procedure TdxBarWinControl.DoMouseMove(var Message: TWMMouse); var P: TPoint; begin P := ClientToParent(Point(Message.XPos, Message.YPos)); MouseMove(KeysToShiftState(Message.Keys), P.X, P.Y); end; procedure TdxBarWinControl.ActivateEdit(AByMouse: Boolean; AKey: Char = #0); var P: TPoint; begin if AByMouse then begin P := Parent.ScreenToClient(GetMouseCursorPos); if not PtInRect(WindowRect, P) then begin P := ParentToClient(P); SendMessage(Handle, WM_LBUTTONDOWN, ShiftStateToKeys(InternalGetShiftState), MakeLParam(P.X, P.Y)); end; end; end; function TdxBarWinControl.GetText: string; var S: PChar; Len: Integer; begin if Handle <> 0 then begin S := StrAlloc(256); Len := SendMessage(Handle, WM_GETTEXT, 255, Longint(S)); if Len = 0 then Result := '' else Result := S; StrDispose(S); end; end; procedure TdxBarWinControl.KillFocus(AHandle: THandle); begin // do nothing end; procedure TdxBarWinControl.RestoreDisplayValue; begin Text := Item.Text; end; procedure TdxBarWinControl.SetFocused(Value: Boolean); var IsDesignForm: Boolean; procedure SetTopMosts(AShow: Boolean); begin if BarDesignController.IsCustomizedByPopup then BarDesignController.SetCustomizePopupTopMosts(AShow); end; begin if FFocused <> Value then begin FFocused := Value; if FFocused then begin FPrevFocusedControl := Windows.GetFocus; if not IsActive then ControlActivate(True); Parent.MakeItemControlFullyVisible(Self); Show; end else begin { if FHandle <> 0 then SetWindowPos(Handle, 0, 0, 0, 0, 0, SWP_NOZORDER or SWP_NOMOVE or SWP_NOSIZE or SWP_HIDEWINDOW or SWP_NOACTIVATE);} Hide(BarManager.AlwaysSaveText and ((GetAsyncKeyState(VK_ESCAPE) >= 0) or (GetAsyncKeyState(VK_CONTROL) < 0) or (GetAsyncKeyState(VK_MENU) < 0))); if not (bisToolbarsVisibleChanging in BarManager.FInternalState) then begin IsDesignForm := (dxBarCustomizingForm <> nil) and (GetParentForm(FindControl(FPrevFocusedControl)) = dxBarCustomizingForm); if IsDesignForm then SetTopMosts(True); if (FPrevFocusedControl > 0) and IsWindowVisible(FPrevFocusedControl) then SetFocus(FPrevFocusedControl) else if IsWindowVisible(BarManager.Owner.Handle) then Windows.SetFocus(BarManager.Owner.Handle) else Windows.SetFocus(GetNextWindow(BarManager.Owner.Handle, GW_HWNDNEXT)); if IsDesignForm then SetTopMosts(False); FPrevFocusedControl := 0; end; end; end; end; procedure TdxBarWinControl.SetText(Value: string); begin SetWindowText(Handle, PChar(Value)); if Item.EmptyWindow then Repaint; end; procedure TdxBarWinControl.StoreDisplayValue; begin Item.Text := Text; end; procedure TdxBarWinControl.SysKeyDown(var Key: Word; Shift: TShiftState); begin Inc(FKeyPressedInside); case Key of VK_MENU: Key := 0; VK_F10: begin FKeyPressedInside := 0; Parent.HideAll; if (ssShift in Shift) or DoCallKeyboardHook(Key, 1) then Key := 0; end; end; end; procedure TdxBarWinControl.SysKeyUp(var Key: Word; Shift: TShiftState); begin if FKeyPressedInside > 0 then begin FKeyPressedInside := 0; if (Key = VK_MENU) then begin Parent.HideAll; WaitForMenu := True; if DoCallKeyboardHook(Key, Integer($80000001)) then Key := 0; end; end else Key := 0; end; procedure TdxBarWinControl.TransferMessage(AFromWindow: HWND; const Message: TMessage); var APoint: TPoint; begin case Message.Msg of WM_MOUSEFIRST..WM_MOUSELAST: begin APoint := SmallPointToPoint(TSmallPoint(Message.lParam)); MapWindowPoint(AFromWindow, Handle, APoint); SendMessage(Handle, Message.Msg, Message.WParam, MakeLParam(APoint.X, APoint.Y)); end; end; end; procedure TdxBarWinControl.WndProc(var Message: TMessage); var AItem: TdxBarWindowItem; AFocusedParent: HWND; ALinkSelf: TcxObjectLink; P: TPoint; begin AItem := Item; ALinkSelf := cxAddObjectLink(Self); try case Message.Msg of WM_SETFOCUS: AItem.DoEnter; WM_KILLFOCUS: try DoKillFocus(Message); if Focused then begin DefaultHandler(Message); //KillBeep(Handle); Parent.HideAll; Exit; end; if Parent is TdxBarControl then begin if GetFocus = Parent.Handle then AFocusedParent := Parent.Handle else AFocusedParent := GetParent(GetFocus); if not (FindControl(AFocusedParent) is TdxBarControl) then AFocusedParent := GetParent(AFocusedParent); if AFocusedParent <> Parent.Handle then begin DefaultHandler(Message); KillBeep(Handle); Parent.HideAll; Exit; end; end; finally AItem.DoExit; end; WM_MOUSEFIRST..WM_MOUSELAST: case Message.Msg of WM_RBUTTONDOWN: begin DoMouseDown(TWMMouse(Message), mbRight, []); Exit; end; WM_MOUSEMOVE: DoMouseMove(TWMMouse(Message)); else P := ClientToParent(Point(TWMMouse(Message).XPos, TWMMouse(Message).YPos)); if (GetCapture <> Handle) and not PtInRect(WindowRect, P) and PtInRect(Parent.GetItemRect(Self), P) then Exit; end; WM_CHAR: if DoKeyPress(TWMKey(Message)) then Exit; WM_KEYDOWN, WM_SYSKEYDOWN: if DoKeyDown(TWMKey(Message)) then Exit; WM_KEYUP, WM_SYSKEYUP: if DoKeyUp(TWMKey(Message)) then Exit; WM_COMMAND: if (HiWord(Message.WParam) = EN_CHANGE) and not FFocusing then Item.CurChange; end; if ALinkSelf.Ref <> nil then DefaultHandler(Message); finally cxRemoveObjectLink(ALinkSelf); end; end; { TdxBarButtonLikeControl } procedure FinishSubMenuTracking; begin dxKillTimer(0, ABarSubMenuTimerID); ABarSubItemTimer := nil; end; procedure SubMenuTimerProc(AActivation: Boolean); begin try try if ABarSubItemTimer <> nil then if AActivation then ABarSubItemTimer.ControlActivate(True) else ABarSubItemTimer.ControlInActivate(True); finally FinishSubMenuTracking; end; except end; end; procedure ActivateSubMenuTimerProc(Wnd: HWnd; Msg, TimerID, SysTime: Longint); stdcall; begin SubMenuTimerProc(True); end; procedure DeActivateSubMenuTimerProc(Wnd: HWnd; Msg, TimerID, SysTime: Longint); stdcall; begin SubMenuTimerProc(False); end; procedure StartSubMenuTracking(ASubItemControl: TdxBarButtonLikeControl; AActivation: Boolean); begin ABarSubItemTimer := ASubItemControl; if AActivation then ABarSubMenuTimerID := SetTimer(0, 0, dxBarWaitForSubMenuTime, @ActivateSubMenuTimerProc) else ABarSubMenuTimerID := SetTimer(0, 0, dxBarWaitForSubMenuTime, @DeActivateSubMenuTimerProc); end; destructor TdxBarButtonLikeControl.Destroy; begin FinishSubMenuTracking; if (SubMenuControl <> nil) {and not ItemLink.Item.IsDestroying} then SubMenuControl.Hide; inherited; end; function TdxBarButtonLikeControl.ArrowWidth: Integer; begin if Parent.Kind = bkSubMenu then Result := Parent.MenuArrowWidth else Result := Painter.RealButtonArrowWidth(BarManager); end; procedure TdxBarButtonLikeControl.CalcDrawParams(AFull: Boolean = True); begin inherited CalcDrawParams(AFull); if AFull then DrawParams.ButtonGroup := ViewInfo.RealPositionInButtonGroup; DrawParams.ArrowWidth := ArrowWidth; end; function TdxBarButtonLikeControl.CanBePartOfButtonGroup: Boolean; begin Result := True; end; function TdxBarButtonLikeControl.CanActivate: Boolean; begin Result := Enabled or BarManager.Designing; end; procedure TdxBarButtonLikeControl.ControlActivate(Immediately: Boolean); begin inherited; if IsDropDown and CanActivate then begin if Parent is TdxBarControl then if Parent.IsCustomizing or TdxBarControl(Parent).IsDowned then Immediately := True else Exit; if not Immediately and not BarManager.IsCustomizing then StartSubMenuTracking(True) else DoDropDown(True); end; end; procedure TdxBarButtonLikeControl.ControlInactivate(Immediately: Boolean); begin if Parent is TdxBarControl then Immediately := True; if not Immediately and (ABarSubItemTimer = nil) and (Parent <> nil) and not Parent.IsDestroying and not BarManager.IsCustomizing then begin StartSubMenuTracking(False); Exit; end; inherited; DoCloseUp(SubMenuControl <> nil); end; procedure TdxBarButtonLikeControl.ControlGetFocus(AIsSelected: Boolean; var AProcessed: Boolean); begin if not AIsSelected then inherited else if Parent.IsDowned and IsDroppedDown then Parent.BarLostFocus; end; procedure TdxBarButtonLikeControl.DropDown(AByMouse: Boolean); begin Parent.IsDowned := True; end; function TdxBarButtonLikeControl.GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; begin Result := TdxBarButtonLikeControlAccessibilityHelper; end; function TdxBarButtonLikeControl.GetDrawParamsClass: TdxBarItemControlDrawParamsClass; begin Result := TdxBarButtonLikeControlDrawParams; end; function TdxBarButtonLikeControl.GetSubMenuControl: TdxBarSubMenuControl; begin Result := nil; end; procedure TdxBarButtonLikeControl.KeyDown(var Key: Word; Shift: TShiftState); begin inherited; if WantsKey(Key) then DropDown(False); end; function TdxBarButtonLikeControl.WantsKey(Key: Word): Boolean; begin Result := inherited WantsKey(Key) or IsDropDown and ((Parent.Kind = bkSubMenu) and (Key = VK_RIGHT) or (Parent.Kind <> bkSubMenu) and (Key in [VK_UP, VK_DOWN])); end; procedure TdxBarButtonLikeControl.FinishSubMenuTracking(ANewSelectedControl: TdxBarItemControl = nil); begin if ABarSubItemTimer = Self then begin if (ANewSelectedControl <> nil) and not Parent.IsChildBar(ANewSelectedControl.Parent) then ControlInActivate(True) else dxBar.FinishSubMenuTracking; end; end; procedure TdxBarButtonLikeControl.StartSubMenuTracking(AActivation: Boolean); begin if AActivation then if ABarSubItemTimer <> nil then ABarSubItemTimer.FinishSubMenuTracking(Self); dxBar.StartSubMenuTracking(Self, AActivation); end; procedure TdxBarButtonLikeControl.DoCloseUp(AHadSubMenuControl: Boolean); begin FinishSubMenuTracking; if AHadSubMenuControl then SubMenuControl.Hide; if Parent.Kind <> bkSubMenu then Repaint; end; procedure TdxBarButtonLikeControl.Paint(ARect: TRect; PaintType: TdxBarPaintType); begin Painter.DrawButtonLikeControl(DrawParams, ARect); end; function TdxBarButtonLikeControl.GetDrawParams: TdxBarButtonLikeControlDrawParams; begin Result := TdxBarButtonLikeControlDrawParams(FDrawParams); end; { TdxBarButtonControl } function TdxBarButtonControl.IsDroppedDown: Boolean; begin Result := FDroppedDown and (SubMenuControl <> nil); end; function TdxBarButtonControl.GetButtonItem: TdxBarButton; begin if Item is TdxBarButton then Result := TdxBarButton(Item) else Result := nil; end; function TdxBarButtonControl.GetDown: Boolean; begin if ButtonItem <> nil then Result := ButtonItem.Down else Result := False; end; function TdxBarButtonControl.GetDropDownEnabled: Boolean; begin Result := (ButtonItem <> nil) and ButtonItem.DropDownEnabled; end; function TdxBarButtonControl.GetDroppedDownFlat: Boolean; begin Result := Painter.IsFlatItemText and IsDroppedDown; end; function TdxBarButtonControl.GetGroupIndex: Integer; begin Result := ButtonItem.GroupIndex; end; function TdxBarButtonControl.GetInternalStates: TdxBarButtonStates; begin if ButtonItem <> nil then Result := ButtonItem.FInternalStates else Result := []; end; function TdxBarButtonControl.GetLowered: Boolean; begin Result := (ButtonItem <> nil) and ButtonItem.Lowered; end; function TdxBarButtonControl.IsFlatTextSelected(APressed: Boolean): Boolean; begin Result := Painter.IsFlatItemText and (APressed or Down and DrawSelected) and Painter.IsItemTextSelectedInverted; if IsHighContrastWhite and Painter.IsFlatItemText and ((APressed or Down) or DrawSelected) and not DroppedDown then Result := True; //!!! Result := False; end; function TdxBarButtonControl.MouseOverArrow: Boolean; begin Result := IsDropDown and (FHotPartIndex = bcpDropButton); end; function TdxBarButtonControl.ArrowPressed: Boolean; begin Result := MousePressed and MouseOverArrow; end; procedure TdxBarButtonControl.CalcDrawParams(AFull: Boolean = True); begin inherited CalcDrawParams(AFull); if AFull then begin DrawParams.ShortCut := ShortCutToText(ShortCut); DrawParams.IsPressed := IsPressed; DrawParams.Downed := Down; DrawParams.DroppedDown := DroppedDown; DrawParams.DroppedDownFlat := DroppedDownFlat; DrawParams.SplitDropDown := True; DrawParams.DropDownEnabled := DropDownEnabled; DrawParams.IsTextSelected := IsFlatTextSelected(IsPressed); DrawParams.IsFlatText := not IsFlatTextSelected(IsPressed); DrawParams.GrayScale := GrayScale; DrawParams.IsLowered := Lowered; end; end; procedure TdxBarButtonControl.CalcParts; begin inherited; Painter.CalculateButtonParts(DrawParams, FParts, ItemBounds); end; procedure TdxBarButtonControl.ControlClick(AByMouse: Boolean; AKey: Char = #0); begin inherited; //#DG TODO: if (Parent is TdxBarControl) and not TdxBarControl(Parent).IsDowned then Exit; if IsDropDown and ArrowPressed then ControlActivate(True) else if (Parent is TdxBarControl) or IsDropDown then Repaint; end; procedure TdxBarButtonControl.ControlUnclick(ByMouse: Boolean); begin if not ByMouse or (FHotPartIndex = bcpButton) then begin if (ButtonItem <> nil) and (bstChecked in ButtonItem.FInternalStates) then ButtonItem.Down := not ButtonItem.Down; ControlInactivate(True); inherited; end; end; procedure TdxBarButtonControl.ControlGetFocus(AIsSelected: Boolean; var AProcessed: Boolean); begin if AIsSelected and Parent.IsDowned and IsDroppedDown and (FHotPartIndex = bcpButton) then Parent.BarGetFocus(Self) else inherited; end; procedure TdxBarButtonControl.DoCloseUp(AHadSubMenuControl: Boolean); begin if AHadSubMenuControl then SubMenuControl.FDropDownButton := nil; FDroppedDown := False; inherited; end; procedure TdxBarButtonControl.DoDropDown(AByMouse: Boolean); var Rect: TRect; P: TPoint; begin if not FDroppedDown and Enabled and DropDownEnabled and (ButtonItem.DropDownMenu <> nil) then begin FDroppedDown := True; Parent.MakeItemControlFullyVisible(Self); Repaint; Rect := Parent.GetItemRect(Self); with Rect do if (Parent.Kind = bkSubMenu) or Parent.IsRealVertical then begin P := Point(Right, Top); if {not Flat or }(Parent.Kind = bkSubMenu) then // fix Dec(P.Y, SubMenuParent.BorderSize); end else P := Point(Left, Bottom); P := Parent.ClientToScreen(P); ButtonItem.DoDropDown(Self, P.X, P.Y, AByMouse); if Painter.IsDropDownRepaintNeeded then Repaint; end; end; function TdxBarButtonControl.DrawSelected: Boolean; begin Result := inherited DrawSelected and not FParent.IsCustomizing or Pressed; end; procedure TdxBarButtonControl.DropDown(AByMouse: Boolean); begin inherited; DoDropDown(AByMouse); end; function TdxBarButtonControl.GetSubMenuControl: TdxBarSubMenuControl; begin if (ButtonItem <> nil) and (ButtonItem.DropDownMenu <> nil) then Result := TdxBarSubMenuControl(ButtonItem.DropDownMenu.ItemLinks.BarControl) else Result := nil; end; function TdxBarButtonControl.GetDefaultHeight: Integer; begin Result := inherited GetDefaultHeight; if Lowered then Inc(Result, 2 * Painter.LoweredBorderSize(Self)); end; function TdxBarButtonControl.GetDefaultWidth: Integer; begin Result := inherited GetDefaultWidth; Painter.InflateSizeForArrow(DrawParams, Result); if Lowered then Inc(Result, 2 * Painter.LoweredBorderSize(Self)); end; function TdxBarButtonControl.GetSmallHeight: Integer; begin Result := inherited GetSmallHeight; if cpText in DrawParams.ViewStructure then Result := Max(Result, GetRotationDependentHeight(DrawParams.DefaultButtonSize)); end; function TdxBarButtonControl.GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; begin Result := TdxBarButtonControlAccessibilityHelper; end; function TdxBarButtonControl.GetDefaultViewStructure: TdxBarItemControlViewStructure; begin case PaintStyle of psStandard: if GetPaintType = ptMenu then Result := [cpIcon, cpText] else if IconAssigned(GetViewSize) then Result := [cpIcon] else Result := [cpText]; psCaption: Result := [cpText]; psCaptionInMenu: if GetPaintType = ptMenu then Result := [cpText] else Result := [cpIcon]; psCaptionGlyph: Result := [cpIcon, cpText]; end; end; function TdxBarButtonControl.GetOwnedBarControl: TCustomdxBarControl; begin Result := SubMenuControl; end; function TdxBarButtonControl.GetPaintStyle: TdxBarPaintStyle; begin if FItemLink <> nil then Result := FItemLink.PaintStyle else Result := psStandard; // if (Parent is TdxBarControl) and (Result = psStandard) and not ImageExists then // Result := psCaption; if (Parent is TdxBarControl) and (Result = psStandard) then PreparePaintStyleOnBar(Result); end; function TdxBarButtonControl.GetPartCount: Integer; begin if FDrawParams.IsDropDown then Result := 2 else Result := 1; end; function TdxBarButtonControl.GetViewStructure: TdxBarItemControlViewStructure; begin if ViewInfo.ViewLevel = ivlSmallIcon then Result := [cpIcon] else Result := inherited GetViewStructure; end; function TdxBarButtonControl.IsDestroyOnClick: Boolean; begin Result := (Parent is TdxBarControl) or ButtonItem.CloseSubMenuOnClick; end; function TdxBarButtonControl.IsDropDown: Boolean; begin Result := bstDropDown in InternalStates; end; function TdxBarButtonControl.IsPressed: Boolean; begin Result := DrawSelected and Parent.IsActive and MousePressed and not ArrowPressed or Pressed and not(bstChecked in InternalStates); end; function TdxBarButtonControl.NeedCaptureMouse: Boolean; begin Result := not DroppedDown; end; procedure TdxBarButtonControl.PaintStyleChanged; begin Parent.RepaintBar; end; procedure TdxBarButtonControl.PreparePaintStyleOnBar(var APaintStyle: TdxBarPaintStyle); begin if not IconAssigned(GetViewSize) then APaintStyle := psCaption; end; { TdxBarApplicationMenuButtonControl } procedure TdxBarApplicationMenuButtonControl.CalcDrawParams(AFull: Boolean = False); begin inherited CalcDrawParams(AFull); if AFull then DrawParams.ContentWidth := inherited InternalGetDefaultWidth; end; function TdxBarApplicationMenuButtonControl.GetDefaultViewStructure: TdxBarItemControlViewStructure; begin Result := [cpText]; if IconAssigned(GetViewSize) then Include(Result, cpIcon); end; function TdxBarApplicationMenuButtonControl.GetDrawParamsClass: TdxBarItemControlDrawParamsClass; begin Result := TdxBarApplicationMenuButtonControlDrawParams; end; function TdxBarApplicationMenuButtonControl.GetPaintType: TdxBarPaintType; begin Result := ptHorz; end; function TdxBarApplicationMenuButtonControl.InternalGetDefaultWidth: Integer; begin if Item.Width <> 0 then Result := Item.Width else Result := inherited InternalGetDefaultWidth; end; procedure TdxBarApplicationMenuButtonControl.CaptionChanged; begin Parent.Repaint; end; procedure TdxBarApplicationMenuButtonControl.GlyphChanged; begin Parent.Repaint; end; procedure TdxBarApplicationMenuButtonControl.VisibleChanged; begin Parent.Repaint; end; procedure TdxBarApplicationMenuButtonControl.WidthChanged; begin Parent.Repaint; end; procedure TdxBarApplicationMenuButtonControl.Paint(ARect: TRect; PaintType: TdxBarPaintType); begin Painter.ApplicationMenuDrawButton(DrawParams, ARect); end; function TdxBarApplicationMenuButtonControl.GetDrawParams: TdxBarApplicationMenuButtonControlDrawParams; begin Result := TdxBarApplicationMenuButtonControlDrawParams(FDrawParams); end; { TdxBarCustomEditControl } destructor TdxBarCustomEditControl.Destroy; begin FreeAndNil(FBkBrush); inherited Destroy; end; procedure TdxBarCustomEditControl.CorrectFrameRect(var ARect: TRect); begin // do nothing end; procedure TdxBarCustomEditControl.DoCalcDrawingConsts; var ASavedFont: TdxBarSavedFont; begin inherited DoCalcDrawingConsts; PrepareCanvasFont(Parent.EditFontHandle, Item.StyleEdit, ASavedFont); try FEditTextSize := Parent.GetTextSize; finally RestoreCanvasFont(ASavedFont); end; end; procedure TdxBarCustomEditControl.DrawFrame; function IsEditorFrameOnly: Boolean; begin Result := not IsEditTransparent or (GetPaintType = ptMenu); end; var AFrameRect, AContentRect: TRect; begin if IsEditorFrameOnly then AFrameRect := GetEditRect else AFrameRect := ItemBounds; CorrectFrameRect(AFrameRect); AContentRect := AFrameRect; Painter.EditControlDrawBorder(DrawParams, AContentRect); ExcludeFrameRegion(Canvas, AFrameRect, AContentRect); end; procedure TdxBarCustomEditControl.CalcDrawParams(AFull: Boolean = True); begin inherited; if AFull then begin DrawParams.IsTransparent := IsEditTransparent; DrawParams.Focused := Focused; end; end; procedure TdxBarCustomEditControl.CalcParts; begin inherited; Painter.CalculateEditParts(DrawParams, FParts, ItemBounds); end; procedure TdxBarCustomEditControl.DrawEditSizingFrame(AWidth: Integer); var AItemRect: TRect; ADC: HDC; begin AItemRect := ItemBounds; if FRightBorderSizing then AItemRect.Right := AItemRect.Left + AWidth else AItemRect.Left := AItemRect.Right - AWidth; ADC := GetDC(0); MapWindowRect(Parent.Handle, 0, AItemRect); with AItemRect do begin PatBlt(ADC, Left, Top, Right - Left, 2, DSTINVERT); PatBlt(ADC, Left, Bottom - 2, Right - Left, 2, DSTINVERT); PatBlt(ADC, Left, Top + 2, 2, Bottom - Top - 4, DSTINVERT); PatBlt(ADC, Right - 2, Top + 2, 2, Bottom - Top - 4, DSTINVERT); end; ReleaseDC(0, ADC); end; function TdxBarCustomEditControl.DrawSelected: Boolean; begin Result := inherited DrawSelected and not FParent.IsCustomizing; end; function TdxBarCustomEditControl.GetDefaultViewStructure: TdxBarItemControlViewStructure; begin Result := []; if ShowCaption then Result := [cpText]; if IconAssigned(GetViewSize) and Painter.EditControlShowIconDefault(DrawParams) then Include(Result, cpIcon); end; function TdxBarCustomEditControl.GetDrawParamsClass: TdxBarItemControlDrawParamsClass; begin Result := TdxBarEditLikeControlDrawParams; end; function TdxBarCustomEditControl.GetPartCount: Integer; begin Result := inherited GetPartCount + 2; end; function TdxBarCustomEditControl.GetPossibleViewLevels: TdxBarItemViewLevels; begin Result := inherited GetPossibleViewLevels; Include(Result, ivlControlOnly); end; function TdxBarCustomEditControl.GetCaptionAreaWidth: Integer; begin Result := 0; if cpText in DrawParams.ViewStructure then begin Result := GetCaptionWidth; Inc(Result, GetIndents(cpText).Left + GetIndents(cpText).Right); end; end; function TdxBarCustomEditControl.GetControlAreaWidth: Integer; begin Result := ItemLink.Width; end; function TdxBarCustomEditControl.GetGlyphAreaWidth: Integer; begin if cpIcon in DrawParams.ViewStructure then begin Result := GetGlyphSize(DrawParams.ViewSize).cx; Inc(Result, GetIndents(cpIcon).Left + GetIndents(cpIcon).Right); end else Result := 0; end; function TdxBarCustomEditControl.GetDefaultHeight: Integer; begin Result := GetEditTextSize; if ShowCaption then Result := Max(Result, Parent.GetDefaultItemHeight(Self)); end; function TdxBarCustomEditControl.GetDefaultWidth: Integer; begin Result := GetDefaultWidthHorzLayout; end; function TdxBarCustomEditControl.GetEditOffset: Integer; begin Result := GetEditRect.Left - ItemBounds.Left; end; function TdxBarCustomEditControl.GetEditRect: TRect; begin Result := ItemBounds; if (Align = iaClient) and not (bboExtendItemWhenAlignedToClient in Parent.BehaviorOptions) then Result.Left := Result.Right - GetControlAreaWidth else Result.Left := ItemBounds.Left + GetCaptionAreaWidth + GetGlyphAreaWidth; end; function TdxBarCustomEditControl.GetEditTextSize: Integer; begin if (Item.StyleEdit <> nil) and (svFont in Item.StyleEdit.AssignedValues) then Result := FEditTextSize else Result := Parent.EditTextSize; end; function TdxBarCustomEditControl.GetIndents(ADrawAreaType: TdxBarItemControlPart): TRect; begin Result := Painter.EditControlGetIndents(DrawParams, ADrawAreaType); end; function TdxBarCustomEditControl.GetMinWidth: Integer; begin Result := GetCaptionAreaWidth + GetMinEditorWidth; end; function TdxBarCustomEditControl.GetShowCaption: Boolean; begin Result := (Parent.Kind = bkSubMenu) or Item.ShowCaption; end; function TdxBarCustomEditControl.IsEditTransparent: Boolean; begin Result := False; end; procedure TdxBarCustomEditControl.Paint(ARect: TRect; PaintType: TdxBarPaintType); begin Painter.DrawEditLikeControl(DrawParams, ARect); end; procedure TdxBarCustomEditControl.Show; begin InitEdit; end; procedure TdxBarCustomEditControl.BeginResize(APoint: TPoint); begin FRightBorderSizing := PtInRect(RightSizingRect, APoint); FSizingEditWidth := cxRectWidth(ItemBounds); //#DG - reliable way to remove a white rect: ProcessPaintMessages; DoPaint(ItemBounds, ptHorz); DrawEditSizingFrame(FSizingEditWidth); end; function TdxBarCustomEditControl.CanResize(APoint: TPoint): Boolean; begin Result := BarManager.IsCustomizing and (PtInRect(RightSizingRect, APoint) or PtInRect(LeftSizingRect, APoint)); end; procedure TdxBarCustomEditControl.EndResize(AAllowResize: Boolean); begin DrawEditSizingFrame(FSizingEditWidth); if AAllowResize and (GetControlAreaWidth <> FSizingEditWidth - GetEditOffset) then ItemLink.UserWidth := FSizingEditWidth - GetEditOffset else Repaint; end; procedure TdxBarCustomEditControl.Resizing(APoint: TPoint); var AItemRect: TRect; APrevSizingEditWidth: Integer; begin AItemRect := ItemBounds; APrevSizingEditWidth := FSizingEditWidth; if FRightBorderSizing then FSizingEditWidth := APoint.X - AItemRect.Left else FSizingEditWidth := AItemRect.Right - APoint.X; CheckEditWidth(FSizingEditWidth, MinWidth); if FSizingEditWidth <> APrevSizingEditWidth then begin DrawEditSizingFrame(APrevSizingEditWidth); DrawEditSizingFrame(FSizingEditWidth); end; end; function TdxBarCustomEditControl.HotPartWantMouse: Boolean; begin Result := inherited HotPartWantMouse; if not BarManager.IsCustomizing and (GetPaintType <> ptMenu) then // Result := Result and not (FHotPartIndex in ecpHeaderParts); Result := Result and not (FHotPartIndex in [ecpIcon, ecpText]) // TODO must be checked end; procedure TdxBarCustomEditControl.RefreshBkBrush(var AHandle: HBRUSH); begin if FBkBrush = nil then FBkBrush := TBrush.Create; FBkBrush.Color := Painter.EditGetBkColor(DrawParams); AHandle := FBkBrush.Handle; end; function TdxBarCustomEditControl.GetCaptionBkBrush: HBRUSH; begin if DrawSelected and (GetPaintType = ptMenu) then Result := Parent.ToolbarSelBrush else Result := Parent.BkBrush; end; function TdxBarCustomEditControl.GetDrawParams: TdxBarEditLikeControlDrawParams; begin Result := TdxBarEditLikeControlDrawParams(FDrawParams); end; function TdxBarCustomEditControl.GetEditBkBrush: HBRUSH; begin RefreshBkBrush(Result); end; function TdxBarCustomEditControl.GetEditFont: TFont; var AStyleEdit: TcxStyle; begin AStyleEdit := Item.StyleEdit; if (AStyleEdit <> nil) and (svFont in AStyleEdit.AssignedValues) then Result := AStyleEdit.Font else Result := Parent.EditFont; end; function TdxBarCustomEditControl.GetItem: TdxCustomBarEdit; begin Result := TdxCustomBarEdit(inherited GetItem); end; function TdxBarCustomEditControl.LeftSizingRect: TRect; begin Result := ItemBounds; Result.Right := Result.Left + EditSizingZoneSize; end; function TdxBarCustomEditControl.RightSizingRect: TRect; begin Result := ItemBounds; Result.Left := Result.Right - EditSizingZoneSize; end; { TdxBarEditControl } constructor TdxBarEditControl.Create(AItemLink: TdxBarItemLink); begin inherited Create(AItemLink); if not ((Parent is TdxBarControl) and TdxBarControl(Parent).Moving) then CreateInnerEdit; end; destructor TdxBarEditControl.Destroy; begin if not ((Parent is TdxBarControl) and TdxBarControl(Parent).Moving) then DestroyInnerEdit; inherited Destroy; end; procedure TdxBarEditControl.CreateWindowHandle; begin FHandle := CreateWindowEx(0, 'EDIT', '', WS_CHILD or Painter.EditControlES_Style, 0, 0, 100, 100, Parent.Handle, 0, HInstance, nil); RestoreDisplayValue; SendMessage(FHandle, EM_SETLIMITTEXT, MaxLength, 0); end; procedure TdxBarEditControl.DestroyWindowHandle(ADestroyWindow: Boolean = True); begin dxBar.DestroyWindowHandle(FHandle, ADestroyWindow); end; function TdxBarEditControl.GetItem: TdxBarEdit; begin Result := TdxBarEdit(ItemLink.Item); end; function TdxBarEditControl.GetMaxLength: Integer; begin Result := Item.MaxLength; end; function TdxBarEditControl.GetReadOnly: Boolean; begin Result := Item.ReadOnly; end; function TdxBarEditControl.CanDrawEditor: Boolean; begin Result := not Focused or not Enabled; end; procedure TdxBarEditControl.ControlClick(AByMouse: Boolean; AKey: Char = #0); begin inherited; if Focused then SendMessage(FHandle, EM_SETSEL, 0, -1); end; procedure TdxBarEditControl.CreateInnerEdit; begin CreateWindowHandle; inherited CreateInnerEdit; end; procedure TdxBarEditControl.DestroyInnerEdit(AFullDestroy: Boolean = True); begin inherited DestroyInnerEdit(AFullDestroy); DestroyWindowHandle(AFullDestroy); end; procedure TdxBarEditControl.DrawTextField; begin if Enabled then WindowRect := FParts[ecpEdit]; if CanDrawEditor then Painter.EditControlDrawTextField(Self, Parent.Canvas.Handle, FParts[ecpEdit], False); end; function TdxBarEditControl.GetHandle: HWND; begin Result := FHandle; end; function TdxBarEditControl.GetMinEditorWidth: Integer; begin Result := MinEditWidth; end; procedure TdxBarEditControl.Hide(AStoreDisplayValue: Boolean); begin if Handle <> 0 then ShowWindow(Handle, SW_HIDE); if AStoreDisplayValue then StoreDisplayValue; end; procedure TdxBarEditControl.InitEdit; begin CalcDrawParams; end; procedure TdxBarEditControl.SetFocused(Value: Boolean); begin if Value <> FFocused then begin if Value{Focused} then SendMessage(Handle, EM_SETREADONLY, WPARAM(ReadOnly or Item.EmptyWindow), 0); inherited; Repaint; end; end; procedure TdxBarEditControl.SetText(Value: string); var ANotEqual: Boolean; begin ANotEqual := Text <> Value; inherited; Painter.EditControlUpdateWndText(Self, Handle, ANotEqual); end; procedure TdxBarEditControl.Show; begin inherited; SendMessage(Handle, WM_SETFONT, EditFont.Handle, 0); with WindowRect do SetWindowPos(Handle, 0, Left, Top, Right - Left, Bottom - Top, SWP_SHOWWINDOW); Painter.EditControlPrepareEditWnd(TdxBarEditControl(Self), Handle); FFocusing := True; try RestoreDisplayValue; finally FFocusing := False; end; SetFocus(Handle); end; procedure TdxBarEditControl.WndProc(var Message: TMessage); begin case Message.Msg of WM_DESTROY: begin Focused := False; DefaultHandler(Message); DestroyInnerEdit(False); end else inherited WndProc(Message); end; end; { TCustomdxBarComboControl } destructor TCustomdxBarComboControl.Destroy; begin DroppedDown := False; inherited; end; function TCustomdxBarComboControl.IsDroppedDown: Boolean; begin Result := DroppedDown; end; function TCustomdxBarComboControl.GetDropDownWindow: HWND; begin Result := Item.DropDownWindow; end; function TCustomdxBarComboControl.GetItem: TCustomdxBarCombo; begin Result := TCustomdxBarCombo(ItemLink.Item); end; procedure TCustomdxBarComboControl.CalcDrawParams(AFull: Boolean = True); begin inherited; if AFull then DrawParams.DroppedDown := FDroppedDown; end; procedure TCustomdxBarComboControl.CalcParts; begin inherited; Painter.CalculateComboParts(DrawParams, FParts, ItemBounds); end; function TCustomdxBarComboControl.CanDrawEditor: Boolean; begin Result := not Enabled or not Focused or Item.EmptyWindow; end; procedure TCustomdxBarComboControl.ControlInactivate(Immediately: Boolean); begin DroppedDown := False; inherited; end; procedure TCustomdxBarComboControl.CorrectFrameRect(var ARect: TRect); begin ARect.Right := FParts[ccpDropButton].Right + Painter.ComboControlButtonOffsets.Right; end; procedure TCustomdxBarComboControl.DrawTextField; begin Painter.ComboControlDrawArrowButton(DrawParams, FParts[ccpDropButton]); inherited DrawTextField; end; procedure TCustomdxBarComboControl.EnabledChanged; begin DroppedDown := False; inherited; end; procedure TCustomdxBarComboControl.GetArrowParams(out ABrush: HBRUSH; out AArrowColor: COLORREF); begin Painter.ComboControlGetArrowParams(DrawParams, ABrush, AArrowColor); end; function TCustomdxBarComboControl.GetPartCount: Integer; begin Result := inherited GetPartCount + 1; end; function TCustomdxBarComboControl.IsChildWindow(AWnd: HWND): Boolean; begin Result := inherited IsChildWindow(AWnd) or (DroppedDown and IsWindowVisible(DropDownWindow) and IsChildEx(DropDownWindow, AWnd)); end; procedure TCustomdxBarComboControl.SetDroppedDown(Value: Boolean); var P: TPoint; begin if (FDroppedDown <> Value) and not Item.ReadOnly then begin FDroppedDown := Value; Repaint; if FDroppedDown then begin with Parent.GetItemRect(Self), P do if (Parent.Kind = bkSubMenu) or Parent.IsRealVertical then begin X := Right; Y := Top; end else begin X := Left + GetEditOffset; Y := Bottom; end; ClientToScreen(Parent.Handle, P); Item.DropDown(P.X, P.Y); end else Item.CloseUp; end; end; procedure TCustomdxBarComboControl.SysKeyDown(var Key: Word; Shift: TShiftState); begin if (Key = VK_UP) or (Key = VK_DOWN) then begin DroppedDown := not DroppedDown; Key := 0; end; inherited SysKeyDown(Key, Shift); end; procedure TCustomdxBarComboControl.SysKeyUp(var Key: Word; Shift: TShiftState); begin if (Key = VK_UP) or (Key = VK_DOWN) then Key := 0; inherited SysKeyUp(Key, Shift); end; procedure TCustomdxBarComboControl.WndProc(var Message: TMessage); function IsMouseCursorInDroppedDownArea: Boolean; begin if Item.ShowEditor then Result := FHotPartIndex in [ccpDropButton] else Result := FHotPartIndex in [ecpEdit, ccpDropButton]; end; function LButtonDowned: Boolean; begin with Message do LButtonDowned := (Msg = WM_LBUTTONDOWN) or (Msg = WM_LBUTTONDBLCLK); end; var Shift: TShiftState; AHandle: HWND; begin with Message do case Msg of WM_KEYDOWN, WM_KEYUP, WM_CHAR: begin Shift := KeyDataToShiftState(lParam); if (Msg = WM_KEYDOWN) and (wParam = VK_F4) then begin DroppedDown := not DroppedDown; Exit; end else if DroppedDown and (DropDownWindow <> 0) and Item.CheckKeyForDropDownWindow(wParam, Shift) then begin Result := SendMessage(DropDownWindow, Msg, wParam, lParam); Exit; end; end; end; AHandle := Handle; inherited; if not IsWindowVisible(AHandle) then Exit; if LButtonDowned then FOnPressDroppedDown := DroppedDown; if IsMouseCursorInDroppedDownArea and (not FOnPressDroppedDown and LButtonDowned or FOnPressDroppedDown and (Message.Msg = WM_LBUTTONUP)) then DroppedDown := not DroppedDown; end; { TdxBarComboControl } function TdxBarComboControl.GetItem: TdxBarCustomCombo; begin Result := TdxBarCustomCombo(ItemLink.Item); end; function TdxBarComboControl.GetItemIndex: Integer; begin Result := Item.ItemIndex; end; function TdxBarComboControl.GetItems: TStrings; begin Result := Item.Items; end; function TdxBarComboControl.GetSorted: Boolean; begin Result := Item.Sorted; end; procedure TdxBarComboControl.SetLocalItemIndex(Value: Integer); begin FLocalItemIndex := Value; RestoreDisplayValue; if Item.EmptyWindow then Repaint; end; procedure TdxBarComboControl.RestoreDisplayValue; begin if (0 <= FLocalItemIndex) and (FLocalItemIndex <= Items.Count - 1) then Text := Items[FLocalItemIndex] else inherited RestoreDisplayValue; end; procedure TdxBarComboControl.SetFocused(Value: Boolean); begin FFocusing := True; try if Value then LocalItemIndex := ItemIndex; finally FFocusing := False; end; inherited; end; procedure TdxBarComboControl.WndProc(var Message: TMessage); var Shift: TShiftState; begin if not ReadOnly then begin with Message do case Msg of WM_MOUSEWHEEL: begin if SmallInt(HIWORD(TWMMOuse(Message).Keys)) > 0 then begin if not DroppedDown then begin if LocalItemIndex > 0 then LocalItemIndex := LocalItemIndex - 1; end else SendMessage(DropDownWindow, WM_VScroll, SB_LINEUP, 0); end else begin if not DroppedDown then begin if LocalItemIndex < (Items.Count - 1) then LocalItemIndex := LocalItemIndex + 1; end else SendMessage(DropDownWindow, WM_VScroll, SB_LINEDOWN, 0); end; end; WM_KEYDOWN: begin if (wParam = VK_RETURN) or (wParam = VK_TAB) then begin if (LocalItemIndex <> -1) and (Item.Items[LocalItemIndex] = Text) then begin Item.ItemIndex := LocalItemIndex; if not IsWindowVisible(Handle) then Exit; end; end else begin Shift := KeyDataToShiftState(lParam); if not DroppedDown and ((wParam = VK_UP) or (wParam = VK_DOWN)) and (Shift = []) then begin if (wParam = VK_UP) and (LocalItemIndex > 0) then LocalItemIndex := LocalItemIndex - 1 else if (wParam = VK_DOWN) and (LocalItemIndex < Items.Count - 1) then LocalItemIndex := LocalItemIndex + 1; Exit; end; end; end; end; end; inherited WndProc(Message); end; { TdxBarSubItemControl } destructor TdxBarSubItemControl.Destroy; begin FIsActive := False; inherited Destroy; end; function TdxBarSubItemControl.IsDroppedDown: Boolean; begin Result := (SubMenuControl <> nil) and IsActive; end; function TdxBarSubItemControl.GetCaptionOffset: Integer; begin Result := Painter.GetControlCaptionOffset(Self); end; function TdxBarSubItemControl.GetItem: TCustomdxBarSubItem; begin Result := TCustomdxBarSubItem(ItemLink.Item); end; function TdxBarSubItemControl.IsFlatText: Boolean; begin Result := Painter.IsFlatItemText and not IsHighContrastWhite; end; function TdxBarSubItemControl.IsTextSelected(ASelected, ADown: Boolean): Boolean; function IsFlatText: Boolean; begin Result := Painter.IsFlatItemText and IsHighContrastWhite; end; begin Result := ASelected and (not IsFlatText and Painter.IsMenuItem(Self) or IsFlatText and not ADown); end; function TdxBarSubItemControl.GetSubMenuControl: TdxBarSubMenuControl; begin if Item.ItemLinks = nil then Result := nil else Result := TdxBarSubMenuControl(Item.ItemLinks.BarControl); end; procedure TdxBarSubItemControl.CalcDrawParams; begin inherited; if AFull then begin DrawParams.IsPressed := IsDroppedDown; DrawParams.DroppedDown := IsDroppedDown; DrawParams.IsTextSelected := IsTextSelected(DrawSelected, IsDroppedDown); DrawParams.IsFlatText := IsFlatText; DrawParams.IsMenuItem := IsMenuItem; end; end; function TdxBarSubItemControl.CanActivate: Boolean; begin Result := inherited CanActivate and (Enabled or not Item.IsInternal); end; function TdxBarSubItemControl.CanClicked: Boolean; begin Result := False; end; procedure TdxBarSubItemControl.ControlActivate(Immediately: Boolean); begin if not HasSubMenu then Exit; if IsDroppedDown then if (ItemLink.Item.CurItemLink = nil) or (Self = ItemLink.Item.CurItemLink.Control) then begin FinishSubMenuTracking; Exit; end else ItemLink.Item.CurItemLink.Control.ControlInActivate(True); inherited; end; procedure TdxBarSubItemControl.ControlInactivate(Immediately: Boolean); begin if HasSubMenu then inherited; end; procedure TdxBarSubItemControl.ControlClick(AByMouse: Boolean; AKey: Char = #0); begin if IsDroppedDown then begin if Parent.IsCustomizing or (BarManager.GetPaintStyle = bmsStandard) then // ??? ControlInactivate(True) end else begin ControlActivate(True); if not AByMouse and (SubMenuControl <> nil) then with SubMenuControl do if ItemLinks.First <> nil then SetKeySelectedItem(ItemLinks.First.Control); end; end; procedure TdxBarSubItemControl.CreateSubMenuControl; begin Item.ItemLinks.CreateBarControl; end; procedure TdxBarSubItemControl.DoCreateSubMenuControl; begin CreateSubMenuControl; if HasShadow and IsDroppedDown then begin SubMenuControl.OwnerBounds := Parent.GetItemScreenRect(Self); SubMenuControl.FOwnerControl := Parent; end; end; procedure TdxBarSubItemControl.DoCloseUp(AHadSubMenuControl: Boolean); begin if AHadSubMenuControl then SubMenuControl.FSubItem := nil; inherited DoCloseUp(AHadSubMenuControl); if AHadSubMenuControl then Item.DoCloseUp; end; procedure TdxBarSubItemControl.DoDropDown(AByMouse: Boolean); begin Item.DoPopup; Item.DirectClick; DoCreateSubMenuControl; if SubMenuControl <> nil then ShowSubmenuControl; end; procedure TdxBarSubItemControl.DropDown(AByMouse: Boolean); begin inherited; Click(AByMouse); end; procedure TdxBarSubItemControl.ShowSubmenuControl; var R: TRect; P: TPoint; begin R := FParent.GetItemRect(Self); if Parent.Kind = bkSubMenu then begin P := Point(R.Right, R.Top - SubMenuParent.BorderSize); SubMenuControl.OwnerWidth := R.Right - R.Left; end else if Parent.IsRealVertical then begin P := Point(R.Right, R.Top); SubMenuControl.OwnerWidth := R.Right - R.Left; end else begin P := Point(R.Left, R.Bottom); SubMenuControl.OwnerHeight := R.Bottom - R.Top; end; SubMenuControl.FSubItem := Self; P := FParent.ClientToScreen(P); SubMenuControl.Left := P.X; SubMenuControl.Top := P.Y; // *** Parent.ChildBar := SubMenuControl; //#DG SubMenuControl.UpdateDoubleBuffered; - ? why ? // *** if Parent.Kind <> bkSubMenu then Repaint; SubMenuControl.FShowAnimation := FShowAnimation; FShowAnimation := False; SubMenuControl.Show; if Painter.IsDropDownRepaintNeeded then Repaint; end; function TdxBarSubItemControl.GetCaptionAreaWidth: Integer; begin Result := inherited GetCaptionAreaWidth; Painter.InflateSizeForArrow(DrawParams, Result); end; function TdxBarSubItemControl.GetControlCaptionOffset: Integer; begin Result := Painter.GetControlCaptionOffset(Self); end; function TdxBarSubItemControl.GetAccessibilityHelperClass: TdxBarAccessibilityHelperClass; begin Result := TdxBarSubItemControlAccessibilityHelper; end; function TdxBarSubItemControl.GetOwnedBarControl: TCustomdxBarControl; begin Result := SubMenuControl; end; function TdxBarSubItemControl.HasSubMenu: Boolean; begin Result := True; end; function TdxBarSubItemControl.IsDestroyOnClick: Boolean; begin Result := False; end; function TdxBarSubItemControl.IsDropDown: Boolean; begin Result := True; end; function TdxBarSubItemControl.IsExpandable: Boolean; begin Result := True; end; function TdxBarSubItemControl.IsMenuItem: Boolean; begin Result := Parent.IsMainMenu; end; function TdxBarSubItemControl.IsPressed: Boolean; begin Result := IsDroppedDown and (FHotPartIndex <> icpNone) and MousePressed; end; function TdxBarSubItemControl.WantsDblClick: Boolean; begin Result := inherited WantsDblClick and not BarManager.Designing; end; function TdxBarSubItemControl.WantsKey(Key: Word): Boolean; begin Result := inherited WantsKey(Key) or (Key = VK_RETURN); end; function TdxBarSubItemControl.GetPossibleViewLevels: TdxBarItemViewLevels; begin Result := inherited GetPossibleViewLevels; Include(Result, ivlLargeIconWithText); end; function TdxBarSubItemControl.GetDefaultViewStructure: TdxBarItemControlViewStructure; begin Result := []; if Item.ShowCaption or (GetPaintType = ptMenu) then Include(Result, cpText); if IconAssigned(GetViewSize) or not (cpText in Result) then Include(Result, cpIcon); end; { TContainerItemSubMenuControl } type TContainerItemSubMenuControl = class(TdxBarSubMenuControl) private FContainerItem: TCustomdxBarContainerItem; protected procedure DoCloseUp; override; function GetIsCustomizing: Boolean; override; public destructor Destroy; override; end; destructor TContainerItemSubMenuControl.Destroy; var AContainerItem: TCustomdxBarContainerItem; begin AContainerItem := FContainerItem; inherited; AContainerItem.NeedClearItemList; end; procedure TContainerItemSubMenuControl.DoCloseUp; begin with FContainerItem do DeleteListedItemLinks(ItemLinks, 0); inherited; end; function TContainerItemSubMenuControl.GetIsCustomizing: Boolean; begin Result := False; end; { TdxBarContainerItemControl } function TdxBarContainerItemControl.GetItem: TCustomdxBarContainerItem; begin Result := TCustomdxBarContainerItem(ItemLink.Item); end; procedure TdxBarContainerItemControl.CreateSubMenuControl; begin if BarManager.IsCustomizing then Exit; Item.ItemLinks.FBarControl := TContainerItemSubMenuControl.Create(BarManager); SubMenuControl.FItemLinks := Item.ItemLinks; TContainerItemSubMenuControl(SubMenuControl).FContainerItem := Item; with Item do AddListedItemLinks(ItemLinks, 0, True, ItemLink); end; function TdxBarContainerItemControl.DrawSelected: Boolean; begin Result := inherited DrawSelected and not Parent.IsCustomizing; end; function TdxBarContainerItemControl.GetCaption: string; begin Result := inherited GetCaption; if not ShowRealCaption then Result := '(' + Result + ')'; end; function TdxBarContainerItemControl.IsExpandable: Boolean; begin Result := not BarManager.IsCustomizing; end; procedure TdxBarContainerItemControl.Paint(ARect: TRect; PaintType: TdxBarPaintType); begin if PaintType = ptMenu then Painter.DrawGlyphAndTextInSubMenu(DrawParams, ARect) else inherited; end; function TdxBarContainerItemControl.ShowRealCaption: Boolean; begin Result := (Parent is TdxBarControl) or not Item.HideWhenRun; end; { TdxBarPainter } constructor TdxBarPainter.Create(AData: Integer); begin inherited Create; end; procedure TdxBarPainter.CalculateButtonParts( const ADrawParams: TdxBarButtonLikeControlDrawParams; var AParts: array of TRect; const AItemRect: TRect); begin if ADrawParams.IsDropDown then begin AParts[bcpDropButton].Left := AParts[bcpDropButton].Right - ADrawParams.ArrowWidth; AParts[bcpButton].Right := AParts[bcpDropButton].Left; end; end; procedure TdxBarPainter.CalculateColorComboParts(const ADrawParams: TdxBarColorComboControlDrawParams; var AParts: array of TRect; const AItemRect: TRect); begin AParts[clcpCustomColorButton] := GetCustomColorButtonBounds(ADrawParams, AItemRect); AParts[ccpDropButton].Right := AParts[clcpCustomColorButton].Left; if IsCustomColorButtonVisible(ADrawParams) then Dec(AParts[ccpDropButton].Right, GetCustomColorButtonIndents(ADrawParams).Left); Dec(AParts[ccpDropButton].Right, ComboControlButtonOffsets.Right); InternalCalculateComboParts(ADrawParams, AParts); end; procedure TdxBarPainter.CalculateComboParts(const ADrawParams: TdxBarEditLikeControlDrawParams; var AParts: array of TRect; const AItemRect: TRect); begin AParts[ccpDropButton] := cxRectContent(AItemRect, ComboControlButtonOffsets); InternalCalculateComboParts(ADrawParams, AParts); end; procedure TdxBarPainter.CalculateEditParts(const ADrawParams: TdxBarEditLikeControlDrawParams; var AParts: array of TRect; const AItemRect: TRect); var ATransparentIndent: Integer; begin with ADrawParams do begin if IsTransparent and (PaintType <> ptMenu) then ATransparentIndent := EditControlBorderOffsets.Left else ATransparentIndent := 0; AParts[ecpIcon].Left := AParts[ecpIcon].Left + ATransparentIndent; AParts[ecpIcon].Right := AParts[ecpIcon].Left + BarEditControl.GetGlyphAreaWidth; AParts[ecpText].Left := AParts[ecpIcon].Right; AParts[ecpText].Right := AParts[ecpText].Left + BarEditControl.GetCaptionAreaWidth; AParts[ecpEdit] := EditControlGetContentRect(BarEditControl.GetEditRect); end; end; procedure TdxBarPainter.CalculateSpinEditParts(const ADrawParams: TdxBarEditLikeControlDrawParams; var AParts: array of TRect; const AItemRect: TRect); begin AParts[secButtonUp] := GetSpinEditButtonBounds(AItemRect, sbUp); AParts[secButtonDown] := GetSpinEditButtonBounds(AItemRect, sbDown); AParts[ecpEdit].Right := AParts[secButtonUp].Left - EditControlBorderOffsets.Right - GetSpinEditButtonIndents.Left; end; function TdxBarPainter.GetToolbarContentOffsets(ABar: TdxBar; ADockingStyle: TdxBarDockingStyle; AHasSizeGrip: Boolean): TRect; begin if ADockingStyle = dsNone then begin Result := Rect(BorderSizeX, BorderSizeY, BorderSizeX, BorderSizeY); if (ABar.Control = nil) or ABar.Control.HasCaption then begin Inc(Result.Left, BarHorSize); Inc(Result.Right, BarHorSize); Inc(Result.Top, BarCaptionAreaSize + BarTopSize); Inc(Result.Bottom, BarBottomSize); end; end else if ABar.BorderStyle = bbsSingle then begin BarBorderSizes(ABar, ADockingStyle, Result); if ADockingStyle in [dsTop, dsBottom] then Inc(Result.Left, BarFingersSize(ABar)) else Inc(Result.Top, BarFingersSize(ABar)); end else begin Result := cxEmptyRect; if ABar.IsStatusBar then Inc(Result.Top, StatusBarTopBorderSize(ABar.BarManager)); if AHasSizeGrip then Inc(Result.Right, StatusBarGripSize(ABar.BarManager).cx); end; end; function TdxBarPainter.GetToolbarsOffsetForAutoAlign: Integer; begin Result := 0; end; class procedure TdxBarPainter.CalculateArrowPoints(const ARect: TRect; AArrowSize: Integer; AArrowDirection: TcxArrowDirection; out P: TcxArrowPoints); procedure OffsetPoints(var P: TcxArrowPoints; ADisplace: TPoint); var I: Integer; begin for I := Low(P) to High(P) do P[I] := cxPointOffset(P[I], ADisplace); end; procedure CorrectArrowPoints(var P: TcxArrowPoints; AArrowDirection: TcxArrowDirection); begin case AArrowDirection of adUp: begin P[cxArrowLeftBasePointIndex] := cxPointOffset(P[cxArrowLeftBasePointIndex], 0, 1); P[cxArrowRightBasePointIndex] := cxPointOffset(P[cxArrowRightBasePointIndex], 1, 1); end; adDown: begin P[cxArrowLeftBasePointIndex] := cxPointOffset(P[cxArrowLeftBasePointIndex], 1, 0); P[cxArrowTopPointIndex] := cxPointOffset(P[cxArrowTopPointIndex], 0, 1); if Odd(AArrowSize + cxRectHeight(ARect)) then OffsetPoints(P, Point(0, -1)); end; adLeft: begin P[cxArrowLeftBasePointIndex] := cxPointOffset(P[cxArrowLeftBasePointIndex], 1, 1); P[cxArrowRightBasePointIndex] := cxPointOffset(P[cxArrowRightBasePointIndex], 1, 0); end; adRight: begin P[cxArrowRightBasePointIndex] := cxPointOffset(P[cxArrowRightBasePointIndex], 0, 1); P[cxArrowTopPointIndex] := cxPointOffset(P[cxArrowRightBasePointIndex], 1, 0); if Odd(AArrowSize + cxRectWidth(ARect)) then OffsetPoints(P, Point(-1, 0)); end; end; end; begin TcxCustomLookAndFeelPainter.CalculateArrowPoints(ARect, P, AArrowDirection, False, AArrowSize); CorrectArrowPoints(P, AArrowDirection); end; class function TdxBarPainter.GetArrowRectByPoints(const P: TcxArrowPoints; AArrowDirection: TcxArrowDirection): TRect; begin case AArrowDirection of adUp: Result := Rect(P[cxArrowLeftBasePointIndex].X, P[cxArrowTopPointIndex].Y, P[cxArrowRightBasePointIndex].X, P[cxArrowRightBasePointIndex].Y); adDown: Result := Rect(P[cxArrowRightBasePointIndex].X, P[cxArrowRightBasePointIndex].Y, P[cxArrowLeftBasePointIndex].X, P[cxArrowTopPointIndex].Y); adLeft: Result := Rect(P[cxArrowTopPointIndex].X, P[cxArrowRightBasePointIndex].Y, P[cxArrowLeftBasePointIndex].X, P[cxArrowLeftBasePointIndex].Y); adRight: Result := Rect(P[cxArrowLeftBasePointIndex].X, P[cxArrowLeftBasePointIndex].Y, P[cxArrowTopPointIndex].X, P[cxArrowRightBasePointIndex].Y); end; end; class procedure TdxBarPainter.SetArrowRegion(ACanvas: TcxCanvas; AArrowDirection: TcxArrowDirection; P: TcxArrowPoints; AOperation: TcxRegionOperation); procedure CalculateClipArea(var P: TcxArrowPoints); begin case AArrowDirection of adUp: begin Dec(P[cxArrowLeftBasePointIndex].X); Inc(P[cxArrowRightBasePointIndex].X); Dec(P[cxArrowTopPointIndex].Y); end; adLeft: begin Inc(P[cxArrowRightBasePointIndex].X); Dec(P[cxArrowRightBasePointIndex].Y, 2); Dec(P[cxArrowTopPointIndex].X); end; adRight: begin Dec(P[cxArrowLeftBasePointIndex].X); Dec(P[cxArrowLeftBasePointIndex].Y, 2); end; end; end; var ARgn: HRGN; begin CalculateClipArea(P); ARgn := CreatePolygonRgn(P, 3, WINDING); ACanvas.SetClipRegion(TcxRegion.Create(ARgn), AOperation); end; class function TdxBarPainter.GetControlCaptionOffset(ABarItemControl: TdxBarItemControl): Integer; begin Result := -ABarItemControl.Parent.Font.Height div 2; end; class function TdxBarPainter.GetDefaultTextSize(ACanvas: TcxCanvas): Integer; begin Result := ACanvas.TextHeight('Wg') + 6; end; class function TdxBarPainter.GetPopupWindowBorderWidth: Integer; begin Result := 2; end; class function TdxBarPainter.GetSubMenuItemIconRect( const AItemRect: TRect; AIconAreaSize: Integer): TRect; begin Result := AItemRect; Result.Right := Result.Left + AIconAreaSize; end; class function TdxBarPainter.GetSubMenuItemTextIndent(const ADrawParams: TdxBarItemControlDrawParams): Integer; begin Result := ADrawParams.BarItemControl.SubMenuParent.BandSize + 3; end; class procedure TdxBarPainter.DrawBackground(ABarItemControl: TdxBarItemControl; DC: HDC; const R: TRect; ABrush: HBRUSH; AOpaque: Boolean); begin if AOpaque then FillRect(DC, R, ABrush) else begin ABarItemControl.CheckNonRecent; try ABarItemControl.Parent.FillBackground(DC, R, ABrush, clNone, True); finally ABarItemControl.UncheckNonRecent; end; end; end; class procedure TdxBarPainter.DrawBackgroundFrameRect(ABarItemControl: TdxBarItemControl; DC: HDC; R: TRect; ABrush: HBRUSH; AOpaque: Boolean); var AClipRgn: HRGN; AClipRgnExists: Boolean; begin if AOpaque then FrameRect(DC, R, ABrush) else begin SaveClipRgn(DC, AClipRgn, AClipRgnExists); InflateRect(R, -1, -1); with R do ExcludeClipRect(DC, Left, Top, Right, Bottom); InflateRect(R, 1, 1); DrawBackground(ABarItemControl, DC, R, ABrush, False); RestoreClipRgn(DC, AClipRgn, AClipRgnExists); end; end; class procedure TdxBarPainter.DrawDisabledShadowRect(ABarItemControl: TdxBarItemControl; DC: HDC; R: TRect); begin FillRect(DC, R, COLOR_BTNSHADOW + 1); end; procedure TdxBarPainter.DrawItemBackground(ABarItemControl: TdxBarItemControl; ACanvas: TcxCanvas; const ASourceRect: TRect; ABrush: HBRUSH); begin ABarItemControl.Parent.FillBackground(ACanvas.Handle, ASourceRect, ABrush, clNone, True); end; procedure TdxBarPainter.DrawGlyph(ABarItemControl: TdxBarItemControl; ADC: HDC; ADrawRect: TRect; const AFullBounds: TRect; APaintType: TdxBarPaintType; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, ACenter, AForceUseBkBrush, AIsSplit: Boolean); var AImageBounds: TRect; begin DrawGlyph(ABarItemControl, ADC, ADrawRect, AFullBounds, AImageBounds, APaintType, ABarItemControl.GetViewStructure, ABarItemControl.GetViewSize, AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, ACenter, AForceUseBkBrush, False, AIsSplit); end; procedure TdxBarPainter.DrawGlyph( ABarItemControl: TdxBarItemControl; ADC: HDC; ADrawRect: TRect; const AFullBounds: TRect; out AImageBounds: TRect; APaintType: TdxBarPaintType; AViewStructure: TdxBarItemControlViewStructure; AViewSize: TdxBarItemControlViewSize; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, ACenter, AForceUseBkBrush, AGrayScale, AIsSplit: Boolean); var ACurrentGlyph: TBitmap; ACurrentImages: TCustomImageList; ACurrentImageIndex: Integer; begin GetImageParams(ABarItemControl, ADrawRect, APaintType, AViewStructure, AViewSize, ACenter, ASelected, ADowned, ADrawDowned, AGlyphEmpty, ACurrentGlyph, ACurrentImages, ACurrentImageIndex, AImageBounds); ABarItemControl.ViewInfo.ImageBounds := AImageBounds; if not IsRectEmpty(AFullBounds) then ADrawRect := AFullBounds; DrawGlyphAndBkgnd(ABarItemControl, ADC, ADrawRect, AImageBounds, APaintType, ACurrentGlyph, ACurrentImages, ACurrentImageIndex, AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AForceUseBkBrush, AGrayScale, AIsSplit); end; procedure TdxBarPainter.DrawGlyphAndBkgnd( ABarItemControl: TdxBarItemControl; ADC: HDC; R: TRect; const AGlyphRect: TRect; APaintType: TdxBarPaintType; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AForceUseBkBrush, AGrayScale, AIsSplit: Boolean); procedure GetDimensions(out AWidth, AHeight: Integer); begin AWidth := cxRectWidth(R); AHeight := cxRectHeight(R); end; procedure GetImageDimensions(out AWidth, AHeight: Integer); begin AWidth := cxRectWidth(AGlyphRect); AHeight := cxRectHeight(AGlyphRect); end; var ABrush: HBRUSH; AWidth, AHeight, AImageWidth, AImageHeight: Integer; ANeedBorder: Boolean; begin GetDimensions(AWidth, AHeight); ABrush := GlyphBkgndBrush(ABarItemControl, APaintType, AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AForceUseBkBrush, AGrayScale); if AGlyphEmpty then begin ANeedBorder := (ABarItemControl.BarManager.GlyphSize + 2 <= AWidth) and (ABarItemControl.BarManager.GlyphSize + 2 <= AHeight); end else begin GetImageDimensions(AImageWidth, AImageHeight); ANeedBorder := (AImageWidth + 2 <= AWidth) and (AImageHeight + 2 <= AHeight); end; if IsNativeBackground then DrawGlyphBorder(ABarItemControl, ADC, ABrush, ANeedBorder, R, APaintType, AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AIsSplit); if AGlyphEmpty then begin DrawGlyphEmptyImage(ABarItemControl, ADC, R, ABrush, ANeedBorder, APaintType, ASelected, ADowned, ADrawDowned); end else begin DrawGlyphImage(ABarItemControl, ADC, ABrush, ANeedBorder, R, AGlyphRect, AGlyph, AImages, AImageIndex, ASelected, ADowned, ADrawDowned, AForceUseBkBrush, AGrayScale, ADroppedDown, APaintType); end; if not IsNativeBackground then DrawGlyphBorder(ABarItemControl, ADC, ABrush, ANeedBorder, R, APaintType, AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AIsSplit); end; procedure TdxBarPainter.DrawGlyphAndTextInSubMenu( const ADrawParams: TdxBarButtonLikeControlDrawParams; var R: TRect); begin // Required end; procedure TdxBarPainter.DrawItemMultilineText(const ADrawParams: TdxBarItemControlDrawParams; const AText: string; const ATextRect: TRect; AMaxLineCount: Integer); var ALines: TStrings; I, ALettersCount, ALineHeight: Integer; ARect: TRect; begin ARect := ATextRect; ALines := TStringList.Create; try cxGetTextLines(AText, ADrawParams.Canvas, ARect, ALines); if ALines.Count > AMaxLineCount then begin for I := ALines.Count - 1 downto AMaxLineCount - 1 do ALines.Delete(I); if ALines.Count > 0 then ALettersCount := Length(ALines[0]) + 1 else ALettersCount := 0; ALines.Add(Trim(Copy(AText, ALettersCount, MaxInt))); end; ALineHeight := ADrawParams.Canvas.TextHeight('Wg'); for I := 0 to ALines.Count - 1 do begin DrawItemText(ADrawParams.BarItemControl, ADrawParams.Canvas.Handle, ALines[I], ARect, DT_TOP, ADrawParams.Enabled, ADrawParams.DrawSelected, False, True, IsFlatItemTextForMenu, DT_END_ELLIPSIS); OffsetRect(ARect, 0, ALineHeight); end; finally ALines.Free; end; end; procedure TdxBarPainter.DrawItemText(ABarItemControl: TdxBarItemControl; ADC: HDC; S: string; APaintRect: TRect; AAlignment: UINT; AEnabled, ASelected, ARotated, AClipped, AFlatText: Boolean; AFormat: UINT); procedure UnderlineAccel(ACanvas: TcxCanvas; const APaintRect: TRect; const ATextSize: TSize; AAccelWidth, AAccelOffset: Integer); var X, Y: Integer; ATextMetric: TTextMetric; begin ACanvas.Pen.Color := ACanvas.Font.Color; GetTextMetrics(ACanvas.Handle, ATextMetric); X := (APaintRect.Left + APaintRect.Right - ATextSize.cy) div 2 + ATextMetric.tmDescent - 2; Y := APaintRect.Top + AAccelOffset; ACanvas.MoveTo(X, Y); ACanvas.LineTo(X, Y + AAccelWidth); end; var R: TRect; AAccelPos: Integer; AFlat: Boolean; AColor1, AColor2: TColor; ATextSize: TSize; ATextOffsetY, AAccelWidth, AAccelOffsetY: Integer; begin BarCanvas.BeginPaint(ADC); try R := APaintRect; if not AClipped then AFormat := AFormat or DT_NOCLIP else if ARotated then begin AFormat := AFormat or DT_NOCLIP; BarCanvas.SetClipRegion(TcxRegion.Create(APaintRect), roIntersect); end; AAccelPos := 0; AAccelWidth := 0; AAccelOffsetY := 0; if ARotated then begin AAccelPos := GetAccelPos(S, True); if AAccelPos > 0 then AFormat := AFormat or DT_NOPREFIX; ATextSize := BarCanvas.TextExtent(S); case AAlignment of DT_CENTER: ATextOffsetY := (cxRectHeight(APaintRect) - ATextSize.cx) div 2; DT_RIGHT: ATextOffsetY := cxRectHeight(APaintRect) - ATextSize.cx; else ATextOffsetY := 0; end; OffsetRect(APaintRect, (cxRectWidth(APaintRect) + ATextSize.cy) div 2, ATextOffsetY); if AAccelPos > 0 then begin AAccelOffsetY := ATextOffsetY + BarCanvas.TextWidth(Copy(S, 1, AAccelPos - 1)); AAccelWidth := BarCanvas.TextWidth(S[AAccelPos]); end; end else AFormat := AFormat or AAlignment or DT_VCENTER; AFlat := IsFlatItemText and AFlatText; // TODO and ... GetTextColors(ABarItemControl, AEnabled, ASelected, AFlat, AColor1, AColor2); BarCanvas.Brush.Style := bsClear; if AColor2 <> AColor1 then begin BarCanvas.Font.Color := AColor1; OffsetRect(APaintRect, 1, 1); cxDrawText(BarCanvas.Handle, S, APaintRect, AFormat); OffsetRect(APaintRect, -1, -1); if ARotated and (AAccelPos > 0) then begin OffsetRect(R, 1, 1); UnderlineAccel(BarCanvas, R, ATextSize, AAccelWidth, AAccelOffsetY); OffsetRect(R, -1, -1); end; end; BarCanvas.Font.Color := AColor2; cxDrawText(BarCanvas.Handle, S, APaintRect, AFormat); if ARotated and (AAccelPos > 0) then UnderlineAccel(BarCanvas, R, ATextSize, AAccelWidth, AAccelOffsetY); finally BarCanvas.EndPaint; end; end; procedure TdxBarPainter.DrawItemTextInSubMenu(const ADrawParams: TdxBarButtonLikeControlDrawParams; R: TRect); procedure DrawDescription(var ACaptionRect: TRect); var ADescriptionRect: TRect; ATextHeight, AOffset: Integer; begin with ADrawParams do begin if Description <> '' then begin ATextHeight := Canvas.TextHeight('Wg'); AOffset := (cxRectHeight(R) - ATextHeight * 3) div 4; ADescriptionRect.Left := R.Left; ADescriptionRect.Top := R.Bottom - (ATextHeight + AOffset) * 2; ADescriptionRect.Right := R.Right - BarItemControl.Parent.TextSize; ADescriptionRect.Bottom := R.Bottom; ACaptionRect.Bottom := ADescriptionRect.Top; DrawItemMultilineText(ADrawParams, Description, ADescriptionRect, 2); end; Canvas.Font.Style := Canvas.Font.Style + [fsBold]; end; end; var ACaptionRect: TRect; begin with ADrawParams do begin InflateRect(R, 0, SubMenuControlInternalBorderSize); ACaptionRect := R; if BarItemControl.ShowDescription then DrawDescription(ACaptionRect); DrawItemText(BarItemControl, Canvas.Handle, Caption, ACaptionRect, DT_LEFT, Enabled, DrawSelected, False, False, IsFlatItemTextForMenu); if BarItemControl.CanShowShortCut and (ShortCut <> '') then begin Dec(ACaptionRect.Right, 5 + BarItemControl.Parent.TextSize); DrawItemText(BarItemControl, Canvas.Handle, ShortCut, ACaptionRect, DT_RIGHT, Enabled, DrawSelected, False, False, IsFlatItemTextForMenu); end; end; end; class procedure TdxBarPainter.DrawLowered(DC: HDC; var R: TRect); begin // Required end; class procedure TdxBarPainter.FrameAndFillRect(ABarItemControl: TdxBarItemControl; DC: HDC; var R: TRect; Enabled, Selected, Pressed: Boolean); begin // Required end; class procedure TdxBarPainter.GetArrowParams( const ADrawParams: TdxBarItemControlDrawParams; out ABrush: HBRUSH; out AArrowColor: COLORREF); begin AArrowColor := GetSysColor(COLOR_BTNTEXT); ABrush := ADrawParams.BarItemControl.BkBrush; end; class procedure TdxBarPainter.GetCaptionParams(out AOffsets: TRect; out AHeightCorrection: Integer); begin AOffsets := Rect(2, 1, 2, 1); AHeightCorrection := 0; end; class function TdxBarPainter.GlyphBkgndBrush(ABarItemControl: TdxBarItemControl; APaintType: TdxBarPaintType; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AForceUseBkBrush, AGrayScale: Boolean): HBRUSH; begin Result := ABarItemControl.BkBrush; end; class function TdxBarPainter.GlyphDownShift(ABarItemControl: TdxBarItemControl): Integer; begin Result := 0; end; class function TdxBarPainter.GlyphDrawDownedShift(ABarItemControl: TdxBarItemControl; ADown: Boolean): Integer; begin Result := 0; end; class function TdxBarPainter.IsFlatItemText: Boolean; begin Result := False; end; class function TdxBarPainter.IsFlatItemTextForMenu: Boolean; begin Result := IsFlatItemText and not IsHighContrastWhite; end; class function TdxBarPainter.IsItemTextSelectedInverted: Boolean; begin Result := True; end; class function TdxBarPainter.LoweredBorderSize(ABarItemControl: TdxBarItemControl): Integer; begin Result := 0; end; class function TdxBarPainter.TextAreaOffset(ABarItemControl: TdxBarItemControl): Integer; begin if ABarItemControl.Parent.Kind = bkSubMenu then Result := ABarItemControl.Parent.TextSize + 1 else Result := 0; end; class function TdxBarPainter.BarFingersSize(ABar: TdxBar): Integer; begin if ABar.Control.CanMoving then Result := FingersSize else Result := EmptyFingersSize; end; class function TdxBarPainter.BeforeFingersSize: Integer; begin // Required Result := 0; end; class function TdxBarPainter.BorderSizeX: Integer; begin Result := GetSystemMetrics(SM_CXFRAME); end; class function TdxBarPainter.BorderSizeY: Integer; begin Result := GetSystemMetrics(SM_CYFRAME); end; class function TdxBarPainter.EmptyFingersSize: Integer; begin Result := 0; end; class function TdxBarPainter.FingersSize: Integer; begin // Required Result := 0; end; class function TdxBarPainter.GripperSize: Integer; begin Result := dxBarFingerSize; end; class function TdxBarPainter.RealButtonArrowWidth(ABarManager: TdxBarManager): Integer; begin Result := (1 + Byte(ABarManager.LargeIcons)) * ABarManager.FButtonArrowWidth; if not Odd(Result) then Inc(Result); end; class function TdxBarPainter.RealLargeButtonArrowWidth(ABarManager: TdxBarManager): Integer; begin Result := ABarManager.FLargeButtonArrowWidth; end; class function TdxBarPainter.SubMenuBeginGroupIndent: Integer; begin // Required Result := 0; end; class procedure TdxBarPainter.DockControlFillBackground(ADockControl: TdxDockControl; DC: HDC; ADestR, ASourceR, AWholeR: TRect; ABrush: HBRUSH; AColor: TColor); begin FillBackgroundRect(DC, ADestR, ASourceR, ABrush, AColor, nil); end; class function TdxBarPainter.IsNativeBackground: Boolean; begin Result := False; end; class function TdxBarPainter.BarChildrenHaveShadows(ABarControl: TCustomdxBarControl): Boolean; begin Result := False; end; procedure TdxBarPainter.BarDrawDockedBackground(ABarControl: TdxBarControl; DC: HDC; ADestR, ASourceR: TRect; ABrush: HBRUSH; AColor: TColor); begin BarFillParentBackground(ABarControl, DC, ADestR, ASourceR, ABrush, AColor); end; class function TdxBarPainter.BarControlOwnerBrush(ABarManager: TdxBarManager): HBRUSH; begin Result := ABarManager.FlatToolbarsBrush; end; class procedure TdxBarPainter.BarDrawFloatingBackground(ABarControl: TCustomdxBarControl; DC: HDC; ADestR, ASourceR: TRect; ABrush: HBRUSH; AColor: TColor); begin FillBackgroundRect(DC, ADestR, ASourceR, ABrush, AColor, ABarControl.BarManager.Backgrounds.Bar); end; class procedure TdxBarPainter.BarDrawOwnerLink(ABarControl: TCustomdxBarControl; DC: HDC); begin if not IsRectEmpty(ABarControl.OwnerLinkBounds[False]) then FillRect(DC, ABarControl.OwnerLinkBounds[False], ABarControl.BarControlOwnerBrush); end; procedure TdxBarPainter.BarFillParentBackground(ABarControl: TCustomdxBarControl; DC: HDC; const ADestR, ASourceR: TRect; ABrush: HBRUSH; AColor: TColor); var ABounds: TRect; begin ABounds := ABarControl.BoundsRect; ABarControl.DockControl.FillBackground(DC, ADestR, cxRectOffset(ASourceR, ABounds.Left, ABounds.Top), ABrush, AColor); end; class function TdxBarPainter.BarHasShadow(ABarControl: TCustomdxBarControl): Boolean; begin Result := False; end; class function TdxBarPainter.BarToolbarBrush(ABarControl: TCustomdxBarControl): HBRUSH; begin Result := GetSysColorBrush(COLOR_BTNFACE); end; class function TdxBarPainter.BarToolbarBrushEx(ABarControl: TdxBarControl): HBRUSH; begin Result := BarToolbarBrush(ABarControl); end; class function TdxBarPainter.BarToolbarDownedBrush(ABarControl: TCustomdxBarControl): HBRUSH; begin Result := PatternBrush; end; class function TdxBarPainter.BarToolbarDownedSelBrush(ABarControl: TCustomdxBarControl): HBRUSH; begin Result := GetSysColorBrush(COLOR_BTNFACE); end; class function TdxBarPainter.BarToolbarSelBrush(ABarControl: TCustomdxBarControl): HBRUSH; begin Result := GetSysColorBrush(COLOR_HIGHLIGHT); end; class function TdxBarPainter.ComboBoxArrowWidth(ABarControl: TCustomdxBarControl; cX: Integer): Integer; begin Result := 2 * cX - 1; end; class function TdxBarPainter.EditTextSize(ABarControl: TCustomdxBarControl; cY: Integer): Integer; var ABorderOffsets, ATextOffsets: TRect; ATextHeightCorrection: Integer; begin ABorderOffsets := EditControlBorderOffsets; GetEditTextParams(ATextOffsets, ATextHeightCorrection); Result := ABorderOffsets.Top + ATextOffsets.Top + cY + ATextOffsets.Bottom + ABorderOffsets.Bottom + ATextHeightCorrection; end; class procedure TdxBarPainter.GetEditTextParams(out AOffsets: TRect; out AHeightCorrection: Integer); var ACaptionHeightCorrection: Integer; ACaptionOffsets: TRect; begin GetCaptionParams(ACaptionOffsets, ACaptionHeightCorrection); AOffsets := ACaptionOffsets; GetEditTextVerticalOffsets(AOffsets.Top, AOffsets.Bottom); AHeightCorrection := ACaptionOffsets.Top + ACaptionHeightCorrection + ACaptionOffsets.Bottom - (AOffsets.Top + AOffsets.Bottom); end; class procedure TdxBarPainter.GetEditTextVerticalOffsets( out ATop, ABottom: Integer); begin ATop := 0; ABottom := 2; end; class procedure TdxBarPainter.SetWindowRgn(AHandle: THandle; const AWindowRect: TRect; ARedraw: Boolean = False); begin // do nothing end; class function TdxBarPainter.BarAllowHotTrack: Boolean; begin Result := False; end; class function TdxBarPainter.BarAllowQuickCustomizing: Boolean; begin Result := False; end; class function TdxBarPainter.BarBeginGroupSideSize: Integer; begin Result := (BarBeginGroupSize - (1 + 1){|}) div 2; end; class function TdxBarPainter.BarBeginGroupSize: Integer; begin Result := 2 + (1 + 1){|} + 2; end; class procedure TdxBarPainter.BarBorderPaintSizes(ABarControl: TdxBarControl; var R: TRect); begin R := Rect(BarBorderSize, BarBorderSize, BarBorderSize, BarBorderSize); end; class function TdxBarPainter.BarBorderSize: Integer; begin Result := 1; end; class procedure TdxBarPainter.BarBorderSizes(ABar: TdxBar; AStyle: TdxBarDockingStyle; var R: TRect); begin R := Rect(2, 2, 2, 2); end; class function TdxBarPainter.BarCaptionAreaSize: Integer; begin Result := BarCaptionSize + 1; end; class procedure TdxBarPainter.BarCaptionFillBackground(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); begin FillRect(DC, R, AToolbarBrush); end; class function TdxBarPainter.BarCaptionSize: Integer; var NonClientMetrics: TNonClientMetrics; begin NonClientMetrics.cbSize := SizeOf(NonClientMetrics); SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, @NonClientMetrics, 0); Result := NonClientMetrics.iSmCaptionHeight; end; class function TdxBarPainter.BarCaptionTransparent: Boolean; begin Result := False; end; class function TdxBarPainter.BarCloseButtonSize: TSize; begin Result.cx := BarCaptionSize; Result.cy := Result.cx; end; procedure TdxBarPainter.BarDrawBackground(ABarControl: TdxBarControl; ADC: HDC; const ADestRect, ASourceRect: TRect; ABrush: HBRUSH; AColor: TColor); begin // check background if not ABarControl.GetBackgroundBitmap.Empty then FillBackgroundRect(ADC, ADestRect, ASourceRect, ABrush, AColor, ABarControl.GetBackgroundBitmap) else begin if ABarControl.Bar.IsStatusBar and ABarControl.BarManager.Backgrounds.Bar.Empty then StatusBarFillBackground(ABarControl, ADC, ADestRect, ASourceRect, Rect(0, 0, ABarControl.Width, ABarControl.Height), ABrush, AColor) else begin if ABarControl.Bar.Color = clDefault then begin if ABarControl.DockControl <> nil then BarDrawDockedBackground(ABarControl, ADC, ADestRect, ASourceRect, ABrush, AColor) else BarDrawFloatingBackground(ABarControl, ADC, ADestRect, ASourceRect, ABrush, AColor) end else FillRectByColor(ADC, ADestRect, ABarControl.Bar.Color); // TODO end; end; end; procedure TdxBarPainter.BarDrawBeginGroup(ABarControl: TCustomdxBarControl; DC: HDC; ABeginGroupRect: TRect; AToolbarBrush: HBRUSH; AHorz: Boolean); begin if AHorz then begin with ABeginGroupRect do begin ABarControl.FillBackground(DC, Rect(Left, Top, Right, Top + BarBeginGroupSideSize), AToolbarBrush, clNone, True); ABarControl.FillBackground(DC, Rect(Left, Bottom - BarBeginGroupSideSize, Right, Bottom), AToolbarBrush, clNone, True); end; InflateRect(ABeginGroupRect, 0, -BarBeginGroupSideSize); DrawEdge(DC, ABeginGroupRect, EDGE_ETCHED, BF_TOP) end else begin with ABeginGroupRect do begin ABarControl.FillBackground(DC, Rect(Left, Top, Left + BarBeginGroupSideSize, Bottom), AToolbarBrush, clNone, True); ABarControl.FillBackground(DC, Rect(Right - BarBeginGroupSideSize, Top, Right, Bottom), AToolbarBrush, clNone, True); end; InflateRect(ABeginGroupRect, -BarBeginGroupSideSize, 0); DrawEdge(DC, ABeginGroupRect, EDGE_ETCHED, BF_LEFT); end; end; class procedure TdxBarPainter.BarDrawCaptionElement(ABarControl: TdxBarControl; DC: HDC; R: TRect; AState: TdxBarMarkState); var ABrush: HBRUSH; begin if AState <> msNone then begin FrameFlatSelRect(DC, R); InflateRect(R, -1, -1); if AState = msSelected then ABrush := ABarControl.ToolbarSelBrush else ABrush := ABarControl.ToolbarDownedSelBrush; FillRect(DC, R, ABrush); end else begin ABrush := CreateSolidBrush(ABarControl.CaptionBkColor); FillRect(DC, R, ABrush); DeleteObject(ABrush); end; end; class procedure TdxBarPainter.BarDrawCloseButton(ABarControl: TdxBarControl; DC: HDC; R: TRect); begin // Required end; procedure TdxBarPainter.BarDrawDockedBarBorder(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); begin // Required end; class procedure TdxBarPainter.BarDrawFloatingBarBorder(ABarControl: TdxBarControl; DC: HDC; var R, CR: TRect; AToolbarBrush: HBRUSH); begin // Required end; class procedure TdxBarPainter.BarDrawFloatingBarCaption(ABarControl: TdxBarControl; DC: HDC; var R, CR: TRect; AToolbarBrush: HBRUSH); var R1: TRect; X: Integer; ATransparent: Boolean; procedure DrawCaption; var S: string; AFont: HFONT; Size: TSize; APrevBkMode: Integer; AFlags: Integer; begin if R.Right - R.Left <= 0 then Exit; S := ABarControl.GetCaption; AFont := SelectObject(DC, CreateToolbarCaptionFontHandle(ABarControl.Font, ABarControl.BarManager.UseSystemFont)); // SetTextColor(DC, GetSysColor(COLOR_CAPTIONTEXT)); SetTextColor(DC, ABarControl.CaptionColor); SetBkColor(DC, ABarControl.CaptionBkColor); AFlags := ETO_CLIPPED; if ATransparent then APrevBkMode := SetBkMode(DC, TRANSPARENT) else begin AFlags := AFlags or ETO_OPAQUE; APrevBkMode := 0; // WARN OFF end; GetTextExtentPoint32(DC, PChar(S), Length(S), Size); ExtTextOut(DC, X, (R.Top + R.Bottom - Size.cy) div 2, AFlags, @R, PChar(S), Length(S), nil); if ATransparent then SetBkMode(DC, APrevBkMode); DeleteObject(SelectObject(DC, AFont)); end; begin R1 := R; R1.Top := R.Bottom; R1.Bottom := R1.Top + 1; FillRect(DC, R1, AToolbarBrush); ATransparent := BarCaptionTransparent; if ATransparent then BarCaptionFillBackground(ABarControl, DC, R, AToolbarBrush); if ABarControl.HasCloseButton then begin Dec(R.Right, BarCaptionSize); ABarControl.DrawCloseButton(DC); end; X := R.Left; if ABarControl.MarkExists then BarOffsetFloatingBarCaption(ABarControl, X, R) else Inc(X, 2); DrawCaption; if ABarControl.MarkExists then ABarControl.DrawMark(DC); end; procedure TdxBarPainter.BarDrawMark(ABarControl: TdxBarControl; DC: HDC; MarkR: TRect); begin BarDrawMarkArrow(ABarControl, DC, MarkR); end; procedure TdxBarPainter.BarDrawMarks(ABarControl: TdxBarControl; ACanvas: TcxCanvas; const AItemRect: TRect; AToolbarBrush: HBRUSH); begin BarDrawMarkBackground(ABarControl, ACanvas.Handle, AItemRect, AToolbarBrush); BarDrawMarkElements(ABarControl, ACanvas.Handle, AItemRect); end; class procedure TdxBarPainter.BarDrawMDIButton(ABarControl: TdxBarControl; AButton: TdxBarMDIButton; ASelected, APressed: Boolean; DC: HDC; R: TRect); begin // Required end; class procedure TdxBarPainter.BarDrawStatusBarGrip(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); var R1: TRect; begin R1 := R; R1.Top := R1.Bottom - StatusBarGripSize(ABarControl.BarManager).cy; BarDrawGrip(ABarControl, DC, R1, AToolbarBrush); R1.Bottom := R1.Top; R1.Top := R.Top; ABarControl.FillBackground(DC, R1, AToolbarBrush, clNone, False); end; class procedure TdxBarPainter.BarDrawStatusBarTopBorder(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); begin ABarControl.FillBackground(DC, R, AToolbarBrush, clNone, False); end; class function TdxBarPainter.BarHorSize: Integer; begin Result := 0; end; function TdxBarPainter.BarMarkRect(ABarControl: TdxBarControl): TRect; begin Result := BarMarkItemRect(ABarControl); end; function TdxBarPainter.BarMarkItemRect(ABarControl: TdxBarControl): TRect; begin // TODO: Required SetRectEmpty(Result); end; procedure TdxBarPainter.BarMarkRectInvalidate(ABarControl: TdxBarControl); var DC: HDC; begin if ABarControl.DockingStyle = dsNone then begin DC := GetWindowDC(ABarControl.Handle); ABarControl.DrawMark(DC); ReleaseDC(ABarControl.Handle, DC); end else cxInvalidateRect(ABarControl.Handle, BarMarkItemRect(ABarControl), False); end; class function TdxBarPainter.BarTopSize: Integer; begin Result := 0; end; class function TdxBarPainter.BarBottomSize: Integer; begin Result := 0; end; class function TdxBarPainter.BarUseSystemClose: Boolean; begin Result := False; end; class function TdxBarPainter.BarUseSystemNCBorder: Boolean; begin Result := False; end; function TdxBarPainter.MarkSizeX: Integer; begin Result := 11; end; function TdxBarPainter.MarkSizeY: Integer; begin Result := 9; end; class procedure TdxBarPainter.StatusBarFillBackground(ABarControl: TdxBarControl; DC: HDC; ADestR, ASourceR, AWholeR: TRect; ABrush: HBRUSH; AColor: TColor); begin FillBackgroundRect(DC, ADestR, ASourceR, ABrush, AColor, nil); end; class function TdxBarPainter.StatusBarGripSize(ABarManager: TdxBarManager): TSize; begin Result.cx := GetSystemMetrics(SM_CXHSCROLL); Result.cy := GetSystemMetrics(SM_CYHSCROLL); end; class function TdxBarPainter.StatusBarTopBorderSize(ABarManager: TdxBarManager): Integer; begin Result := 2; end; class function TdxBarPainter.BarToolbarBrushEx2(ABarControl: TdxBarControl): HBRUSH; begin Result := BarToolbarBrushEx(ABarControl); end; class procedure TdxBarPainter.DrawQuickCustItemFrame(ABarItemControl: TdxBarItemControl; DC: HDC; var R, ARect: TRect; Selected: Boolean); begin with R do Right := Left + Bottom - Top; ARect.Left := R.Right; end; class procedure TdxBarPainter.DrawQuickCustItemFrameSelected(ABarItemControl: TdxBarItemControl; DC: HDC; WholeR, R: TRect; Selected: Boolean); begin end; class function TdxBarPainter.IsQuickControlPopupOnRight: Boolean; begin Result := False; end; class function TdxBarPainter.GetTailAreaSize(const ADrawParams: TdxBarItemControlDrawParams): Integer; begin Result := ADrawParams.BarItemControl.Parent.IconAreaSize; end; class function TdxBarPainter.ItemControlGetIndents(const ADrawParams: TdxBarItemControlDrawParams; ADrawAreaType: TdxBarItemControlPart): TRect; begin Result := cxRect(3, 0, 3, 0); end; function TdxBarPainter.GetButtonBorderHeight: Integer; begin Result := dxBarButtonBorderHeight; end; function TdxBarPainter.GetButtonBorderWidth: Integer; begin Result := dxBarButtonBorderWidth; end; function TdxBarPainter.GetButtonHeight(AIconSize, ATextSize: Integer): Integer; begin Result := AIconSize + GetButtonBorderHeight; end; function TdxBarPainter.GetButtonWidth(AIconSize, ATextSize: Integer): Integer; begin Result := AIconSize + GetButtonBorderWidth; end; function TdxBarPainter.GetButtonSize(AIconSize, ATextSize: Integer): TSize; begin Result := Size(GetButtonWidth(AIconSize, ATextSize), GetButtonHeight(AIconSize, ATextSize)); end; class procedure TdxBarPainter.CorrectButtonControlDefaultHeight(var DefaultHeight: Integer); begin end; class procedure TdxBarPainter.CorrectButtonControlDefaultWidth(var DefaultWidth: Integer); begin end; class function TdxBarPainter.IsDropDownRepaintNeeded: Boolean; begin Result := False; end; class procedure TdxBarPainter.OffsetCaptionBounds(ADown, APressed: Boolean; var R: TRect); begin end; class procedure TdxBarPainter.OffsetEllipsisBounds(APressed: Boolean; var R: TRect); begin end; procedure TdxBarPainter.DrawButtonLikeControl( const ADrawParams: TdxBarButtonLikeControlDrawParams; ARect: TRect); function GetFullBounds(const AFullRect: TRect): TRect; begin if ADrawParams.DroppedDownFlat then Result := ARect else if ADrawParams.ViewSize = cvsLarge then Result := AFullRect else Result := cxEmptyRect; end; var R, AFullRect, AImageBounds: TRect; ATextAlignment: DWORD; begin with ADrawParams do begin if IsLowered then DrawLowered(Canvas.Handle, ARect); R := ARect; if PaintType = ptMenu then DrawGlyphAndTextInSubMenu(ADrawParams, R) else begin if IsDropDown and SplitDropDown then Dec(R.Right, cxRectWidth(BarItemControl.FParts[bcpDropButton])); if ViewSize = cvsLarge then begin AFullRect := R; InflateRect(R, -1, -1); OffsetCaptionBounds(Downed, IsPressed, R); end else AFullRect := ARect; DrawGlyph(BarItemControl, Canvas.Handle, R, GetFullBounds(AFullRect), AImageBounds, PaintType, ViewStructure, ViewSize, not (cpIcon in ViewStructure), DrawSelected, Downed, IsPressed, DroppedDown, False, False, GrayScale, SplitDropDown and IsDropDown); if cpText in ViewStructure then begin CorrectCaptionParams(ADrawParams, R, AImageBounds, ATextAlignment); DrawItemText(BarItemControl, Canvas.Handle, Caption, R, ATextAlignment, Enabled, IsTextSelected, PaintType = ptVert, False, IsFlatText); end; end; if IsDropDown and not IsMenuItem then begin if SplitDropDown then DrawSplitControlArrow(ADrawParams, ARect) else DrawAssociateControlArrow(ADrawParams, ARect); end; end; end; procedure TdxBarPainter.DrawButtonLikeControlCaption( const ADrawParams: TdxBarButtonLikeControlDrawParams; const ARect, AImageBounds: TRect); var ATextAlignment: DWORD; ATextBounds: TRect; begin if cpText in ADrawParams.ViewStructure then begin ATextBounds := ARect; CorrectCaptionParams(ADrawParams, ATextBounds, AImageBounds, ATextAlignment); ButtonLikeControlDoDrawCaption(ADrawParams, ATextBounds, ATextAlignment); end; end; procedure TdxBarPainter.DrawButtonControlArrow( const ADrawParams: TdxBarButtonLikeControlDrawParams; R1: TRect; ABrush: HBRUSH); begin // Required end; procedure TdxBarPainter.DrawSplitControlArrow( const ADrawParams: TdxBarButtonLikeControlDrawParams; ARect: TRect); var AArrowColor: COLORREF; ABrush: HBRUSH; begin ARect.Left := ARect.Right - ADrawParams.ArrowWidth; GetArrowParams(ADrawParams, ABrush, AArrowColor); DrawButtonControlArrow(ADrawParams, ARect, ABrush); end; procedure TdxBarPainter.DrawAssociateControlArrow( const ADrawParams: TdxBarButtonLikeControlDrawParams; ARect: TRect); var ASize: Integer; begin with ADrawParams do if PaintType = ptMenu then begin ASize := BarItemControl.Parent.MenuArrowHeight; ARect.Left := ARect.Right - BarItemControl.Parent.TextSize + ASize; DrawLargeItemArrow(Canvas.Handle, ARect, adRight, ASize, DrawSelected and not IsFlatItemTextForMenu, Enabled, IsFlatItemText); end else begin ASize := BarItemControl.Parent.MenuArrowHeight - 1; OffsetCaptionBounds(False, DroppedDown, ARect); case PaintType of ptHorz: begin ARect.Left := ARect.Right - BarItemControl.Parent.TextSize div 2 + BarItemControl.Parent.Font.Height div 2; DrawLargeItemArrow(Canvas.Handle, ARect, adDown, ASize, IsTextSelected, Enabled, IsFlatItemText); end; ptVert: begin ARect.Top := ARect.Bottom - BarItemControl.Parent.TextSize div 2 + BarItemControl.Parent.Font.Height div 2; DrawLargeItemArrow(Canvas.Handle, ARect, adRight, ASize, IsTextSelected, Enabled, IsFlatItemText); end; end; end; end; class function TdxBarPainter.ComboControlArrowOffset: Integer; begin Result := 1; end; class function TdxBarPainter.ComboControlButtonOffsets: TRect; begin Result := EditControlBorderOffsets; Result.Left := ComboControlArrowOffset; end; procedure TdxBarPainter.ComboControlDrawArrowButton( const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); var ABrush: HBRUSH; AArrowColor: COLORREF; X, Y, ASize: Integer; begin with ADrawParams do begin ComboControlGetArrowParams(ADrawParams, ABrush, AArrowColor); ComboControlDrawSimpleButton(BarItemControl, Canvas.Handle, ARect, DroppedDown, DrawSelected, ABrush, PaintType); ASize := (ARect.Right - ARect.Left) div 2; if not Odd(ASize) then Inc(ASize); X := (ARect.Left + ARect.Right - ASize) div 2; Y := (ARect.Top + ARect.Bottom - ASize div 2) div 2; ComboControlDrawArrow(BarItemControl, Canvas.Handle, X, Y, ASize, AArrowColor); end; end; class procedure TdxBarPainter.ComboControlDrawSimpleButton( ABarComboControl: TdxBarItemControl; ADC: HDC; var ARect: TRect; ADroppedDown, ASelected: Boolean; ABrush: HBRUSH; APaintType: TdxBarPaintType); begin // Required end; class procedure TdxBarPainter.ComboControlGetArrowParams( const ADrawParams: TdxBarEditLikeControlDrawParams; out ABrush: HBRUSH; out AArrowColor: COLORREF); begin GetArrowParams(ADrawParams, ABrush, AArrowColor); end; class function TdxBarPainter.DropDownListBoxBorderSize: Integer; begin // Required Result := 0; end; procedure TdxBarPainter.DropDownListBoxDrawBorder(DC: HDC; AColor: TColor; ARect: TRect); begin FrameRect(DC, ARect, GetSysColorBrush(COLOR_BTNSHADOW)); InflateRect(ARect, -1, -1); FrameRectByColor(DC, ARect, AColor); end; class function TdxBarPainter.SubMenuControlArrowsOffset: Integer; begin Result := 2; end; class function TdxBarPainter.SubMenuControlArrowWidth(ATextSize: Integer): Integer; begin Result := ATextSize div 4 * 3 + 1; end; class function TdxBarPainter.SubMenuControlBeginGroupRect( ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; const AItemRect: TRect): TRect; begin Result := AItemRect; if AControl.FChangeRecentGroup and AControl.NonRecent then Dec(Result.Top); Result.Bottom := Result.Top; Dec(Result.Top, ABarSubMenuControl.BeginGroupSize); end; class function TdxBarPainter.SubMenuControlBeginGroupSize: Integer; begin Result := 4 + 2 + 4; end; class function TdxBarPainter.SubMenuControlBorderSize: Integer; begin Result := SubMenuControlNCBorderSize + SubMenuControlClientBorderSize; end; class function TdxBarPainter.SubMenuControlNCBorderSize: Integer; begin Result := 1; end; class function TdxBarPainter.SubMenuControlClientBorderSize: Integer; begin Result := 2; end; class procedure TdxBarPainter.SubMenuControlCalcDrawingConsts(ACanvas: TcxCanvas; ATextSize: Integer; out AMenuArrowWidth, AMarkSize: Integer); var AArrowSize: Integer; begin AMenuArrowWidth := SubMenuControlArrowWidth(ATextSize); AMarkSize := ACanvas.TextHeight('0') + 1; AArrowSize := SubMenuControlMarkArrowSize(AMarkSize); if Odd(AArrowSize) then AMarkSize := (AArrowSize - 1) * 2 + 2 * 3; end; class function TdxBarPainter.SubMenuControlInternalBorderSize: Integer; begin Result := 0; end; class function TdxBarPainter.SubMenuControlInternalBorderOffset: Integer; begin Result := 0; end; class function TdxBarPainter.SubMenuControlIsOffsetRecentGroupNeeded: Boolean; begin Result := False; end; class function TdxBarPainter.SubMenuControlContentRectOffset(ABarSubMenuControl: TdxBarSubMenuControl): TRect; var AOffset: Integer; begin AOffset := SubMenuControlClientBorderSize; Result := Rect(AOffset, AOffset, AOffset, AOffset); end; class function TdxBarPainter.SubMenuControlDetachCaptionAreaSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; begin Result := 2 + ABarSubMenuControl.DetachCaptionSize + 1; end; procedure TdxBarPainter.SubMenuControlDrawScrollButton(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; AArrowDirection: TcxArrowDirection); begin // do nothing end; procedure TdxBarPainter.SubMenuControlDrawBackground(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; ARect: TRect; ABrush: HBRUSH; AColor: TColor); begin FillBackgroundRect(ACanvas.Handle, ARect, ARect, ABrush, AColor, ABarSubMenuControl.GetBackgroundBitmap); end; procedure TdxBarPainter.SubMenuControlDrawBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); begin with R do begin FillRect(DC, Rect(Left, Top, Left + 1, Bottom - 1), COLOR_BTNFACE + 1); FillRect(DC, Rect(Left + 1, Top, Right - 1, Top + 1), COLOR_BTNFACE + 1); end; DrawEdge(DC, R, BDR_RAISEDOUTER, BF_BOTTOMRIGHT); if ABarSubMenuControl.Detachable then begin InflateRect(R, -1, -1); DrawEdge(DC, R, BDR_RAISEDINNER, BF_RECT - BF_BOTTOM); InflateRect(R, -1, -1); R.Bottom := R.Top + ABarSubMenuControl.DetachCaptionAreaSize - 1; FrameRect(DC, R, GetSysColorBrush(COLOR_BTNFACE)); SubMenuControlDrawDetachCaption(ABarSubMenuControl, DC, ABarSubMenuControl.DetachCaptionRect); end; end; class procedure TdxBarPainter.SubMenuControlDrawClientBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; const R: TRect; ABrush: HBRUSH); var ARect: TRect; begin ARect := R; if ABarSubMenuControl.Detachable then ARect.Top := ARect.Top - 2; DrawEdge(DC, ARect, BDR_RAISEDINNER, BF_RECT); InflateRect(ARect, -1, -1); FrameRect(DC, ARect, ABrush); end; procedure TdxBarPainter.SubMenuControlDrawDetachCaption(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); const Colors: array[Boolean] of COLORREF = (COLOR_INACTIVECAPTION, COLOR_ACTIVECAPTION); begin FillRect(DC, R, Colors[ABarSubMenuControl.DetachCaptionSelected] + 1); end; procedure TdxBarPainter.SubMenuControlDrawBeginGroup(ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; ACanvas: TcxCanvas; const ABeginGroupRect: TRect); var R: TRect; ABrush: HBRUSH; LD, RD: Integer; AOpaque: Boolean; ADC: HDC; begin ADC := ACanvas.Handle; RD := Byte(AControl.FNonRecent); R := ABeginGroupRect; if AControl.FChangeRecentGroup and AControl.FNonRecent then begin RD := 0; ABrush := ABarSubMenuControl.ToolbarBrush; end else ABrush := ABarSubMenuControl.BkBrush; LD := RD * Ord(ABarSubMenuControl.BarSize = 0); AOpaque := AControl.FNonRecent and not AControl.FChangeRecentGroup; DrawBackground(AControl, ADC, Rect(R.Left - LD, R.Top, R.Right + 2 * RD, R.Bottom), ABrush, AOpaque); InflateRect(R, -SubMenuBeginGroupIndent, -4); SubMenuControlDrawSeparator(ACanvas, R); end; class procedure TdxBarPainter.SubMenuControlDrawItemFrame(ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; DC: HDC; AItemRect: TRect; AIndex: Integer); begin // do nothing end; procedure TdxBarPainter.SubMenuControlDrawSeparator(ACanvas: TcxCanvas; const ARect: TRect); var R: TRect; begin R := ARect; DrawEdge(ACanvas.Handle, R, EDGE_ETCHED, BF_TOP); end; class function TdxBarPainter.SubMenuControlGetBandSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; begin Result := ABarSubMenuControl.IconAreaSize; end; class function TdxBarPainter.SubMenuControlGetControlContentIndent(ABarSubMenuControl: TdxBarSubMenuControl): Integer; begin Result := ABarSubMenuControl.BarSize + ABarSubMenuControl.IconAreaSize; CorrectButtonControlDefaultHeight(Result); end; class function TdxBarPainter.SubMenuControlMarkArrowSize(AMarkSize: Integer): Integer; begin Result := (AMarkSize - 2 * (2 + 1)) div 2; end; class function TdxBarPainter.SubMenuControlMarkRectOffset(ABarSubMenuControl: TdxBarSubMenuControl): Integer; begin Result := 1; end; class function TdxBarPainter.SubMenuControlNormalItemHeight: Integer; begin Result := 19; end; class procedure TdxBarPainter.SubMenuControlOffsetDetachCaptionRect(ABarSubMenuControl: TdxBarSubMenuControl; var R: TRect); begin InflateRect(R, -3, -3); end; class procedure TdxBarPainter.SubMenuControlPrepareBkBrush(ABarSubMenuControl: TdxBarSubMenuControl; var ABkBrush: HBRUSH); begin end; class function TdxBarPainter.SubMenuControlTextSize(ACanvas: TcxCanvas): Integer; begin Result := GetDefaultTextSize(ACanvas); end; class function TdxBarPainter.SubMenuControlToolbarItemsBrush(ABarSubMenuControl: TdxBarSubMenuControl): HBRUSH; begin Result := COLOR_BTNFACE + 1; end; procedure TdxBarPainter.ApplicationMenuDrawBorder( ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; const ARect: TRect); begin SubMenuControlDrawBorder(ABarSubMenuControl, DC, ARect); end; procedure TdxBarPainter.ApplicationMenuDrawButton(const ADrawParams: TdxBarApplicationMenuButtonControlDrawParams; var R: TRect); begin // do nothing end; procedure TdxBarPainter.ApplicationMenuDrawContentArea( ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; const AContentRect, AItemsArea: TRect); begin ACanvas.ExcludeClipRect(AItemsArea); SubMenuControlDrawBackground(ABarSubMenuControl, ACanvas, AContentRect, ABarSubMenuControl.ToolbarDownedBrush, clNone); end; function TdxBarPainter.ApplicationMenuGetFrameSizes: TRect; begin Result := cxNullRect; end; procedure TdxBarPainter.ExtraMenuControlDrawBackground(AExtraMenuControl: TCustomdxBarControl; ACanvas: TcxCanvas; ARect: TRect; ABrush: HBRUSH; AColor: TColor); begin FillBackgroundRect(ACanvas.Handle, ARect, ARect, ABrush, AColor, AExtraMenuControl.GetBackgroundBitmap); // SubMenuControlDrawBackground(ABarSubMenuControl, ACanvas, ARect, ABrush, AColor); end; procedure TdxBarPainter.ExtraMenuControlDrawBeginGroup(AExtraMenuControl: TCustomdxBarControl; ACanvas: TcxCanvas; ABeginGroupRect: TRect; AToolbarBrush: HBRUSH; AHorz: Boolean); begin BarDrawBeginGroup(AExtraMenuControl, ACanvas.Handle, ABeginGroupRect, AToolbarBrush, AHorz); end; class procedure TdxBarPainter.EditDrawInterior(ABarEditControl: TdxBarEditControl; ABarEdit: TdxBarEdit; ACanvas: TCanvas; R: TRect; ItemLink: TdxBarItemLink); var DC: HDC; S: string; begin DC := ACanvas.Handle; FillRect(DC, R, ACanvas.Brush.Handle); // draw only client area Inc(R.Left, 2); Dec(R.Right, 2); EditOffsetInteriorRect(R); if ABarEdit.FocusedItemLink = ItemLink then S := ABarEdit.CurText else S := ABarEdit.Text; SetBkMode(DC, TRANSPARENT); cxDrawText(DC, S, R, DT_NOPREFIX); SetBkMode(DC, OPAQUE); end; class function TdxBarPainter.EditGetRealPaintStyle(ABarManager: TdxBarManager): TdxBarManagerStyle; begin Result := ABarManager.GetRealPaintStyle; end; function TdxBarPainter.EditGetEnabledBkColor(ABarItemControl: TdxBarCustomEditControl): COLORREF; begin Result := GetSysColor(COLOR_WINDOW); end; function TdxBarPainter.EditGetDisabledBkColor(ABarItemControl: TdxBarCustomEditControl): COLORREF; begin Result := cxGetBrushData(ABarItemControl.Parent.BkBrush).lbColor; end; function TdxBarPainter.EditGetBkColor(const ADrawParams: TdxBarEditLikeControlDrawParams): COLORREF; var AEditViewParams: TcxViewParams; begin with ADrawParams do if Enabled then begin BarEditControl.Item.GetEditViewParams(AEditViewParams); Result := AEditViewParams.Color; if Result = COLORREF(clDefault) then Result := EditGetEnabledBkColor(BarEditControl); end else Result := EditGetDisabledBkColor(BarEditControl); end; function TdxBarPainter.EditGetEnabledTextColor: COLORREF; begin Result := GetSysColor(COLOR_WINDOWTEXT); end; function TdxBarPainter.EditGetDisabledTextColor: COLORREF; begin Result := GetSysColor(COLOR_GRAYTEXT); end; function TdxBarPainter.EditGetTextColor(ABarItemControl: TdxBarCustomEditControl): COLORREF; var AEditViewParams: TcxViewParams; begin if ABarItemControl.Enabled then begin ABarItemControl.Item.GetEditViewParams(AEditViewParams); Result := AEditViewParams.TextColor; if Result = COLORREF(clDefault) then Result := EditGetEnabledTextColor; end else Result := EditGetDisabledTextColor; end; procedure TdxBarPainter.EditGetColors(ABarItemControl: TdxBarCustomEditControl; var ATextColor, ABkColor: COLORREF); begin ATextColor := EditGetTextColor(ABarItemControl); ABkColor := EditGetBkColor(ABarItemControl.DrawParams); end; procedure TdxBarPainter.EditButtonDrawBorder( const ADrawParams: TdxBarItemControlDrawParams; AState: Integer; var ADrawRect: TRect; out AContentRect: TRect); begin // do nothing end; function TdxBarPainter.EditButtonAllowOffsetContent: Boolean; begin Result := True; end; procedure TdxBarPainter.EditButtonDrawBackground(const ADrawParams: TdxBarEditLikeControlDrawParams; AState: Integer; ARect: TRect; ABrush: HBrush); begin // do nothing end; function TdxBarPainter.EditButtonAllowCompositeFrame: Boolean; begin Result := False; end; class function TdxBarPainter.EditButtonAllowHotTrack(const ADrawParams: TdxBarItemControlDrawParams): Boolean; begin Result := ADrawParams.DrawSelected; end; class function TdxBarPainter.EditButtonIsCustomBorder: Boolean; begin Result := False; end; class function TdxBarPainter.EditButtonIsCustomBackground(AState: Integer): Boolean; begin Result := False; end; class procedure TdxBarPainter.CustomComboDrawItem(ABarCustomCombo: TdxBarCustomCombo; ACanvas: TCanvas; AIndex: Integer; ARect: TRect; AState: TOwnerDrawState; AInteriorIsDrawing: Boolean); var S: string; begin with ACanvas, ARect do begin if AIndex = -1 then S := ABarCustomCombo.Text else S := ABarCustomCombo.Items[AIndex]; FillRect(ARect); TextOut(Left + 2, Top, S); end; end; procedure TdxBarPainter.DrawEditLikeControl(const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); begin with ADrawParams do begin if (PaintType = ptMenu) and DrawSelected then EditControlDrawSelectionFrame(ADrawParams, ARect); BarEditControl.DrawFrame; if cpIcon in ViewStructure then EditControlDrawGlyph(ADrawParams, BarEditControl.FParts[ecpIcon]); if cpText in ViewStructure then EditControlDrawCaption(ADrawParams, BarEditControl.FParts[ecpText]); BarEditControl.DrawTextField; end; end; class function TdxBarPainter.EditControlBorderOffsets: TRect; begin Result := Rect(2, 2, 2, 2); end; procedure TdxBarPainter.EditControlDrawBorder( const ADrawParams: TdxBarEditLikeControlDrawParams; var ARect: TRect); var ABrush: HBRUSH; begin with ADrawParams do begin if DrawSelected then DrawEdge(Canvas.Handle, ARect, BDR_SUNKENOUTER, BF_RECT) else DrawBackgroundFrameRect(BarEditControl, Canvas.Handle, ARect, BarEditControl.Parent.BkBrush, BarEditControl.FNonRecent); InflateRect(ARect, -1, -1); if Enabled or IsTransparent then ABrush := BarEditControl.Parent.BkBrush else ABrush := GetSysColorBrush(COLOR_BTNHIGHLIGHT); DrawBackgroundFrameRect(BarEditControl, Canvas.Handle, ARect, ABrush, BarEditControl.FNonRecent or (DrawSelected or not Enabled) and not IsTransparent); InflateRect(ARect, -1, -1); end; end; procedure TdxBarPainter.EditControlDrawCaption(const ADrawParams: TdxBarEditLikeControlDrawParams; const ARect: TRect); var AIndentRect, ATextRect: TRect; begin with ADrawParams do begin ATextRect := ARect; ATextRect.Right := ATextRect.Right - EditControlGetIndents(ADrawParams, cpText).Right; AIndentRect := ARect; AIndentRect.Left := ATextRect.Right; DrawBackground(BarEditControl, Canvas.Handle, ATextRect, BarEditControl.CaptionBkBrush, EditControlCaptionBackgroundIsOpaque(ADrawParams)); DrawBackground(BarEditControl, Canvas.Handle, AIndentRect, EditControlGetRightCaptionIndentBrush(BarEditControl), EditControlCaptionRightIndentIsOpaque(ADrawParams)); DrawItemText(BarEditControl, Canvas.Handle, Caption, ATextRect, DT_RIGHT, Enabled, DrawSelected and (PaintType = ptMenu), False, False, IsFlatItemTextForMenu); Canvas.SetClipRegion(TcxRegion.Create(ARect), roSubtract); end; end; procedure TdxBarPainter.EditControlDrawSelectionFrame(const ADrawParams: TdxBarEditLikeControlDrawParams; const ARect: TRect); begin FrameFlatSelRect(ADrawParams.Canvas.Handle, ARect); end; procedure TdxBarPainter.EditControlDrawGlyph(const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); begin with ADrawParams do begin if PaintType <> ptMenu then begin DrawBackground(BarEditControl, Canvas.Handle, ARect, BarEditControl.CaptionBkBrush, EditControlCaptionBackgroundIsOpaque(ADrawParams)); Inc(ARect.Left, EditControlGetIndents(ADrawParams, cpIcon).Left); Dec(ARect.Right, EditControlGetIndents(ADrawParams, cpIcon).Right); end; DrawGlyph(BarEditControl, Canvas.Handle, ARect, ARect, PaintType, False, EditControlGlyphIsDrawSelected(BarEditControl), False, False, False, True, False, False); Canvas.SetClipRegion(TcxRegion.Create(ARect), roSubtract); end; end; class function TdxBarPainter.EditControlCaptionBackgroundIsOpaque( const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; begin with ADrawParams do Result := (PaintType = ptMenu) and (DrawSelected or ADrawParams.BarItemControl.FNonRecent); end; class function TdxBarPainter.EditControlCaptionRightIndentIsOpaque( const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; begin with ADrawParams do Result := (PaintType = ptMenu) and (ADrawParams.BarItemControl.FNonRecent); end; procedure TdxBarPainter.EditControlDrawTextField(ABarEditControl: TdxBarEditControl; DC: HDC; const ARect: TRect; AIgnoreEnabled: Boolean); var ATextColor, ABkColor: COLORREF; PrevClipRgn: HRGN; ClipRgnExists: Boolean; PrevFont: HFONT; begin // if ABarEditControl.Enabled or AIgnoreEnabled then if True then begin EditGetColors(ABarEditControl, ATextColor, ABkColor); SetTextColor(DC, ATextColor); PrevClipRgn := CreateRectRgn(0, 0, 0, 0); ClipRgnExists := GetClipRgn(DC, PrevClipRgn) = 1; with ARect do IntersectClipRect(DC, Left, Top, Right, Bottom); try with ABarEditControl.Parent.Canvas do begin Font.Color := ATextColor; Brush.Color := ABkColor; Handle; // RequiredState(csAllValid) end; PrevFont := SelectObject(DC, ABarEditControl.EditFont.Handle); try ABarEditControl.Item.DrawInterior(ABarEditControl, ABarEditControl.Canvas.Canvas, ARect, ABarEditControl.ItemLink); finally if GetObjectType(PrevFont) = OBJ_FONT then SelectObject(DC, PrevFont); end; finally if ClipRgnExists then SelectClipRgn(DC, PrevClipRgn) else SelectClipRgn(DC, 0); DeleteObject(PrevClipRgn); end; end else FillRect(DC, ARect, ABarEditControl.Parent.BkBrush); end; class function TdxBarPainter.EditControlES_Style: Integer; begin Result := ES_AUTOHSCROLL; end; function TdxBarPainter.EditControlGetContentRect(const ARect: TRect): TRect; begin Result := cxRectContent(ARect, EditControlBorderOffsets); end; class function TdxBarPainter.EditControlShowIconDefault(const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; begin Result := False; end; class function TdxBarPainter.EditControlGetIndents( const ADrawParams: TdxBarEditLikeControlDrawParams; ADrawAreaType: TdxBarItemControlPart): TRect; begin case ADrawAreaType of cpText: Result := Rect(EditControlCaptionGetLeftIndent(ADrawParams), 0, EditControlCaptionRightIndent, 0);//4 else {cpIcon} if ADrawParams.PaintType = ptMenu then Result := EditControlSubmenuGlyphIndents(ADrawParams) //Result := Rect(2, 0, 2, 0) else Result := Rect((ADrawParams.DefaultButtonSize.cx - ADrawParams.BarItemControl.GetGlyphSize(ADrawParams.ViewSize).cx) div 2, 0, GetControlTextIndents.Left, 0); end; end; class function TdxBarPainter.EditControlCaptionGetLeftIndent( const ADrawParams: TdxBarEditLikeControlDrawParams): Integer; begin if (cpIcon in ADrawParams.ViewStructure) then if (ADrawParams.PaintType <> ptMenu) then Result := 0 else Result := EditControlCaptionIconRelativeLeftIndent(ADrawParams) //In Submenu else Result := EditControlCaptionLeftIndent(ADrawParams); end; class function TdxBarPainter.EditControlCaptionIconRelativeLeftIndent( const ADrawParams: TdxBarEditLikeControlDrawParams): Integer; begin Result := 2; end; class function TdxBarPainter.EditControlCaptionLeftIndent( const ADrawParams: TdxBarEditLikeControlDrawParams): Integer; begin Result := 2 end; class function TdxBarPainter.EditControlCaptionRightIndent: Integer; begin Result := 4; end; class function TdxBarPainter.EditControlSubmenuGlyphIndents( const ADrawParams: TdxBarEditLikeControlDrawParams): TRect; begin Result := Rect(4, 0, 0, 0); end; class function TdxBarPainter.EditControlGetRightCaptionIndentBrush( ABarEditControl: TdxBarCustomEditControl): HBRUSH; begin Result := ABarEditControl.Parent.BkBrush; end; class function TdxBarPainter.EditControlGlyphIsDrawSelected( ABarEditControl: TdxBarCustomEditControl): Boolean; begin Result := False; end; class procedure TdxBarPainter.EditControlPrepareEditWnd(ABarEditControl: TdxBarEditControl; AHandle: HWND); begin end; procedure TdxBarPainter.ColorComboCorrectFrameRect( const ADrawParams: TdxBarColorComboControlDrawParams; var ARect: TRect); begin // do nothing end; procedure TdxBarPainter.ColorComboDrawCustomButton( const ADrawParams: TdxBarColorComboControlDrawParams; ARect: TRect); begin with ADrawParams do FrameAndFillRect(BarItemControl, Canvas.Handle, ARect, Enabled, DrawSelected, IsPressed); DrawDots(ADrawParams, ARect); end; procedure TdxBarPainter.ColorComboDrawCustomButtonAdjacentZone( const ADrawParams: TdxBarColorComboControlDrawParams; ARect: TRect); begin with ADrawParams do begin DrawBackgroundFrameRect(BarItemControl, Canvas.Handle, ARect, BarItemControl.Parent.BkBrush, False); InflateRect(ARect, 0, -1); DrawBackgroundFrameRect(BarItemControl, Canvas.Handle, ARect, BarItemControl.Parent.BkBrush, False); end; end; function TdxBarPainter.GetCustomColorButtonIndents( const ADrawParams: TdxBarColorComboControlDrawParams): TRect; begin Result := Rect(1, 2, 1, 2); end; function TdxBarPainter.IsCustomColorButtonVisible( const ADrawParams: TdxBarColorComboControlDrawParams): Boolean; begin Result := cxRectWidth(ADrawParams.BarItemControl.FParts[clcpCustomColorButton]) <> 0; end; class procedure TdxBarPainter.SysPanelCalcSize(AHandle: HWND; var ARect: TRect; var Corner: TdxCorner; Combo: TdxBarItem; AllowResizing: Boolean); var R: TRect; AControl: TdxBarWinControl; begin InflateRect(ARect, -1, -1); if AllowResizing and (Combo.CurItemLink <> nil) and (Combo.CurItemLink.Control <> nil) then begin GetWindowRect(AHandle, R); AControl := TdxBarWinControl(Combo.CurItemLink.Control); MapWindowRect(0, AControl.Parent.Handle, R); Corner := GetCornerForRects(AControl.WindowRect, R); with ARect do if Corner in [coBottomLeft, coBottomRight] then Dec(Bottom, SysPanelSize) else Inc(Top, SysPanelSize); end; end; class procedure TdxBarPainter.SysPanelDraw(AHandle: HWND; AllowResizing, MouseAboveCloseButton, CloseButtonIsTracking: Boolean; var CloseButtonRect, GripRect: TRect; Corner: TdxCorner); begin dxBarPopupNCPaint(AHandle, AllowResizing, False, MouseAboveCloseButton, CloseButtonIsTracking, CloseButtonRect, GripRect, Corner); end; class function TdxBarPainter.SysPanelSize: Integer; begin Result := dxDropDownNCHeight; end; class function TdxBarPainter.IsDateNavigatorFlat: Boolean; begin Result := False; end; class procedure TdxBarPainter.DateNavigatorDrawButton(ABarItem: TdxBarItem; DC: HDC; R: TRect; const ACaption: string; APressed: Boolean); var Offset: Integer; APrevPen: HPEN; begin Offset := 0; with R do begin if APressed then begin DrawFrameControl(DC, R, DFC_BUTTON, DFCS_BUTTONPUSH or DFCS_PUSHED); Offset := 1; end else begin APrevPen := SelectObject(DC, CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNTEXT))); MoveToEx(DC, Left, Bottom - 1, nil); LineTo(DC, Right - 1, Bottom - 1); LineTo(DC, Right - 1, Top); DeleteObject(SelectObject(DC, APrevPen)); APrevPen := SelectObject(DC, CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNFACE))); LineTo(DC, Left, Top); LineTo(DC, Left, Bottom - 1); DeleteObject(SelectObject(DC, APrevPen)); APrevPen := SelectObject(DC, CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNSHADOW))); MoveToEx(DC, Left + 1, Bottom - 2, nil); LineTo(DC, Right - 2, Bottom - 2); LineTo(DC, Right - 2, Top + 1); DeleteObject(SelectObject(DC, APrevPen)); APrevPen := SelectObject(DC, CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNHIGHLIGHT))); MoveToEx(DC, Left + 1, Bottom - 3, nil); LineTo(DC, Left + 1, Top + 1); LineTo(DC, Right - 2, Top + 1); DeleteObject(SelectObject(DC, APrevPen)); SetPixel(DC, Right - 2, Top + 1, GetSysColor(COLOR_BTNFACE)); end; InflateRect(R, -2, -2); end; // draw button's caption DateNavigatorDrawButtonCaption(DC, R, Offset, ACaption, True); end; function TdxBarPainter.DateNavigatorHeaderColor: TColor; begin Result := clBtnFace; end; function TdxBarPainter.GetSpinEditArrowPos(const ADrawParams: TdxBarSpinEditDrawParams; ARect: TRect; AButtonIndex: Integer): TPoint; begin with ADrawParams do begin Result.X := ARect.Left + ArrowSize.cy; ARect.Top := (ARect.Top + ARect.Bottom - ArrowSize.cy) div 2 + Byte(AButtonIndex = secButtonUp) * (ArrowSize.cy - 1); Result.Y := ARect.Top; end; end; procedure TdxBarPainter.SpinEditCorrectFrameRect(const ADrawParams: TdxBarItemControlDrawParams; var ARect: TRect); begin ARect.Right := ADrawParams.BarItemControl.FParts[secButtonUp].Left - GetSpinEditButtonIndents.Left; end; function TdxBarPainter.GetSpinEditArrowSize(AHeight: Integer): TSize; begin Result.cy := (AHeight div 2 - 2) div 2; Result.cx := 2 * Result.cy - 1; end; function TdxBarPainter.GetSpinEditButtonBounds(const ARect: TRect; AButton: TdxBarSpinEditButton): TRect; function IsButtonsWidthTooLarge(AButtonsWidth: Integer): Boolean; begin Result := AButtonsWidth >= cxRectWidth(ARect) div 2; end; var AArrowSize: TSize; AButtonsWidth: Integer; begin Result := ARect; AArrowSize := GetSpinEditArrowSize(cxRectHeight(ARect)); AButtonsWidth := AArrowSize.cx + 2 * (1 + 1 + AArrowSize.cy); if IsButtonsWidthTooLarge(AButtonsWidth) then AButtonsWidth := 0; Result.Left := Result.Right - AButtonsWidth; Result := cxRectContent(Result, GetSpinEditButtonIndents); case AButton of sbUp: Result.Bottom := (Result.Bottom + Result.Top) div 2; sbDown: Result.Top := (Result.Bottom + Result.Top) div 2; end; end; function TdxBarPainter.GetSpinEditButtonIndents: TRect; begin Result := Rect(1, 0, 1, 0); end; procedure TdxBarPainter.SpinEditControlDrawButton(const ADrawParams: TdxBarSpinEditDrawParams; ARect: TRect; AButtonIndex: Integer); procedure OffsetArrowPosIfActive(var AArrowPos: TPoint); begin if AButtonIndex = ADrawParams.ActiveButtonIndex then AArrowPos := cxPointOffset(AArrowPos, 1, 1); end; var AArrowPos: TPoint; begin with ADrawParams do begin FrameAndFillRect(BarEditControl, Canvas.Handle, ARect, Enabled, DrawSelected, ActiveButtonIndex = AButtonIndex); AArrowPos := GetSpinEditArrowPos(ADrawParams, ARect, AButtonIndex); OffsetArrowPosIfActive(AArrowPos); DrawSpinEditArrow(ADrawParams, AArrowPos, AButtonIndex); end; end; procedure TdxBarPainter.SpinEditControlDrawButtonsAdjacentZone(const ADrawParams: TdxBarSpinEditDrawParams; const ARect: TRect); begin with ADrawParams do DrawBackground(BarEditControl, Canvas.Handle, ARect, BarEditControl.Parent.BkBrush, False); end; class function TdxBarPainter.ProgressControlBarBrushColor: TColorRef; begin Result := GetSysColor(COLOR_HIGHLIGHT); end; class function TdxBarPainter.ProgressControlBarHeight(ABarItemControl: TdxBarItemControl): Integer; begin Result := 12; end; procedure TdxBarPainter.ProgressControlDrawBar(const ADrawParams: TdxbarProgressControlDrawParams; BarR: TRect; ABarBrushColor: TColorRef); var R: TRect; Limit, Step: Integer; ALeft, ARight: ^Integer; ABarBrush: HBRUSH; begin with ADrawParams do begin R := BarR; ProgressControlDrawBackground(ADrawParams, R); with R do if PaintType = ptVert then begin ALeft := @Top; ARight := @Bottom; end else begin ALeft := @Left; ARight := @Right; end; ARight^ := ALeft^ + MulDiv(ARight^ - ALeft^, Position - Min, Max - Min); Limit := ARight^; ABarBrush := CreateSolidBrush(ABarBrushColor); if Smooth then ProgressControlFillContent(ADrawParams, R, ABarBrush) else begin with R do if PaintType = ptVert then Step := MulDiv(Right - Left, 2, 3) else Step := MulDiv(Bottom - Top, 2, 3); repeat ARight^ := ALeft^ + Step; if ARight^ > Limit then ARight^ := Limit; ProgressControlFillDiscreteContent(ADrawParams, R, ABarBrush); ALeft^ := ARight^; Inc(ARight^, 2); if ARight^ > Limit then ARight^ := Limit; ALeft^ := ARight^; until ARight^ = Limit; end; if PaintType = ptVert then BarR.Top := Limit else BarR.Left := Limit; DeleteObject(ABarBrush); end; end; procedure TdxBarPainter.ProgressControlFillContent(const ADrawParams: TdxBarItemControlDrawParams; const R: TRect; ABarBrush: HBRUSH); begin FillRect(ADrawParams.Canvas.Handle, R, ABarBrush); end; procedure TdxBarPainter.ProgressControlFillDiscreteContent(const ADrawParams: TdxBarItemControlDrawParams; const R: TRect; ABarBrush: HBRUSH); begin ProgressControlFillContent(ADrawParams, R, ABarBrush); end; procedure TdxBarPainter.ProgressControlDrawBackground(const ADrawParams: TdxBarItemControlDrawParams; var BarR: TRect); begin with ADrawParams do DrawBackground(BarItemControl, Canvas.Handle, BarR, BarItemControl.Parent.BkBrush, False); end; class function TdxBarPainter.ProgressControlIndent(const ADrawParams: TdxBarItemControlDrawParams): Integer; begin Result := 0; end; class function TdxBarPainter.ContainerControlSubMenuOffset: Integer; begin Result := 0; end; class function TdxBarPainter.InPlaceSubItemControlBrush: HBRUSH; begin Result := GetSysColorBrush(COLOR_BTNSHADOW); end; class function TdxBarPainter.InPlaceSubItemGetArrowWidth(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams): Integer; begin Result := ADrawParams.BarItemControl.SubMenuParent.TextSize; end; class function TdxBarPainter.InPlaceSubItemGetTextIndent: Integer; begin Result := 5; end; function TdxBarPainter.InPlaceSubItemControlIsFlatItemText(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams): Boolean; begin Result := ADrawParams.DrawSelected; end; function TdxBarPainter.InPlaceSubItemControlIsArrowSelected(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams): Boolean; begin Result := True; end; procedure TdxBarPainter.InPlaceSubItemControlDrawArrow(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams; ADirection: TcxArrowDirection; ARect: TRect); var ASize: Integer; begin with ADrawParams do begin ASize := BarItemControl.Parent.MenuArrowHeight; ARect.Left := ARect.Right - ArrowWidth; if not IsExpanded then Inc(ARect.Left, ASize); DrawLargeItemArrow(Canvas.Handle, ARect, ADirection, ASize, True, True, IsFlatItemText); end; end; procedure TdxBarPainter.InPlaceSubItemControlDrawBackground(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams; ARect: TRect); const InternalSeparatorSize = 1; var ABrush: HBRUSH; begin with ADrawParams do begin FillRect(Canvas.Handle, cxRectInflate(ARect, 0, cxRectHeight(ARect) - InternalSeparatorSize, 0, 0), BarItemControl.Parent.BkBrush); Dec(ARect.Bottom, InternalSeparatorSize); if DrawSelected then ABrush := BarItemControl.Parent.ToolbarSelBrush else ABrush := InPlaceSubItemControlBrush; DrawBackground(BarItemControl, Canvas.Handle, ARect, ABrush, True{Opaque}); if DrawSelected then FrameFlatSelRect(Canvas.Handle, ARect); end; end; procedure TdxBarPainter.InPlaceSubItemControlDrawInMenu(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams; ARect: TRect); const Arrows: array[Boolean] of TcxArrowDirection = (adRight, adDown); begin with ADrawParams do begin InPlaceSubItemControlDrawBackground(ADrawParams, ARect); Inc(ARect.Left, InPlaceSubItemGetTextIndent); DrawItemText(BarItemControl, Canvas.Handle, Caption, ARect, DT_LEFT, True, True, False, False, InPlaceSubItemControlIsFlatItemText(ADrawParams)); if Enabled then InPlaceSubItemControlDrawArrow(ADrawParams, Arrows[IsExpanded], ARect); end; end; procedure TdxBarPainter.DrawStaticBorder(const ADrawParams: TdxBarStaticLikeControlDrawParams; var ARect: TRect); const Borders: array[TdxBarStaticBorderStyle] of Integer = (0, BDR_SUNKENOUTER, BDR_RAISEDINNER, EDGE_ETCHED, 0); begin with ADrawParams do begin if BorderStyle = sbsNone then Exit; if BorderStyle = sbsBump then begin DrawEdge(Canvas.Handle, ARect, BDR_RAISEDINNER, BF_RECT); InflateRect(ARect, -1, -1); DrawEdge(Canvas.Handle, ARect, BDR_SUNKENOUTER, BF_RECT); InflateRect(ARect, -1, -1); end else begin DrawEdge(Canvas.Handle, ARect, Borders[BorderStyle], BF_RECT); InflateRect(ARect, -BorderWidth, -BorderWidth); end; end; end; procedure TdxBarPainter.DrawStaticGlyphAndCaption(const ADrawParams: TdxBarStaticLikeControlDrawParams; const ARect: TRect); function IsGlyphCenter: Boolean; begin Result := ADrawParams.AllowCenter; if ADrawParams.PaintType = ptMenu then Result := Result and not (cpText in ADrawParams.ViewStructure); end; function GetGlyphRect: TRect; begin Result := ARect; with ADrawParams do case PaintType of ptMenu: if not IsGlyphCenter then Result := GetSubMenuItemIconRect(ARect, BarItemControl.Parent.IconAreaSize); ptHorz: if cpText in ViewStructure then Result.Right := Result.Left + DefaultButtonSize.cx; ptVert: if cpText in ViewStructure then Result.Bottom := Result.Top + DefaultButtonSize.cy; end; end; function IsTextCenter: Boolean; begin Result := ADrawParams.AllowCenter and (ADrawParams.Alignment = taCenter); end; function GetTextIndent: Integer; begin Result := 0; with ADrawParams do if cpIcon in ViewStructure then case PaintType of ptHorz: Result := DefaultButtonSize.cx + 2; ptVert: Result := DefaultButtonSize.cy + 2; ptMenu: if Alignment = taLeftJustify then Result := GetSubMenuItemTextIndent(ADrawParams) end else if not IsTextCenter then Result := BarItemControl.Parent.TextSize div 4; end; function GetTextRect: TRect; var ALeftJustify: Boolean; begin Result := ARect; with ADrawParams do begin ALeftJustify := Alignment = taLeftJustify; if PaintType in [ptMenu, ptHorz] then if ALeftJustify or IsTextCenter then Inc(Result.Left, GetTextIndent) else Dec(Result.Right, 2) else if ALeftJustify or IsTextCenter then Inc(Result.Top, GetTextIndent) else Dec(Result.Bottom, 2); end; end; begin with ADrawParams do begin DrawBackground(BarItemControl, Canvas.Handle, ARect, BarItemControl.BkBrush, StaticBackgroundIsOpaque(ADrawParams)); if cpIcon in ViewStructure then DrawGlyph(BarItemControl, Canvas.Handle, GetGlyphRect, cxEmptyRect, PaintType, False, False, False, False, False, IsGlyphCenter, True, False); if cpText in ViewStructure then DrawItemText(BarItemControl, Canvas.Handle, Caption, GetTextRect, SystemAlignmentsHorz[Alignment], Enabled, False, PaintType = ptVert, True, False); end; end; procedure TdxBarPainter.DrawStaticLikeControl(const ADrawParams: TdxBarStaticLikeControlDrawParams; var ARect: TRect; const AIndentsRect: TRect); procedure DrawIndents; procedure DrawLeftIndent; var R: TRect; begin R := ARect; if AIndentsRect.Left <> 0 then begin if ADrawParams.PaintType = ptVert then begin Inc(ARect.Top, AIndentsRect.Left); R.Bottom := ARect.Top; end else begin Inc(ARect.Left, AIndentsRect.Left); R.Right := ARect.Left; end; with ADrawParams do DrawBackground(BarItemControl, Canvas.Handle, R, BarItemControl.Parent.BkBrush, False); end; end; procedure DrawRightIndent; var R: TRect; begin R := ARect; if AIndentsRect.Right <> 0 then begin if ADrawParams.PaintType = ptVert then begin R.Bottom := ARect.Bottom; Dec(ARect.Bottom, AIndentsRect.Right); R.Top := ARect.Bottom; end else begin R.Right := ARect.Right; Dec(ARect.Right, AIndentsRect.Right); R.Left := ARect.Right; end; with ADrawParams do DrawBackground(BarItemControl, Canvas.Handle, R, BarItemControl.Parent.BkBrush, False); end; end; begin DrawLeftIndent; DrawRightIndent; end; begin with ADrawParams do begin DrawIndents; DrawStaticBorder(ADrawParams, ARect); BarStaticControl.DrawInterior(ARect); end; end; class function TdxBarPainter.StaticBackgroundIsOpaque(const ADrawParams: TdxBarItemControlDrawParams): Boolean; begin Result := ADrawParams.BarItemControl.IsBkColorAssigned; end; class function TdxBarPainter.SeparatorControlGetIndents(const ADrawParams: TdxBarSeparatorControlDrawParams; ADrawAreaType: TdxBarItemControlPart): TRect; begin Result := cxRect(6, 0, 0, 0); end; function TdxBarPainter.SubMenuGetSeparatorSize: Integer; begin Result := MenuSeparatorSize; end; procedure TdxBarPainter.DrawSeparatorGlyphAndCaption(const ADrawParams: TdxBarSeparatorControlDrawParams; const ARect: TRect); begin DrawStaticGlyphAndCaption(ADrawParams, ARect); end; procedure TdxBarPainter.DrawSeparatorControl(const ADrawParams: TdxBarSeparatorControlDrawParams; const ARect: TRect); begin with ADrawParams do if cpText in ADrawParams.ViewStructure then begin DrawSeparatorGlyphAndCaption(ADrawParams, ARect); if not IsTop then SubMenuControlDrawSeparator(Canvas, cxRectSetTop(ARect, ARect.Top, SubMenuGetSeparatorSize)); SubMenuControlDrawSeparator(Canvas, cxRectSetBottom(ARect, ARect.Bottom, SubMenuGetSeparatorSize)); end else if PaintType = ptMenu then SubMenuControlDrawBeginGroup(BarItemControl.SubMenuParent, BarItemControl, Canvas, ARect) else BarDrawBeginGroup(BarItemControl.Parent, Canvas.Handle, ARect, BarItemControl.Parent.ToolbarBrush, False); end; class procedure TdxBarPainter.EditControlUpdateWndText(ABarEditControl: TdxBarEditControl; AHandle: HWND; ANotEqual: Boolean); begin SendMessage(AHandle, EM_SETSEL, 0, -1); end; class function TdxBarPainter.HasEditControlExternalFrame( APaintType: TdxBarPaintType; ASelected: Boolean): Boolean; begin Result := False; end; class function TdxBarPainter.IsCompoundPainting: Boolean; begin Result := False; end; procedure TdxBarPainter.DrawToolbarContentPart( ABarControl: TdxBarControl; ACanvas: TcxCanvas); begin with ABarControl do FillBackground(Canvas.Handle, ClientRect, ToolbarBrush, clNone, True); end; procedure TdxBarPainter.DrawToolbarNonContentPart( ABarControl: TdxBarControl; DC: HDC); begin end; class function TdxBarPainter.GetDefaultArrowSignSize: TSize; begin Result := Size(5, 3); end; function TdxBarPainter.GetToolbarCaptionRect(const ARect: TRect): TRect; begin Result := ARect; InflateRect(Result, -BorderSizeX, -BorderSizeY); Result.Bottom := Result.Top + BarCaptionSize; end; procedure TdxBarPainter.CorrectCaptionParams( const ADrawParams: TdxBarButtonLikeControlDrawParams; var ATextBounds: TRect; const AImageBounds: TRect; out ATextAlignment: DWORD); procedure OffsetTextBounds(var ATextBounds: TRect); begin if not IsMenuItem(ADrawParams.BarItemControl) then OffsetCaptionBounds(ADrawParams.Downed, ADrawParams.IsPressed, ATextBounds); end; begin if ADrawParams.ViewSize = cvsLarge then begin ATextAlignment := DT_CENTER; case ADrawParams.BarItemControl.Item.GlyphLayout of glLeft: begin ATextAlignment := DT_LEFT; if ADrawParams.PaintType = ptHorz then ATextBounds.Left := AImageBounds.Right + 3 else ATextBounds.Top := AImageBounds.Bottom + 3; end; glRight: begin ATextAlignment := DT_RIGHT; if ADrawParams.PaintType = ptHorz then ATextBounds.Right := AImageBounds.Left - 3 else ATextBounds.Bottom := AImageBounds.Top - 3; end; glTop: if ADrawParams.PaintType = ptHorz then ATextBounds.Top := AImageBounds.Bottom else ATextBounds.Right := AImageBounds.Left; glBottom: if ADrawParams.PaintType = ptHorz then ATextBounds.Bottom := AImageBounds.Top else ATextBounds.Left := AImageBounds.Right; end; end else begin ATextAlignment := DT_LEFT; if cpIcon in ADrawParams.ViewStructure then if ADrawParams.PaintType = ptHorz then Inc(ATextBounds.Left, ADrawParams.DefaultButtonSize.cx) else Inc(ATextBounds.Top, ADrawParams.DefaultButtonSize.cy) else if ADrawParams.PaintType = ptHorz then Inc(ATextBounds.Left, ADrawParams.BarItemControl.GetControlCaptionOffset) else Inc(ATextBounds.Top, ADrawParams.BarItemControl.GetControlCaptionOffset); OffsetTextBounds(ATextBounds); end; end; function TdxBarPainter.GetBorderSize: Integer; begin Result := 0; end; function TdxBarPainter.GetIconAreaSize(ABarControl: TCustomdxBarControl): Integer; const AIconAreaOffset = 4; // ! begin case ABarControl.ItemLinks.ItemSize of misNormal: Result := ABarControl.TextSize; else //misLarge Result := Round((DefautGlyphSize * 2 + AIconAreaOffset * 2) * ABarControl.Ratio); end; CorrectButtonControlDefaultHeight(Result); end; class procedure TdxBarPainter.DrawGlyphBorder(ABarItemControl: TdxBarItemControl; DC: HDC; ABrush: HBRUSH; NeedBorder: Boolean; R: TRect; PaintType: TdxBarPaintType; IsGlyphEmpty, Selected, Down, DrawDowned, ADroppedDown, IsSplit: Boolean); begin // Required end; class procedure TdxBarPainter.DrawGlyphCheckMark(ABarItemControl: TdxBarItemControl; DC: HDC; X, Y, DoubleSize: Integer); begin // Required // TODO: make default from Flat? end; class procedure TdxBarPainter.DrawGlyphEmptyImage(ABarItemControl: TdxBarItemControl; DC: HDC; R: TRect; ABrush: HBRUSH; NeedBorder: Boolean; PaintType: TdxBarPaintType; Selected, Down, DrawDowned: Boolean); var DoubleSize: Integer; begin if NeedBorder then InflateRect(R, -1, -1); if not IsNativeBackground then DrawBackground(ABarItemControl, DC, R, ABrush, ({not IgnoreGlyphOpaque and }(Down or DrawDowned or Selected)) or ABarItemControl.FNonRecent); if NeedBorder then InflateRect(R, 1, 1); if (PaintType = ptMenu) and Down then with R do begin DoubleSize := 1 + Byte(ABarItemControl.Parent.Font.Size >= 16); DrawGlyphCheckMark(ABarItemControl, DC, (Left + Right - DoubleSize * 9) div 2, (Top + Bottom - DoubleSize * 7) div 2, DoubleSize); end; end; class procedure TdxBarPainter.DrawGlyphImage(ABarItemControl: TdxBarItemControl; DC: HDC; ABrush: HBRUSH; NeedBorder: Boolean; R: TRect; const GlyphRect: TRect; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; Selected, Down, DrawDowned, ForceUseBkBrush, GrayScale, BarControlOwner: Boolean; PaintType: TdxBarPaintType); var ATransparent: Boolean; begin if NeedBorder then InflateRect(R, -1, -1); ATransparent := not ABarItemControl.FNonRecent and ABarItemControl.Parent.IsTransparent; if ATransparent then begin DrawBackground(ABarItemControl, DC, R, ABrush, (not IgnoreGlyphOpaque and (Down or DrawDowned or Selected)) or ABarItemControl.FNonRecent or ABarItemControl.IsBkColorAssigned); ABrush := 0; end; TransparentDraw(ABarItemControl, DC, ABrush, R, GlyphRect, AGlyph, AImages, AImageIndex, ABarItemControl.BarManager.ImageListBkColor, ABarItemControl.GetImageEnabled(PaintType), GrayScale, False{Flat}, Selected, Down, DrawDowned, False{Shadow}, GetFaded(ABarItemControl.Parent){Faded}, ABarItemControl.BarManager.ImageOptions.SmoothGlyphs, ABarItemControl.BarManager.ImageOptions.UseLeftBottomPixelAsTransparent); if NeedBorder then InflateRect(R, 1, 1); end; class procedure TdxBarPainter.DrawItemArrow(DC: HDC; R: TRect; ArrowType: TcxArrowDirection; Enabled, Selected, Flat: Boolean); begin dxBar.DrawItemArrow(DC, R, ArrowType, Enabled, Selected, Flat); end; procedure TdxBarPainter.DrawLargeItemArrow(DC: HDC; R: TRect; ArrowType: TcxArrowDirection; Size: Integer; Selected, Enabled, Flat: Boolean); begin dxBar.DrawLargeItemArrow(DC, R, ArrowType, Size, Selected, Enabled, Flat); end; class procedure TdxBarPainter.FrameFlatSelRect(DC: HDC; const R: TRect); begin // do nothing end; procedure TdxBarPainter.GetImageParams(AItemControl: TdxBarItemControl; const ADrawRect: TRect; APaintType: TdxBarPaintType; AViewStructure: TdxBarItemControlViewStructure; AViewSize: TdxBarItemControlViewSize; ACenter, ASelected, ADowned, ADrawDowned: Boolean; var AGlyphEmpty: Boolean; out ACurrentGlyph: TBitmap; out ACurrentImages: TCustomImageList; out ACurrentImageIndex: Integer; out AImageBounds: TRect); var AImageSize: TSize; begin AImageSize := AItemControl.GetGlyphSize(AViewSize, ASelected); AGlyphEmpty := not AItemControl.GetCurrentImage(AViewSize, ASelected, ACurrentGlyph, ACurrentImages, ACurrentImageIndex) or AGlyphEmpty; if (AViewSize = cvsLarge) and (APaintType <> ptMenu) then AImageBounds := GetLargeImageBounds(AItemControl, AImageSize, ADrawRect, APaintType, AViewStructure, AItemControl.Item.GlyphLayout) else AImageBounds := GetSmallImageBounds(AItemControl, AImageSize, ADrawRect, APaintType, AViewStructure, ACenter, AGlyphEmpty, AItemControl.BarManager.StretchGlyphs, ADowned, ADrawDowned); end; function TdxBarPainter.GetLargeImageBounds(AItemControl: TdxBarItemControl; const AImageSize: TSize; const ADrawRect: TRect; APaintType: TdxBarPaintType; AViewStructure: TdxBarItemControlViewStructure; AGlyphLayout: TdxBarGlyphLayout): TRect; function GetImageOffset: TSize; begin Result.cx := (ADrawRect.Left + ADrawRect.Right - AImageSize.cx) div 2; Result.cy := (ADrawRect.Top + ADrawRect.Bottom - AImageSize.cy) div 2; if cpText in AViewStructure then begin case APaintType of ptHorz: case AGlyphLayout of glLeft: Result.cx := ADrawRect.Left + 4; glRight: Result.cx := ADrawRect.Right - 4 - AImageSize.cx; glTop: Result.cy := ADrawRect.Top + 2; glBottom: Result.cy := ADrawRect.Bottom - 2 - AImageSize.cy; end; ptVert: case AGlyphLayout of glLeft: Result.cy := ADrawRect.Top + 4; glRight: Result.cy := ADrawRect.Bottom - 4 - AImageSize.cy; glTop: Result.cx := ADrawRect.Right - 2 - AImageSize.cx; glBottom: Result.cx := ADrawRect.Left + 2; end; end; end; end; var AOffset: TSize; begin Result := Rect(0, 0, AImageSize.cx, AImageSize.cy); AOffset := GetImageOffset; OffsetRect(Result, AOffset.cx, AOffset.cy); end; class function TdxBarPainter.GetSmallImageBounds(AItemControl: TdxBarItemControl; const AImageSize: TSize; const ADrawRect: TRect; APaintType: TdxBarPaintType; AViewStructure: TdxBarItemControlViewStructure; ACenter, AGlyphEmpty, AStretchGlyph, ADowned, ADrawDowned: Boolean): TRect; procedure GetDimensions(out AWidth, AHeight: Integer); begin AWidth := cxRectWidth(ADrawRect); AHeight := cxRectHeight(ADrawRect); if not ACenter then case APaintType of ptHorz: AWidth := AItemControl.FDrawParams.DefaultButtonSize.cx; ptVert: AHeight := AItemControl.FDrawParams.DefaultButtonSize.cy; end; end; procedure GetRealImageDimensions(AWidth, AHeight: Integer; out AImageWidth, AImageHeight: Integer); var ARatio: Double; begin AImageWidth := AImageSize.cx; AImageHeight := AImageSize.cy; if APaintType = ptMenu then begin if AStretchGlyph then begin ARatio := AItemControl.Parent.Ratio; AImageWidth := Round(AImageWidth * ARatio); AImageHeight := Round(AImageHeight * ARatio); if Odd(AWidth - AImageWidth) and Odd(AHeight - AImageHeight) then begin Dec(AImageWidth); Dec(AImageHeight); end; end end else begin if AItemControl.BarManager.LargeIcons then begin if AItemControl.BarManager.IsLargeImagesForLargeIcons then begin AImageWidth := AItemControl.BarManager.LargeImages.Width; AImageHeight := AItemControl.BarManager.LargeImages.Height; end else begin AImageWidth := 2 * AImageWidth; AImageHeight := 2 * AImageHeight; end; end; end; end; function GetImageBounds(AWidth, AHeight, AImageWidth, AImageHeight: Integer): TRect; begin Result := Bounds( ADrawRect.Left + (AWidth - AImageWidth) div 2, ADrawRect.Top + (AHeight - AImageHeight) div 2, AImageWidth, AImageHeight); if ADowned then OffsetRect(Result, GlyphDownShift(AItemControl), GlyphDownShift(AItemControl)); if ADrawDowned then OffsetRect(Result, GlyphDrawDownedShift(AItemControl, ADowned), GlyphDrawDownedShift(AItemControl, ADowned)); end; var AWidth, AHeight, AImageWidth, AImageHeight: Integer; begin Result := Rect(0, 0, AImageSize.cx, AImageSize.cy); GetDimensions(AWidth, AHeight); if not AGlyphEmpty or ADowned then begin GetRealImageDimensions(AWidth, AHeight, AImageWidth, AImageHeight); Result := GetImageBounds(AWidth, AHeight, AImageWidth, AImageHeight); end; end; function TdxBarPainter.GetDefaultEnabledTextColor( ABarItemControl: TdxBarItemControl; ASelected, AFlat: Boolean): TColor; begin if ASelected and not AFlat then Result := GetSysColor(COLOR_HIGHLIGHTTEXT) else Result := GetSysColor(COLOR_BTNTEXT); end; procedure TdxBarPainter.GetDisabledTextColors( ABarItemControl: TdxBarItemControl; ASelected, AFlat: Boolean; var AColor1, AColor2: TColor); begin if ASelected or AFlat then begin AColor1 := GetSysColor(COLOR_GRAYTEXT); AColor2 := AColor1; end else begin AColor1 := GetSysColor(COLOR_BTNHIGHLIGHT); AColor2 := GetSysColor(COLOR_BTNSHADOW); end; end; function TdxBarPainter.GetEnabledTextColor( ABarItemControl: TdxBarItemControl; ASelected, AFlat: Boolean): TColor; begin Result := GetDefaultEnabledTextColor(ABarItemControl, ASelected, AFlat); end; procedure TdxBarPainter.GetTextColors(ABarItemControl: TdxBarItemControl; AEnabled, ASelected, AFlat: Boolean; var AColor1, AColor2: TColor); var ATextViewParams: TcxViewParams; begin if AEnabled then begin ABarItemControl.Item.GetTextViewParams(ATextViewParams); if ATextViewParams.TextColor <> clDefault then AColor1 := ATextViewParams.TextColor else AColor1 := GetEnabledTextColor(ABarItemControl, ASelected, AFlat); AColor2 := AColor1; end else GetDisabledTextColors(ABarItemControl, ASelected, AFlat, AColor1, AColor2); end; class function TdxBarPainter.GetFaded(ABarControl: TCustomdxBarControl): Boolean; begin Result := ABarControl.BarManager.MakeDisabledImagesFaded; end; class function TdxBarPainter.IgnoreGlyphOpaque: Boolean; begin Result := False; end; class function TdxBarPainter.IgnoreNonRecentColor: Boolean; begin Result := False; end; class function TdxBarPainter.IsArrowButtonDowned(APaintStyle: TdxBarPaintType; AIsPressed: Boolean): Boolean; begin Result := False; end; class function TdxBarPainter.IsMenuItem(ABarItemControl: TdxBarItemControl): Boolean; begin Result := False; end; class function TdxBarPainter.GetBarItemContolHintPosition( ABarControl: TCustomdxBarControl; const AItemBounds: TRect; const ACursorPos: TPoint; AHeight: Integer): TPoint; begin Result := ACursorPos; Inc(Result.Y, HintOffset); end; function TdxBarPainter.CreateHintViewInfo(ABarManager: TdxBarManager; AHintText: string; const AShortCut: string; AScreenTip: TdxBarScreenTip): TdxBarCustomHintViewInfo; begin Result := TdxBarHintViewInfo.Create(ABarManager, AHintText, AShortCut, GetMouseCursorPos); end; class function TdxBarPainter.BarIsBarSmall(ABarControl: TdxBarControl; const R: TRect): Boolean; begin with R do Result := Bottom - Top <= 1 + 3 + 5 + 3 + 3 + 1; end; class function TdxBarPainter.BarCaptionBkColor(ABarControl: TdxBarControl; AMainFormActive: Boolean): COLORREF; const CaptionBkColors: array[Boolean] of Integer = (COLOR_INACTIVECAPTION, COLOR_ACTIVECAPTION); begin Result := GetSysColor(CaptionBkColors[AMainFormActive]); end; class function TdxBarPainter.BarCaptionColor(ABarControl: TdxBarControl): COLORREF; begin Result := GetSysColor(COLOR_CAPTIONTEXT); end; class function TdxBarPainter.BarMarkArrowColor(ABarControl: TdxBarControl; AState: TdxBarMarkState): COLORREF; begin Result := GetSysColor(COLOR_CAPTIONTEXT); end; class procedure TdxBarPainter.BarDrawGrip(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); begin ABarControl.FillBackground(DC, R, AToolbarBrush, clNone, True); // DrawFrameControl(DC, R, DFC_SCROLL, DFCS_SCROLLSIZEGRIP); BarDrawSizeGrip(DC, R); end; procedure TdxBarPainter.BarDrawMarkArrow(ABarControl: TdxBarControl; DC: HDC; MarkR: TRect); var P: array[1..3] of TPoint; AColor: COLORREF; begin with MarkR, P[1] do begin P[1] := Point((Left + Right - MarkSizeArrowX) div 2, (Top + Bottom - MarkSizeArrowY) div 2 + (Top + Bottom - MarkSizeArrowY) mod 2); P[2] := Point(X + MarkSizeArrowX - 1, Y); P[3] := Point(X + MarkSizeArrowX div 2, Y + MarkSizeArrowY - 1); end; AColor := BarMarkArrowColor(ABarControl, ABarControl.MarkDrawState); PolygonByColor(DC, P, AColor, AColor); end; class procedure TdxBarPainter.BarDrawMarkAtPos(ABarControl: TdxBarControl; DC: HDC; const ItemRect: TRect; Offset: Integer); var APen: HPEN; X, Y: Integer; begin APen := SelectObject(DC, CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNTEXT))); if ABarControl.Horizontal then begin X := Offset; Y := 4 - Byte(BarIsBarSmall(ABarControl, ItemRect)); MoveToEx(DC, X, Y, nil); LineTo(DC, X + 2, Y + 2); LineTo(DC, X - 1, Y + 5); MoveToEx(DC, X + 1, Y, nil); LineTo(DC, X + 3, Y + 2); LineTo(DC, X, Y + 5); end else begin X := ABarControl.ClientWidth - 8; MoveToEx(DC, X, Offset, nil); LineTo(DC, X + 2, Offset + 2); LineTo(DC, X + 5, Offset - 1); MoveToEx(DC, X, Offset + 1, nil); LineTo(DC, X + 2, Offset + 3); LineTo(DC, X + 5, Offset); end; ReverseGDIObject(DC, APen); end; procedure TdxBarPainter.BarDrawMarkBackground(ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect; AToolbarBrush: HBRUSH); begin // Required end; procedure TdxBarPainter.BarDrawMarkElements(ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect); procedure DrawArrow(X, Y: Integer; Vertical: Boolean); var P: array[1..3] of TPoint; AColor: COLORREF; begin if Vertical then begin P[1] := Point(X, Y); P[2] := Point(X, Y + 4); P[3] := Point(X - 2, Y + 2); end else begin P[1] := Point(X, Y); P[2] := Point(X + 4, Y); P[3] := Point(X + 2, Y + 2); end; AColor := GetSysColor(GetDrawMarkElementColor(ABarControl)); PolygonByColor(DC, P, AColor, AColor); end; begin with ItemRect do begin if BarAllowQuickCustomizing then if ABarControl.Horizontal then DrawArrow(Left + 3, Bottom - 7 + Byte(BarIsBarSmall(ABarControl, ItemRect)), False) else DrawArrow(Left + 5, Top + 3, True); if ABarControl.FTruncated then if ABarControl.Horizontal then begin BarDrawMarkAtPos(ABarControl, DC, ItemRect, Left + 2); BarDrawMarkAtPos(ABarControl, DC, ItemRect, Left + 6); end else begin BarDrawMarkAtPos(ABarControl, DC, ItemRect, Bottom - MarkSizeY); BarDrawMarkAtPos(ABarControl, DC, ItemRect, Bottom - MarkSizeY + 4); end; end; end; class procedure TdxBarPainter.BarOffsetFloatingBarCaption(ABarControl: TdxBarControl; var X: Integer; var R: TRect); begin X := ABarControl.MarkNCRect.Right + 3 * FloatToolbarMarkIndent; end; class function TdxBarPainter.GetDrawMarkElementColor(ABarControl: TdxBarControl): Integer; begin Result := COLOR_BTNTEXT; end; procedure TdxBarPainter.ButtonLikeControlDoDrawCaption( const ADrawParams: TdxBarButtonLikeControlDrawParams; const ATextBounds: TRect; ATextAlignment: DWORD); begin with ADrawParams do DrawItemText(BarItemControl, Canvas.Handle, Caption, ATextBounds, ATextAlignment, Enabled, IsTextSelected, PaintType = ptVert, False, IsFlatText); end; class function TdxBarPainter.GetControlTextIndents: TRect; begin Result := Rect(4, 0, 0, 0); end; class function TdxBarPainter.GetControlCaptionRect(const ADrawParams: TdxBarItemControlDrawParams): TRect; begin Result := cxGetTextRect(ADrawParams.Canvas.Handle, ADrawParams.Caption, 1); end; procedure TdxBarPainter.InflateSizeForArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; var ASize: Integer); begin if ADrawParams.SplitDropDown then begin if (ADrawParams.PaintType <> ptMenu) and ADrawParams.IsDropDown then Inc(ASize, GetControlTextIndents.Right + ADrawParams.ArrowWidth); end else if not ADrawParams.IsMenuItem then Inc(ASize, ADrawParams.BarItemControl.Parent.TextSize div 2); end; procedure TdxBarPainter.DrawDot(const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); begin if ADrawParams.Enabled then if IsHighContrastWhite and ADrawParams.DrawSelected then FillRect(ADrawParams.Canvas.Handle, ARect, COLOR_BTNFACE + 1) else FillRect(ADrawParams.Canvas.Handle, ARect, COLOR_BTNTEXT + 1) else DrawDisabledShadowRect(ADrawParams.BarItemControl, ADrawParams.Canvas.Handle, ARect); end; procedure TdxBarPainter.DrawDots(const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); procedure CalculateFirstDotBounds(ADotWidth: Integer; var ARect: TRect); var ALeftIndent, ASpaceAfter: Integer; begin ALeftIndent := (cxRectWidth(ARect) - ADotWidth * 5) div 2; ARect.Right := ARect.Left + ADotWidth; ARect.Top := ARect.Bottom - ADotWidth; ASpaceAfter := GetDotSpaceAfter(ADotWidth); OffsetRect(ARect, ALeftIndent, - ASpaceAfter); end; const DotsCount = 3; var ADotWidth, I: Integer; begin with ADrawParams do begin ADotWidth := (ARect.Right - ARect.Left) div 7; CalculateFirstDotBounds(ADotWidth, ARect); OffsetEllipsisBounds(IsPressed, ARect); for I := 0 to DotsCount - 1 do begin DrawDot(ADrawParams, ARect); OffsetRect(ARect, ADotWidth * 2, 0); end; end; end; function TdxBarPainter.GetDotSpaceAfter(ADotWidth: Integer): Integer; begin Result := ADotWidth; end; function TdxBarPainter.GetCustomColorButtonBounds(const ADrawParams: TdxBarColorComboControlDrawParams; ARect: TRect): TRect; function IsCustomButtonTooLarge(AButtonWidth: Integer): Boolean; begin Result := AButtonWidth >= (cxRectWidth(ARect) div 2); end; begin Result := ARect; Result.Left := Result.Right - ((ARect.Bottom - ARect.Top - 2 - 2) div 7 * 7 + 2 + 2); if IsCustomButtonTooLarge(cxRectWidth(Result)) or not ADrawParams.IsShowCustomColorButton then Result.Left := Result.Right else Result := cxRectContent(Result, GetCustomColorButtonIndents(ADrawParams)); end; class procedure TdxBarPainter.ComboControlDrawArrow(ABarComboControl: TdxBarItemControl; DC: HDC; X, Y, Size: Integer; Color: COLORREF); begin ComboControlDrawOneArrow(ABarComboControl, DC, X, Y, Size, Color); end; class procedure TdxBarPainter.ComboControlDrawOneArrow(ABarItemControl: TdxBarItemControl; DC: HDC; X, Y, Size: Integer; Color: COLORREF); var P: array[1..3] of TPoint; begin P[1] := Point(X, Y); P[2] := Point(X + Size - 1, Y); P[3] := Point(X + Size div 2, Y + Size div 2); PolygonByColor(DC, P, Color, Color); end; procedure TdxBarPainter.SubMenuControlFillScrollArrow(ACanvas: TcxCanvas; ARect: TRect; AColor: TColor); begin FillRectByColor(ACanvas.Handle, ARect, AColor); end; procedure TdxBarPainter.SubMenuControlDrawScrollArrow(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; const AArrowRect: TRect; AColor: COLORREF; AArrowDirection: TcxArrowDirection); var P: TcxArrowPoints; begin CalculateArrowPoints(AArrowRect, SubMenuControlGetScrollArrowSize(ABarSubMenuControl.TextSize), AArrowDirection, P); ACanvas.SaveClipRegion; try SetArrowRegion(ACanvas, AArrowDirection, P, roSet); SubMenuControlFillScrollArrow(ACanvas, GetArrowRectByPoints(P, AArrowDirection), AColor); finally ACanvas.RestoreClipRegion; end; SetArrowRegion(ACanvas, AArrowDirection, P, roSubtract); end; procedure TdxBarPainter.SubMenuControlDrawScrollBand(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; AArrowDirection: TcxArrowDirection); begin SubMenuControlDrawScrollArrow(ABarSubMenuControl, ACanvas, SubMenuControlGetScrollBandBounds(ABarSubMenuControl, AArrowDirection), GetSysColor(COLOR_BTNTEXT), AArrowDirection); SubMenuControlDrawScrollButton(ABarSubMenuControl, ACanvas, AArrowDirection); SubMenuControlDrawNonRecentGroupSeparator(ABarSubMenuControl, ACanvas, AArrowDirection); SubMenuControlDrawScrollBandBackground(ABarSubMenuControl, ACanvas, AArrowDirection); end; procedure TdxBarPainter.SubMenuControlDrawScrollBandBackground(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; AArrowDirection: TcxArrowDirection); var AControl: TdxBarItemControl; begin case AArrowDirection of adUp: AControl := ABarSubMenuControl.TopItemControl; else {adDown} AControl := ABarSubMenuControl.BottomItemControl; end; DrawBackground(AControl, ACanvas.Handle, ABarSubMenuControl.GetItemRectEx(AControl, True), ABarSubMenuControl.ToolbarItemsBrush, False); end; procedure TdxBarPainter.SubMenuControlDrawNonRecentGroupSeparator(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; AArrowDirection: TcxArrowDirection); const BrushColors: array[Boolean] of COLORREF = (COLOR_BTNHIGHLIGHT, COLOR_BTNSHADOW); var R: TRect; begin with ABarSubMenuControl do if (AArrowDirection = adDown) and BottomItemControl.FChangeRecentGroup then begin R := GetItemRectEx(BottomItemControl, True); R := Rect(R.Left - 1, R.Top, R.Right + 1, R.Top + 1); DrawBackground(BottomItemControl, ACanvas.Handle, R, BrushColors[BottomItemControl.FNonRecent] + 1, False); ACanvas.SetClipRegion(TcxRegion.Create(R), roSubtract); end end; function TdxBarPainter.SubMenuControlGetScrollBandBounds(ABarSubMenuControl: TdxBarSubMenuControl; AArrowDirection: TcxArrowDirection): TRect; var AScrollAreaSize: Integer; begin AScrollAreaSize := SubMenuControlGetScrollBandSize(ABarSubMenuControl); Result := ABarSubMenuControl.FItemsRect; if AArrowDirection = adUp then Result.Bottom := Result.Top + AScrollAreaSize else Result.Top := Result.Bottom - AScrollAreaSize; end; function TdxBarPainter.SubMenuControlGetScrollBandSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; begin Result := ABarSubMenuControl.TextSize; end; class function TdxBarPainter.SubMenuControlGetScrollArrowSize(ATextSize: Integer): Integer; begin Result := ATextSize div 3 - 1 end; procedure TdxBarPainter.SubMenuControlDrawMark(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect; ASelected: Boolean); var APen: HPEN; Size, X, Y, I: Integer; procedure DrawOneMark(const Y: Integer); begin MoveToEx(DC, X, Y, nil); LineTo(DC, X + Size div 2, Y + Size div 2); LineTo(DC, X + Size + 1, Y - 1); end; var AColor: COLORREF; begin Size := ABarSubMenuControl.MarkArrowSize; if IsHighContrastWhite and IsFlatItemText and ASelected then AColor := GetSysColor(COLOR_BTNFACE) else AColor := GetSysColor(COLOR_BTNTEXT); APen := SelectObject(DC, CreatePen(PS_SOLID, 1, AColor)); with R do begin X := (Left + Right - (Size + 1)) div 2; Y := Top + (ABarSubMenuControl.MarkSize - 2 * Size) div 2; for I := Y to Y + Size - 1 do DrawOneMark(I + Byte(I >= Y + Size div 2) * Size div 2); end; ReverseGDIObject(DC, APen); end; procedure TdxBarPainter.SubMenuControlDrawMarkBand( ABarSubMenuControl: TdxBarSubMenuControl; const AMarkRect: TRect; ASelected: Boolean); procedure DrawMarkBackground(ABarSubMenuControl: TdxBarSubMenuControl; ADC: HDC; const AMarkRect: TRect); begin DrawBackground(ABarSubMenuControl.BottomItemControl, ADC, AMarkRect, ABarSubMenuControl.ToolbarItemsBrush, False); if ASelected then SubMenuControlDrawMarkSelection(ABarSubMenuControl, ADC, AMarkRect); end; var ABitmap: TBitmap; begin ABitmap := cxCreateBitmap(AMarkRect); try BarCanvas.BeginPaint(ABitmap.Canvas.Handle); try BarCanvas.WindowOrg := AMarkRect.TopLeft; DrawMarkBackground(ABarSubMenuControl, BarCanvas.Handle, AMarkRect); SubMenuControlDrawMark(ABarSubMenuControl, BarCanvas.Handle, AMarkRect, ASelected); ABarSubMenuControl.Canvas.CopyRect(AMarkRect, BarCanvas.Canvas, AMarkRect); finally BarCanvas.EndPaint; end; finally FreeAndNil(ABitmap); end; ABarSubMenuControl.Canvas.SetClipRegion(TcxRegion.Create(AMarkRect), roSubtract); end; procedure TdxBarPainter.SubMenuControlDrawMarkSelection( ABarSubMenuControl: TdxBarSubMenuControl; ADC: HDC; const AMarkRect: TRect); var R: TRect; begin R := AMarkRect; DrawEdge(ADC, R, BDR_RAISEDINNER, BF_RECT); ABarSubMenuControl.PreparePalette(ADC); DrawBackground(ABarSubMenuControl.BottomItemControl, ADC, cxRectInflate(R, -1, -1), ABarSubMenuControl.FLightBrush, False); ABarSubMenuControl.UnpreparePalette(ADC); end; class function TdxBarPainter.SubMenuControlUseScrollButtons: Boolean; begin Result := False; end; class procedure TdxBarPainter.EditOffsetInteriorRect(var R: TRect); begin end; procedure TdxBarPainter.DrawSpinEditArrow(const ADrawParams: TdxBarSpinEditDrawParams; AArrowPos: TPoint; AButtonIndex: Integer); begin with ADrawParams do begin if Enabled then SpinEditControlDrawArrowByPoints(ADrawParams, AArrowPos, COLOR_BTNTEXT, AButtonIndex) else begin SpinEditControlDrawArrowByPoints(ADrawParams, Point(AArrowPos.X + 1, AArrowPos.Y + 1), COLOR_BTNHIGHLIGHT, AButtonIndex); SpinEditControlDrawArrowByPoints(ADrawParams, AArrowPos, COLOR_BTNSHADOW, AButtonIndex); end; end; end; class procedure TdxBarPainter.SpinEditControlDrawArrowByPoints(const ADrawParams: TdxBarSpinEditDrawParams; AStartPoint: TPoint; AColorIndex: Integer; AButtonIndex: Integer); var P: array[1..3] of TPoint; AColor: COLORREF; begin P[1] := Point(AStartPoint.X, AStartPoint.Y); P[2] := Point(AStartPoint.X + ADrawParams.ArrowSize.cx - 1, AStartPoint.Y); if AButtonIndex = secButtonUp then P[3] := Point(AStartPoint.X + ADrawParams.ArrowSize.cx div 2, AStartPoint.Y - ADrawParams.ArrowSize.cx div 2) else P[3] := Point(AStartPoint.X + ADrawParams.ArrowSize.cx div 2, AStartPoint.Y + ADrawParams.ArrowSize.cx div 2); AColor := GetSysColor(AColorIndex); PolygonByColor(ADrawParams.Canvas.Handle, P, AColor, AColor); end; class procedure TdxBarPainter.DateNavigatorDrawButtonCaption(DC: HDC; R: TRect; Offset: Integer; const ACaption: string; AOpaque: Boolean); var Flags: Integer; Size: TSize; APrevBkMode: Integer; begin with R do begin GetTextExtentPoint32(DC, PChar(ACaption), Length(ACaption), Size); SetTextColor(DC, GetSysColor(COLOR_BTNTEXT)); SetBkColor(DC, GetSysColor(COLOR_BTNFACE)); Flags := ETO_CLIPPED; APrevBkMode := GetBkMode(DC); if AOpaque then Flags := Flags or ETO_OPAQUE else SetBkMode(DC, TRANSPARENT); ExtTextOut(DC, (Left + Right - Size.cX) div 2 + Offset, (Top + Bottom - Size.cY) div 2 + Offset, Flags, @R, PChar(ACaption), Length(ACaption), nil); SetBkMode(DC, APrevBkMode); end; end; procedure TdxBarPainter.InternalCalculateComboParts( const ADrawParams: TdxBarEditLikeControlDrawParams; var AParts: array of TRect); begin AParts[ccpDropButton].Left := AParts[ccpDropButton].Right - ADrawParams.BarItemControl.Parent.ComboBoxArrowWidth; AParts[ecpEdit].Right := AParts[ccpDropButton].Left - ComboControlArrowOffset; end; { TdxBarStandardPainter } class procedure TdxBarStandardPainter.DrawDisabledShadowRect(ABarItemControl: TdxBarItemControl; DC: HDC; R: TRect); begin OffsetRect(R, 1, 1); FillRect(DC, R, COLOR_BTNHIGHLIGHT + 1); OffsetRect(R, -1, -1); inherited DrawDisabledShadowRect(ABarItemControl, DC, R); end; procedure TdxBarStandardPainter.DrawGlyphAndTextInSubMenu( const ADrawParams: TdxBarButtonLikeControlDrawParams; var R: TRect); var AIconRect: TRect; IsGlyphEmpty, AOpaque: Boolean; Brush: HBRUSH; ADC: HDC; begin with ADrawParams do begin ADC := Canvas.Handle; AIconRect := GetSubMenuItemIconRect(R, BarItemControl.Parent.IconAreaSize); IsGlyphEmpty := not BarItemControl.HasIcon(ViewSize, ViewStructure); DrawGlyph(BarItemControl, ADC, AIconRect, cxEmptyRect, ptMenu, IsGlyphEmpty, DrawSelected, Downed, False, False, False, False, False); if DrawSelected and IsGlyphEmpty and not Downed then Brush := BarItemControl.Parent.ToolbarSelBrush else Brush := BarItemControl.BkBrush; R.Left := AIconRect.Right + 1; AOpaque := DrawSelected or BarItemControl.FNonRecent; DrawBackground(BarItemControl, ADC, Rect(AIconRect.Right, AIconRect.Top, R.Left, AIconRect.Bottom), Brush, AOpaque); if AIconRect.Top > R.Top then DrawBackground(BarItemControl, ADC, Rect(AIconRect.Left, R.Top, R.Left, AIconRect.Top), Brush, AOpaque); if AIconRect.Bottom < R.Bottom then DrawBackground(BarItemControl, ADC, Rect(AIconRect.Left, AIconRect.Bottom, R.Left, R.Bottom), Brush, AOpaque); if DrawSelected then Brush := BarItemControl.Parent.ToolbarSelBrush else Brush := BarItemControl.BkBrush; DrawBackground(BarItemControl, ADC, R, Brush, AOpaque); Inc(R.Left, 2); DrawItemTextInSubMenu(ADrawParams, R); end; end; class procedure TdxBarStandardPainter.DrawLowered(DC: HDC; var R: TRect); begin DrawEdge(DC, R, BDR_SUNKENOUTER, BF_RECT); InflateRect(R, -1, -1); // LoweredBorderSize(ABarItemControl) = 1 end; class procedure TdxBarStandardPainter.FrameAndFillRect(ABarItemControl: TdxBarItemControl; DC: HDC; var R: TRect; Enabled, Selected, Pressed: Boolean); const Borders: array[Boolean] of Integer = (BDR_RAISEDINNER, BDR_SUNKENOUTER); var Brush: HBRUSH; begin Brush := ABarItemControl.Parent.BkBrush; if Selected then DrawEdge(DC, R, Borders[Pressed], BF_RECT) else FrameRect(DC, R, ABarItemControl.Parent.BkBrush); InflateRect(R, -1, -1); FillRect(DC, R, Brush); end; class function TdxBarStandardPainter.GlyphBkgndBrush(ABarItemControl: TdxBarItemControl; APaintType: TdxBarPaintType; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AForceUseBkBrush, AGrayScale: Boolean): HBRUSH; begin if ADowned and ABarItemControl.Enabled then if ASelected then Result := ABarItemControl.Parent.ToolbarDownedSelBrush else Result := ABarItemControl.Parent.ToolbarDownedBrush else if ASelected and (APaintType = ptMenu) and AGlyphEmpty and not ADowned then Result := ABarItemControl.Parent.ToolbarSelBrush else Result := ABarItemControl.BkBrush; end; class function TdxBarStandardPainter.GlyphDownShift(ABarItemControl: TdxBarItemControl): Integer; begin Result := 1; end; class function TdxBarStandardPainter.GlyphDrawDownedShift(ABarItemControl: TdxBarItemControl; ADown: Boolean): Integer; begin Result := 1; end; class function TdxBarStandardPainter.LoweredBorderSize(ABarItemControl: TdxBarItemControl): Integer; begin Result := 1; end; class function TdxBarStandardPainter.BeforeFingersSize: Integer; begin Result := 2; end; class function TdxBarStandardPainter.FingersSize: Integer; begin Result := BeforeFingersSize + 2 * GripperSize + 1; end; class procedure TdxBarStandardPainter.BarDrawCloseButton(ABarControl: TdxBarControl; DC: HDC; R: TRect); const Pushes: array[Boolean] of Integer = (0, DFCS_PUSHED); var ABrush: HBRUSH; begin ABrush := CreateSolidBrush(ABarControl.CaptionBkColor); FrameRect(DC, R, ABrush); DeleteObject(ABrush); InflateRect(R, -1, -1); DrawFrameControl(DC, R, DFC_CAPTION, DFCS_CAPTIONCLOSE or Pushes[ABarControl.CloseButtonState = msPressed]); end; procedure TdxBarStandardPainter.BarDrawDockedBarBorder(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); procedure DrawFinger; begin with R do begin DrawEdge(DC, R, BDR_RAISEDINNER, BF_RECT); if ABarControl.Horizontal then SetPixel(DC, Left, Bottom - 1, GetSysColor(COLOR_BTNHIGHLIGHT)) else SetPixel(DC, Right - 1, Top, GetSysColor(COLOR_BTNHIGHLIGHT)); InflateRect(R, -1, -1); FillRect(DC, R, GetSysColorBrush(COLOR_BTNFACE)); InflateRect(R, 1, 1); ExcludeClipRect(DC, Left, Top, Right, Bottom); end; end; begin with R do begin DrawEdge(DC, R, BDR_RAISEDINNER, BF_RECT); InflateRect(R, -2, -2); if ABarControl.CanMoving then begin if ABarControl.Horizontal then begin Inc(Left, BeforeFingersSize); Right := Left + GripperSize; end else begin Inc(Top, BeforeFingersSize); Bottom := Top + GripperSize; end; DrawFinger; if ABarControl.Horizontal then OffsetRect(R, GripperSize, 0) else OffsetRect(R, 0, GripperSize); DrawFinger; end; end; end; class procedure TdxBarStandardPainter.BarDrawFloatingBarBorder(ABarControl: TdxBarControl; DC: HDC; var R, CR: TRect; AToolbarBrush: HBRUSH); begin DrawEdge(DC, R, EDGE_RAISED, BF_RECT); InflateRect(R, -2, -2); FrameRect(DC, R, GetSysColorBrush(COLOR_BTNFACE)); InflateRect(R, -1, -1); FrameRect(DC, R, GetSysColorBrush(COLOR_BTNFACE)); end; class procedure TdxBarStandardPainter.BarDrawMDIButton(ABarControl: TdxBarControl; AButton: TdxBarMDIButton; ASelected, APressed: Boolean; DC: HDC; R: TRect); const Borders: array[Boolean] of Integer = (BDR_RAISEDINNER, BDR_SUNKENOUTER); var AFlat, ClipRgnExists: Boolean; Rgn1, Rgn2: HRGN; AFlags: Integer; begin AFlat := (AButton = mdibClose) and ABarControl.BarManager.FlatCloseButton and ABarControl.MDIButtonsOnBar and not ABarControl.RealMDIButtonsOnBar; Rgn1 := 0; ClipRgnExists := False; if AFlat then begin Rgn1 := CreateRectRgn(0, 0, 0, 0); ClipRgnExists := GetClipRgn(DC, Rgn1) = 1; InflateRect(R, -1, -1); Rgn2 := CreateRectRgnIndirect(R); SelectClipRgn(DC, Rgn2); DeleteObject(Rgn2); InflateRect(R, 1, 1); end; AFlags := 0; if not ABarControl.MDIButtonEnabled(AButton, MF_GRAYED) then AFlags := AFlags or DFCS_INACTIVE else if ASelected and APressed then AFlags := AFlags or DFCS_PUSHED; DrawFrameControl(DC, R, DFC_CAPTION, MDIButtonStyles[AButton] or AFlags or Byte(AFlat) * DFCS_FLAT); if AFlat then begin if ClipRgnExists then SelectClipRgn(DC, Rgn1) else SelectClipRgn(DC, 0); DeleteObject(Rgn1); DrawEdge(DC, R, Borders[ASelected and APressed], BF_RECT); end; end; class function TdxBarStandardPainter.BarHorSize: Integer; begin Result := dxBarHorSize; end; function TdxBarStandardPainter.BarMarkItemRect(ABarControl: TdxBarControl): TRect; begin case ABarControl.DockingStyle of dsTop, dsBottom: with Result do begin Left := ABarControl.ClientWidth - MarkSizeX; Top := 0; Right := Left + MarkSizeX; Bottom := MarkSizeY; end; dsLeft, dsRight: with Result do begin Left := ABarControl.ClientWidth - MarkSizeY; Top := ABarControl.ClientHeight - MarkSizeX; Right := ABarControl.ClientWidth; Bottom := Top + MarkSizeX; end; else Result := ABarControl.GetCaptionRect; with Result do Right := Left + 3 + 7 + 3; end; end; class function TdxBarStandardPainter.BarTopSize: Integer; begin Result := dxBarTopSize; end; class function TdxBarStandardPainter.BarBottomSize: Integer; begin Result := dxBarBottomSize; end; class function TdxBarStandardPainter.BarUseSystemClose: Boolean; begin Result := True; end; class function TdxBarStandardPainter.BarUseSystemNCBorder: Boolean; begin Result := True; end; class function TdxBarStandardPainter.SubMenuBeginGroupIndent: Integer; begin Result := 2; end; procedure TdxBarStandardPainter.DrawButtonControlArrow( const ADrawParams: TdxBarButtonLikeControlDrawParams; R1: TRect; ABrush: HBRUSH); const Borders: array[Boolean] of Integer = (BDR_RAISEDINNER, BDR_SUNKENOUTER); Enables: array[Boolean] of Integer = (DFCS_INACTIVE, 0); var R: TRect; ADC: HDC; begin with ADrawParams do begin ADC := Canvas.Handle; DrawBackground(BarItemControl, ADC, R1, ABrush, (not IgnoreGlyphOpaque and (DroppedDown or DrawSelected)) or BarItemControl.FNonRecent); if DrawSelected then DrawEdge(ADC, R1, Borders[DroppedDown], BF_RECT) else if PaintType = ptMenu then begin R := R1; Dec(R.Left); R.Right := R.Left + 2; DrawEdge(ADC, R, EDGE_ETCHED, BF_LEFT or BF_RIGHT); end; if PaintType = ptMenu then begin if DroppedDown then OffsetRect(R1, 1, 1); DrawLargeItemArrow(ADC, R1, adRight, BarItemControl.Parent.MenuArrowHeight, False, Enabled and DropDownEnabled, False{Flat}); end else begin if DroppedDown and (R1.Right - R1.Left > 9) then OffsetRect(R1, 1, 1); DrawItemArrow(ADC, R1, adDown, Enabled and DropDownEnabled, False, False{Flat}); end; end; end; class procedure TdxBarStandardPainter.OffsetCaptionBounds(ADown, APressed: Boolean; var R: TRect); begin if ADown then OffsetRect(R, 1, 1); if APressed then OffsetRect(R, 1, 1); end; class procedure TdxBarStandardPainter.OffsetEllipsisBounds(APressed: Boolean; var R: TRect); begin if APressed then OffsetRect(R, 1, 1); end; class procedure TdxBarStandardPainter.ComboControlDrawArrow(ABarComboControl: TdxBarItemControl; DC: HDC; X, Y, Size: Integer; Color: COLORREF); begin if ABarComboControl.Enabled then ComboControlDrawOneArrow(ABarComboControl, DC, X, Y, Size, Color) else begin ComboControlDrawOneArrow(ABarComboControl, DC, X + 1, Y + 1, Size, GetSysColor(COLOR_BTNHIGHLIGHT)); ComboControlDrawOneArrow(ABarComboControl, DC, X, Y, Size, GetSysColor(COLOR_BTNSHADOW)); end; end; class procedure TdxBarStandardPainter.ComboControlDrawSimpleButton( ABarComboControl: TdxBarItemControl; ADC: HDC; var ARect: TRect; ADroppedDown, ASelected: Boolean; ABrush: HBRUSH; APaintType: TdxBarPaintType); const Borders: array[Boolean] of Integer = (BDR_RAISEDINNER, BDR_SUNKENOUTER); var ASpaceBrush: HBRUSH; begin if ASelected and ABarComboControl.Enabled then begin DrawEdge(ADC, ARect, Borders[ADroppedDown], BF_RECT); ASpaceBrush := ABarComboControl.Parent.BkBrush; end else begin if ABarComboControl.Enabled then ASpaceBrush := TCustomdxBarComboControl(ABarComboControl).EditBkBrush else ASpaceBrush := ABarComboControl.Parent.BkBrush; FrameRect(ADC, ARect, ASpaceBrush); end; FillRect(ADC, Rect(ARect.Left - 1, ARect.Top, ARect.Left, ARect.Bottom), ASpaceBrush); InflateRect(ARect, -1, -1); FillRect(ADC, ARect, ABrush); if ADroppedDown then OffsetRect(ARect, 1, 1); end; class function TdxBarStandardPainter.DropDownListBoxBorderSize: Integer; begin Result := 2; end; procedure TdxBarStandardPainter.DropDownListBoxDrawBorder(DC: HDC; AColor: TColor; ARect: TRect); begin DrawEdge(DC, ARect, EDGE_RAISED, BF_RECT); end; class procedure TdxBarStandardPainter.SubMenuControlDrawItemFrame(ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; DC: HDC; AItemRect: TRect; AIndex: Integer); procedure DrawChangeRecentGroupLine(ALeftDelta: Integer); const ABrushColors: array[Boolean] of COLORREF = (COLOR_BTNHIGHLIGHT, COLOR_BTNSHADOW); var R: TRect; ASeparatorIndex: Integer; begin R := AItemRect; if not AControl.FNonRecent and ABarSubMenuControl.ViewInfo.IsAssociatedWithSeparator(AControl, ASeparatorIndex) then R.Top := ABarSubMenuControl.ViewInfo.SeparatorInfos[ASeparatorIndex].Bounds.Top; with R do begin Bottom := Top; Dec(Top); Dec(Left, ALeftDelta); Inc(Right); end; FillRect(DC, R, GetSysColor(ABrushColors[AControl.FNonRecent])); end; var ALeftDelta: Integer; begin ALeftDelta := Ord(ABarSubMenuControl.BarSize = 0); if AControl.FChangeRecentGroup then DrawChangeRecentGroupLine(ALeftDelta); if AControl.FNonRecent then with AItemRect do begin if (AIndex = 0) and not ABarSubMenuControl.Detachable then begin FillRect(DC, Rect(Left - ALeftDelta, Top - 1, Right + 2, Top), ABarSubMenuControl.BkBrush); SetPixel(DC, Right + 1, Top - 2, GetSysColor(COLOR_BTNHIGHLIGHT)); end; FillRect(DC, Rect(Left - ALeftDelta, Top, Left, Bottom), ABarSubMenuControl.BkBrush); FillRect(DC, Rect(Right, Top, Right + 2, Bottom), ABarSubMenuControl.BkBrush); if AIndex = AControl.ItemLink.Owner.VisibleItemCount - 1 then begin FillRect(DC, Rect(Left - ALeftDelta, Bottom, Right + 2, ABarSubMenuControl.ClientHeight), ABarSubMenuControl.BkBrush); if ALeftDelta <> 0 then SetPixel(DC, Left - 2, ABarSubMenuControl.ClientHeight - 1, GetSysColor(COLOR_BTNHIGHLIGHT)); end; end; end; class function TdxBarStandardPainter.SubMenuControlIsOffsetRecentGroupNeeded: Boolean; begin Result := True; end; class function TdxBarStandardPainter.SubMenuControlContentRectOffset(ABarSubMenuControl: TdxBarSubMenuControl): TRect; begin Result := inherited SubMenuControlContentRectOffset(ABarSubMenuControl); if ABarSubMenuControl.Detachable then Result.Top := 0; end; class function TdxBarStandardPainter.SubMenuControlMarkRectOffset(ABarSubMenuControl: TdxBarSubMenuControl): Integer; begin Result := inherited SubMenuControlMarkRectOffset(ABarSubMenuControl) + 1; end; class procedure TdxBarStandardPainter.EditControlPrepareEditWnd(ABarEditControl: TdxBarEditControl; AHandle: HWND); begin SendMessage(AHandle, EM_SETMARGINS, EC_LEFTMARGIN or EC_RIGHTMARGIN, MakeLParam(2, 2)); end; function TdxBarStandardPainter.GetBorderSize: Integer; begin Result := 2; end; class procedure TdxBarStandardPainter.DrawGlyphBorder(ABarItemControl: TdxBarItemControl; DC: HDC; ABrush: HBRUSH; NeedBorder: Boolean; R: TRect; PaintType: TdxBarPaintType; IsGlyphEmpty, Selected, Down, DrawDowned, ADroppedDown, IsSplit: Boolean); const Borders: array[Boolean] of Integer = (BDR_RAISEDINNER, BDR_SUNKENOUTER); begin if Down or (Selected and ((PaintType <> ptMenu) or not IsGlyphEmpty)) then DrawEdge(DC, R, Borders[Down or DrawDowned or ADroppedDown and not IsSplit], BF_RECT) else if NeedBorder then DrawBackgroundFrameRect(ABarItemControl, DC, R, ABrush, Selected or Down or DrawDowned or ABarItemControl.FNonRecent or ABarItemControl.IsBkColorAssigned); end; class procedure TdxBarStandardPainter.DrawGlyphCheckMark(ABarItemControl: TdxBarItemControl; DC: HDC; X, Y, DoubleSize: Integer); const Colors: array[Boolean] of TColor = (clBlack, clWhite); var OffsetY, I: Integer; procedure DrawOneMark; begin with ABarItemControl.Parent.Canvas do begin MoveTo(X + DoubleSize * 1, Y + OffsetY + DoubleSize * 2); LineTo(X + DoubleSize * 3, Y + OffsetY + DoubleSize * 4); LineTo(X + DoubleSize * 8, Y + OffsetY - DoubleSize * 1); end; Inc(OffsetY); end; begin with ABarItemControl.Parent.Canvas do if ABarItemControl.Enabled then begin OffsetY := 0; Pen.Color := clSilver; for I := 1 to DoubleSize do DrawOneMark; Pen.Color := Colors[GetSysColor(COLOR_BTNFACE) = 0]; for I := 1 to 2 * DoubleSize do DrawOneMark; Pen.Color := Colors[GetSysColor(COLOR_BTNFACE) <> 0]; for I := 1 to DoubleSize do DrawOneMark; MoveTo(X + DoubleSize - 1, Y + DoubleSize * 3 - (DoubleSize - 1)); LineTo(X + DoubleSize - 1, Y + DoubleSize * 5 + (DoubleSize - 1)); MoveTo(X + DoubleSize * 8, Y - DoubleSize * 1 + 2); LineTo(X + DoubleSize * 8, Y + DoubleSize * 3); end else begin OffsetY := 1; Pen.Color := GetSysColor(COLOR_BTNSHADOW); for I := 1 to 2 * DoubleSize do DrawOneMark; Pen.Color := GetSysColor(COLOR_BTNHIGHLIGHT); for I := 0 to DoubleSize - 1 do begin MoveTo(X + DoubleSize * 4 - (DoubleSize - 1), Y + DoubleSize * 6 + (DoubleSize - 1 - I)); LineTo(X + DoubleSize * 9, Y + DoubleSize * 1 - I); MoveTo(X + DoubleSize * 4, Y + DoubleSize * 7 - I); LineTo(X + DoubleSize * 9, Y + DoubleSize * 2 - I); end; end; end; class function TdxBarStandardPainter.IgnoreGlyphOpaque: Boolean; begin Result := True; end; class function TdxBarStandardPainter.BarIsBarSmall(ABarControl: TdxBarControl; const R: TRect): Boolean; begin Result := False; end; class procedure TdxBarStandardPainter.BarDrawMarkAtPos(ABarControl: TdxBarControl; DC: HDC; const ItemRect: TRect; Offset: Integer); var Pen: HPEN; X: Integer; begin if ABarControl.Horizontal then begin Pen := SelectObject(DC, CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNHIGHLIGHT))); X := Offset; MoveToEx(DC, X - 1, 1, nil); LineTo(DC, X + 2, 4); MoveToEx(DC, X + 3, 4, nil); LineTo(DC, X - 1, 8); ReverseGDIObject(DC, Pen); Pen := SelectObject(DC, CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNSHADOW))); MoveToEx(DC, X, 1, nil); LineTo(DC, X + 2, 3); LineTo(DC, X + 2, 4); LineTo(DC, X - 1, 7); ReverseGDIObject(DC, Pen); end else begin Pen := SelectObject(DC, CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNSHADOW))); X := ABarControl.ClientWidth - 8; MoveToEx(DC, X, Offset, nil); LineTo(DC, X + 4, Offset + 4); MoveToEx(DC, X + 4, Offset + 1, nil); LineTo(DC, X + 6, Offset - 1); ReverseGDIObject(DC, Pen); Pen := SelectObject(DC, CreatePen(PS_SOLID, 1, GetSysColor(COLOR_BTNHIGHLIGHT))); MoveToEx(DC, X + 1, Offset, nil); LineTo(DC, X + 3, Offset + 2); LineTo(DC, X + 4, Offset + 2); LineTo(DC, X + 7, Offset - 1); ReverseGDIObject(DC, Pen); end; end; procedure TdxBarStandardPainter.BarDrawMarkBackground(ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect; AToolbarBrush: HBRUSH); begin ABarControl.FillBackground(DC, ItemRect, AToolbarBrush, clNone, True); end; { TdxBarEnhancedPainter } class function TdxBarEnhancedPainter.BeforeFingersSize: Integer; begin Result := 1; end; class function TdxBarEnhancedPainter.FingersSize: Integer; begin Result := BeforeFingersSize + GripperSize + 2; end; class function TdxBarEnhancedPainter.SubMenuBeginGroupIndent: Integer; begin Result := 12; end; class function TdxBarEnhancedPainter.BarAllowQuickCustomizing: Boolean; begin Result := True; end; procedure TdxBarEnhancedPainter.BarDrawDockedBarBorder(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); procedure DrawFinger; begin with R do begin DrawEdge(DC, R, BDR_RAISEDINNER, BF_RECT); InflateRect(R, -1, -1); FillRect(DC, R, GetSysColorBrush(COLOR_BTNFACE)); InflateRect(R, 1, 1); ExcludeClipRect(DC, Left, Top, Right, Bottom); end; end; begin with R do begin DrawEdge(DC, R, BDR_RAISEDINNER, BF_RECT); InflateRect(R, -2, -2); if ABarControl.CanMoving then begin if ABarControl.Horizontal then begin Inc(Left, BeforeFingersSize); Right := Left + GripperSize; InflateRect(R, 0, -1); end else begin Inc(Top, BeforeFingersSize); Bottom := Top + GripperSize; InflateRect(R, -1, 0); end; DrawFinger; end; end; end; function TdxBarEnhancedPainter.BarMarkItemRect(ABarControl: TdxBarControl): TRect; begin case ABarControl.DockingStyle of dsTop, dsBottom: with Result do begin Left := ABarControl.ClientWidth - MarkSizeX; Top := 0; Right := Left + MarkSizeX; Bottom := ABarControl.ClientHeight; end; dsLeft, dsRight: with Result do begin Left := 0; Top := ABarControl.ClientHeight - MarkSizeX; Right := ABarControl.ClientWidth; Bottom := Top + MarkSizeX; end; else Result := ABarControl.GetCaptionRect; with Result do Right := Left + 3 + 7 + 3; end; end; class procedure TdxBarEnhancedPainter.BarDrawMarkAtPos(ABarControl: TdxBarControl; DC: HDC; const ItemRect: TRect; Offset: Integer); begin TdxBarPainter.BarDrawMarkAtPos(ABarControl, DC, ItemRect, Offset); end; procedure TdxBarEnhancedPainter.BarDrawMarkBackground(ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect; AToolbarBrush: HBRUSH); const MarkEdges: array[msSelected..msPressed] of UINT = (BDR_RAISEDINNER, BDR_SUNKENOUTER); begin if ABarControl.MarkDrawState = msNone then FrameRect(DC, ItemRect, AToolbarBrush) else DrawEdge(DC, ItemRect, MarkEdges[ABarControl.MarkDrawState], BF_RECT); InflateRect(ItemRect, -1, -1); ABarControl.FillBackground(DC, ItemRect, AToolbarBrush, clNone, True); InflateRect(ItemRect, 1, 1); end; { TdxBarFlatPainter } procedure TdxBarFlatPainter.CalculateSpinEditParts(const ADrawParams: TdxBarEditLikeControlDrawParams; var AParts: array of TRect; const AItemRect: TRect); begin inherited; Inc(AParts[secButtonUp].Bottom); end; class function TdxBarFlatPainter.GetControlCaptionOffset(ABarItemControl: TdxBarItemControl): Integer; begin if ABarItemControl.IsMenuItem then Result := 8 else Result := inherited GetControlCaptionOffset(ABarItemControl); end; procedure TdxBarFlatPainter.DrawGlyphAndTextInSubMenu( const ADrawParams: TdxBarButtonLikeControlDrawParams; var R: TRect); var I: Integer; AIconRect: TRect; AIsGlyphEmpty, AOpaque: Boolean; ABrush: HBRUSH; ADC: HDC; begin with ADrawParams do begin ADC := Canvas.Handle; AOpaque := DrawSelected or BarItemControl.FNonRecent; if DrawSelected then FrameFlatSelRect(ADC, R) else begin I := R.Left + 1 + BarItemControl.Parent.IconAreaSize; ABrush := BarItemControl.BarManager.FlatToolbarsBrush; DrawBackground(BarItemControl, ADC, Rect(R.Left, R.Top, I, R.Top + 1), ABrush, AOpaque); DrawBackground(BarItemControl, ADC, Rect(R.Left, R.Bottom - 1, I, R.Bottom), ABrush, AOpaque); DrawBackground(BarItemControl, ADC, Rect(R.Left, R.Top + 1, R.Left + 1, R.Bottom - 1), ABrush, AOpaque); ABrush := BarItemControl.Parent.BkBrush; DrawBackground(BarItemControl, ADC, Rect(I, R.Top, R.Right, R.Top + 1), ABrush, AOpaque); DrawBackground(BarItemControl, ADC, Rect(I, R.Bottom - 1, R.Right, R.Bottom), ABrush, AOpaque); DrawBackground(BarItemControl, ADC, Rect(R.Right - 1, R.Top + 1, R.Right, R.Bottom - 1), ABrush, AOpaque); end; InflateRect(R, -1, -1); AIconRect := GetSubMenuItemIconRect(R, BarItemControl.Parent.IconAreaSize - 2); AIsGlyphEmpty := not BarItemControl.HasIcon(ViewSize, ViewStructure); DrawGlyph(BarItemControl, ADC, AIconRect, cxEmptyRect, ptMenu, AIsGlyphEmpty, DrawSelected, Downed, False, False, False, False, False); if DrawSelected then ABrush := BarItemControl.Parent.ToolbarSelBrush else ABrush := BarItemControl.BarManager.FlatToolbarsBrush; R.Left := AIconRect.Right + 2; DrawBackground(BarItemControl, ADC, Rect(AIconRect.Right, AIconRect.Top, R.Left, AIconRect.Bottom), ABrush, AOpaque); if AIconRect.Top > R.Top then DrawBackground(BarItemControl, ADC, Rect(AIconRect.Left, R.Top, R.Left, AIconRect.Top), ABrush, AOpaque); if AIconRect.Bottom < R.Bottom then DrawBackground(BarItemControl, ADC, Rect(AIconRect.Left, AIconRect.Bottom, R.Left, R.Bottom), ABrush, AOpaque); if DrawSelected then ABrush := BarItemControl.Parent.ToolbarSelBrush else ABrush := BarItemControl.BkBrush; DrawBackground(BarItemControl, ADC, R, ABrush, AOpaque); Inc(R.Left, 8); DrawItemTextInSubMenu(ADrawParams, R); end; end; class procedure TdxBarFlatPainter.DrawLowered(DC: HDC; var R: TRect); begin FrameRect(DC, R, GetSysColorBrush(COLOR_BTNSHADOW)); InflateRect(R, -1, -1); // LoweredBorderSize(ABarItemControl) = 1 end; procedure TdxBarFlatPainter.DrawStaticBorder(const ADrawParams: TdxBarStaticLikeControlDrawParams; var ARect: TRect); var I: Integer; ABrush: HBRUSH; begin with ADrawParams do begin ABrush := StaticBorderBrush(BarItemControl, BorderStyle); for I := 1 to BorderWidth do begin FrameRect(Canvas.Handle, ARect, ABrush); InflateRect(ARect, -1, -1); end; end; end; class procedure TdxBarFlatPainter.FrameAndFillRect(ABarItemControl: TdxBarItemControl; DC: HDC; var R: TRect; Enabled, Selected, Pressed: Boolean); var Brush: HBRUSH; begin Brush := ABarItemControl.Parent.BkBrush; if Selected then begin FrameFlatSelRect(DC, R); if Pressed then Brush := ABarItemControl.Parent.ToolbarDownedSelBrush else Brush := ABarItemControl.Parent.ToolbarSelBrush; end else FrameRect(DC, R, ABarItemControl.Parent.BkBrush); InflateRect(R, -1, -1); FillRect(DC, R, Brush); end; class procedure TdxBarFlatPainter.GetArrowParams( const ADrawParams: TdxBarItemControlDrawParams; out ABrush: HBRUSH; out AArrowColor: COLORREF); begin AArrowColor := GetSysColor(COLOR_BTNTEXT); with ADrawParams do if DrawSelected then if DroppedDown or IsHighContrastWhite then begin ABrush := BarItemControl.Parent.ToolbarDownedSelBrush; AArrowColor := GetSysColor(COLOR_HIGHLIGHTTEXT); end else ABrush := BarItemControl.Parent.ToolbarSelBrush else ABrush := BarItemControl.BkBrush; end; class procedure TdxBarFlatPainter.GetCaptionParams( out AOffsets: TRect; out AHeightCorrection: Integer); begin AOffsets := Rect(2, 2, 2, 3); AHeightCorrection := 0; end; class function TdxBarFlatPainter.GetSubMenuItemTextIndent(const ADrawParams: TdxBarItemControlDrawParams): Integer; begin Result := inherited GetSubMenuItemTextIndent(ADrawParams) + 6; end; class function TdxBarFlatPainter.GlyphBkgndBrush(ABarItemControl: TdxBarItemControl; APaintType: TdxBarPaintType; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AForceUseBkBrush, AGrayScale: Boolean): HBRUSH; begin if ADroppedDown then if ADowned then Result := ABarItemControl.Parent.ToolbarDownedSelBrush else Result := ABarItemControl.Parent.BarControlOwnerBrush else if ASelected then if ADowned or ADrawDowned then Result := ABarItemControl.Parent.ToolbarDownedSelBrush else Result := ABarItemControl.Parent.ToolbarSelBrush else if ADowned then Result := ABarItemControl.Parent.ToolbarDownedBrush else if (APaintType = ptMenu) and not AForceUseBkBrush then Result := GetToolbarBrush(ABarItemControl) else Result := ABarItemControl.BkBrush; end; class function TdxBarFlatPainter.IsFlatItemText: Boolean; begin Result := True; end; class function TdxBarFlatPainter.LoweredBorderSize(ABarItemControl: TdxBarItemControl): Integer; begin Result := 1; end; class function TdxBarFlatPainter.StaticBorderBrush(ABarItemControl: TdxBarItemControl; ABorderStyle: TdxBarStaticBorderStyle): HBRUSH; begin Result := GetSysColorBrush(COLOR_BTNSHADOW); end; class function TdxBarFlatPainter.TextAreaOffset(ABarItemControl: TdxBarItemControl): Integer; begin // WARNING!!! sync with Indent if ABarItemControl.Parent.Kind = bkSubMenu then Result := 1 + ABarItemControl.Parent.TextSize + 2 else Result := 0; end; class function TdxBarFlatPainter.BeforeFingersSize: Integer; begin Result := 1; end; class function TdxBarFlatPainter.FingersSize: Integer; begin Result := BeforeFingersSize + GripperSize + 2; end; class function TdxBarFlatPainter.RealButtonArrowWidth(ABarManager: TdxBarManager): Integer; begin Result := inherited RealButtonArrowWidth(ABarManager); Dec(Result); end; class function TdxBarFlatPainter.RealLargeButtonArrowWidth(ABarManager: TdxBarManager): Integer; begin Result := inherited RealLargeButtonArrowWidth(ABarManager) - 1; end; class function TdxBarFlatPainter.SubMenuBeginGroupIndent: Integer; begin Result := 8; end; class function TdxBarFlatPainter.BarChildrenHaveShadows(ABarControl: TCustomdxBarControl): Boolean; begin Result := True; end; class procedure TdxBarFlatPainter.BarDrawBarControlOwner(ACustomBarControl: TCustomdxBarControl; DC: HDC; R: TRect; ABarControl: TCustomdxBarControl); begin BarDrawBarControlOwnerBorder(ACustomBarControl, DC, R, nil, ABarControl); InflateRect(R, -1, -1); FillRect(DC, R, ACustomBarControl.BarControlOwnerBrush); end; class procedure TdxBarFlatPainter.BarDrawBarControlOwnerBorder(ACustomBarControl: TCustomdxBarControl; DC: HDC; R: TRect; ABarItemControl: TdxBarItemControl; ABarControl: TCustomdxBarControl); var AClipRgn: HRGN; AClipRgnExists: Boolean; procedure DrawBarControlOwnerLink; var ALinkR, ATempRect, CR, WR: TRect; AOrigin: TPoint; AHandle: HWND; begin AClipRgn := 0; if not ABarControl.HandleAllocated then Exit; ALinkR := ABarControl.OwnerLinkBounds[True]; if ABarControl.OwnerControl = nil then // !!! begin GetDCOrgEx(DC, AOrigin); OffsetRect(ALinkR, -AOrigin.X, -AOrigin.Y); end else begin AHandle := ABarControl.OwnerControl.Handle; GetClientRect(AHandle, CR); MapWindowRect(AHandle, 0, CR); if IntersectRect(ATempRect, CR, ALinkR) then // client area OffsetRect(ALinkR, -CR.Left, -CR.Top) else begin GetWindowRect(AHandle, WR); // NC OffsetRect(ALinkR, -WR.Left, -WR.Top); end; end; BarDrawBarControlOwnerLink(ACustomBarControl, DC, R, ALinkR, ABarItemControl); AClipRgn := CreateRectRgn(0, 0, 0, 0); AClipRgnExists := GetClipRgn(DC, AClipRgn) = 1; with ALinkR do ExcludeClipRect(DC, Left, Top, Right, Bottom); end; begin DrawBarControlOwnerLink; BarDrawBarControlOwnerFrame(ACustomBarControl, DC, R); if AClipRgn <> 0 then begin if AClipRgnExists then SelectClipRgn(DC, AClipRgn) else SelectClipRgn(DC, 0); DeleteObject(AClipRgn); end; end; class procedure TdxBarFlatPainter.BarDrawBarControlOwnerFrame(ACustomBarControl: TCustomdxBarControl; DC: HDC; R: TRect); begin FrameRect(DC, R, ACustomBarControl.BarManager.FlatToolbarsBorderBrush); end; class procedure TdxBarFlatPainter.BarDrawBarControlOwnerLink(ACustomBarControl: TCustomdxBarControl; DC: HDC; R, ALinkR: TRect; ABarItemControl: TdxBarItemControl); begin FillRect(DC, ALinkR, ACustomBarControl.BarControlOwnerBrush); end; class function TdxBarFlatPainter.BarHasShadow(ABarControl: TCustomdxBarControl): Boolean; begin Result := ABarControl.DockingStyle = dsNone; end; class function TdxBarFlatPainter.BarToolbarBrush(ABarControl: TCustomdxBarControl): HBRUSH; begin Result := ABarControl.BarManager.FlatToolbarsBrush; end; class function TdxBarFlatPainter.BarToolbarBrushEx(ABarControl: TdxBarControl): HBRUSH; begin if not (ABarControl.IsMainMenu or ABarControl.Bar.IsStatusBar) then Result := inherited BarToolbarBrushEx(ABarControl) else Result := GetSysColorBrush(COLOR_BTNFACE); end; class function TdxBarFlatPainter.BarToolbarDownedBrush(ABarControl: TCustomdxBarControl): HBRUSH; begin Result := ABarControl.BarManager.FlatToolbarsDownedBrush; end; class function TdxBarFlatPainter.BarToolbarDownedSelBrush(ABarControl: TCustomdxBarControl): HBRUSH; begin Result := ABarControl.BarManager.FlatToolbarsDownedSelBrush; end; class function TdxBarFlatPainter.BarToolbarSelBrush(ABarControl: TCustomdxBarControl): HBRUSH; begin Result := ABarControl.BarManager.FlatToolbarsSelBrush; end; class procedure TdxBarFlatPainter.GetEditTextVerticalOffsets( out ATop, ABottom: Integer); begin ATop := 2; ABottom := 2; end; class function TdxBarFlatPainter.BarAllowHotTrack: Boolean; begin Result := True; end; class function TdxBarFlatPainter.BarAllowQuickCustomizing: Boolean; begin Result := True; end; class function TdxBarFlatPainter.BarBeginGroupSideSize: Integer; begin Result := (BarBeginGroupSize - 1{|}) div 2; end; class function TdxBarFlatPainter.BarBeginGroupSize: Integer; begin Result := 2 + 1{|} + 2; end; procedure TdxBarFlatPainter.BarDrawBeginGroup(ABarControl: TCustomdxBarControl; DC: HDC; ABeginGroupRect: TRect; AToolbarBrush: HBRUSH; AHorz: Boolean); begin with ABeginGroupRect do if AHorz then begin ABarControl.FillBackground(DC, Rect(Left, Top, Right, Top + BarBeginGroupSideSize), AToolbarBrush, clNone, True); ABarControl.FillBackground(DC, Rect(Left, Bottom - BarBeginGroupSideSize, Right, Bottom), AToolbarBrush, clNone, True); InflateRect(ABeginGroupRect, 0, -BarBeginGroupSideSize); FillRect(DC, Rect(Left, Top, Right, Top + 1), COLOR_BTNSHADOW + 1); end else begin ABarControl.FillBackground(DC, Rect(Left, Top, Left + BarBeginGroupSideSize, Bottom), AToolbarBrush, clNone, True); ABarControl.FillBackground(DC, Rect(Right - BarBeginGroupSideSize, Top, Right, Bottom), AToolbarBrush, clNone, True); InflateRect(ABeginGroupRect, -BarBeginGroupSideSize, 0); FillRect(DC, Rect(Left, Top, Left + 1, Bottom), COLOR_BTNSHADOW + 1); end; end; class procedure TdxBarFlatPainter.BarDrawCloseButton(ABarControl: TdxBarControl; DC: HDC; R: TRect); procedure DrawCross(var R: TRect); // const // CrossColors: array[Boolean] of Integer = (COLOR_CAPTIONTEXT, COLOR_BTNTEXT); var APen: HPEN; begin InflateRect(R, -3, -4); with R do begin if Odd(Right - Left) then Dec(Right); Bottom := Top + (Right - Left - 1); end; with R do begin // APen := SelectObject(DC, CreatePen(PS_SOLID, 1, // GetSysColor(CrossColors[ABarControl.CloseButtonState = msSelected]))); APen := SelectObject(DC, CreatePen(PS_SOLID, 1, BarMarkArrowColor(ABarControl, ABarControl.CloseButtonState))); MoveToEx(DC, Left, Top, nil); LineTo(DC, Right - 1, Bottom); MoveToEx(DC, Left + 1, Top, nil); LineTo(DC, Right, Bottom); MoveToEx(DC, Left, Bottom - 1, nil); LineTo(DC, Right - 1, Top - 1); MoveToEx(DC, Left + 1, Bottom - 1, nil); LineTo(DC, Right, Top - 1); DeleteObject(SelectObject(DC, APen)); end; end; begin BarDrawCaptionElement(ABarControl, DC, R, ABarControl.CloseButtonState); DrawCross(R); end; procedure TdxBarFlatPainter.BarDrawDockedBarBorder(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); procedure DrawFinger; var I: Integer; Brush: HBRUSH; begin with R do begin if ABarControl.Horizontal then for I := Top to Bottom - 1 do begin if Odd(I - Top) then Brush := AToolbarBrush else Brush := COLOR_BTNSHADOW + 1; FillRect(DC, Rect(Left, I, Right, I + 1), Brush); end else for I := Left to Right - 1 do begin if Odd(I - Left) then Brush := AToolbarBrush else Brush := COLOR_BTNSHADOW + 1; FillRect(DC, Rect(I, Top, I + 1, Bottom), Brush); end; end; end; begin with R do begin FrameRect(DC, R, GetSysColorBrush(COLOR_BTNFACE)); InflateRect(R, -1, -1); FillRect(DC, Rect(Left, Top, Left + 1, Top + 1), COLOR_BTNFACE + 1); FillRect(DC, Rect(Right - 1, Top, Right, Top + 1), COLOR_BTNFACE + 1); FillRect(DC, Rect(Left, Bottom - 1, Left + 1, Bottom), COLOR_BTNFACE + 1); FillRect(DC, Rect(Right - 1, Bottom - 1, Right, Bottom), COLOR_BTNFACE + 1); InflateRect(R, -1, -1); if ABarControl.CanMoving then begin if ABarControl.Horizontal then begin Inc(Left, BeforeFingersSize); Right := Left + GripperSize; InflateRect(R, 0, -3); end else begin Inc(Top, BeforeFingersSize); Bottom := Top + GripperSize; InflateRect(R, -3, 0); end; DrawFinger; end; end; end; class procedure TdxBarFlatPainter.BarDrawFloatingBarBorder(ABarControl: TdxBarControl; DC: HDC; var R, CR: TRect; AToolbarBrush: HBRUSH); var I: Integer; begin FrameRect(DC, R, ABarControl.BarManager.FlatToolbarsBorderBrush); InflateRect(R, -1, -1); FrameRect(DC, R, GetSysColorBrush(COLOR_BTNHIGHLIGHT)); for I := R.Left + 1 to CR.Left - 1 do begin InflateRect(R, -1, -1); FrameRect(DC, R, AToolbarBrush); end; end; procedure TdxBarFlatPainter.BarDrawMark(ABarControl: TdxBarControl; DC: HDC; MarkR: TRect); procedure DrawBackground; var R: TRect; ABrush: HBRUSH; begin if ABarControl.HasCloseButton then begin R := MarkR; with R do begin Left := Right; Right := Left + FloatToolbarMarkIndent; end; ABrush := CreateSolidBrush(ABarControl.CaptionBkColor); FillRect(DC, R, ABrush); DeleteObject(ABrush); end; if ABarControl.MarkDrawState = msPressed then BarDrawBarControlOwner(ABarControl, DC, MarkR, ABarControl.FQuickPopup) else BarDrawCaptionElement(ABarControl, DC, MarkR, ABarControl.MarkDrawState); end; begin DrawBackground; inherited BarDrawMark(ABarControl, DC, MarkR); end; class procedure TdxBarFlatPainter.BarDrawMDIButton(ABarControl: TdxBarControl; AButton: TdxBarMDIButton; ASelected, APressed: Boolean; DC: HDC; R: TRect); const Enables: array[Boolean] of Integer = (DFCS_INACTIVE, 0); var ABitmap: TBitmap; ABrush: HBRUSH; begin ABitmap := TBitmap.Create; try InflateRect(R, -1, -1); ABitmap.Width := R.Right - R.Left; ABitmap.Height := R.Bottom - R.Top; DrawFrameControl(ABitmap.Canvas.Handle, Rect(-1, -1, ABitmap.Width + 1, ABitmap.Height + 1), DFC_CAPTION, MDIButtonStyles[AButton] or DFCS_FLAT or Enables[ABarControl.MDIButtonEnabled(AButton, MF_GRAYED)]); if not ASelected and not APressed then begin InflateRect(R, 1, 1); ABarControl.FillBackground(DC, R, ABarControl.BkBrush, clNone, True); InflateRect(R, -1, -1); end else begin if APressed then begin if ASelected then ABrush := ABarControl.ToolbarDownedSelBrush else ABrush := ABarControl.ToolbarDownedBrush; end else if ASelected then ABrush := ABarControl.ToolbarSelBrush else ABrush := ABarControl.ToolbarBrush; FillRect(DC, R, ABrush); end; TransparentDraw(DC, R, ABitmap); if ASelected or APressed then begin InflateRect(R, 1, 1); FrameFlatSelRect(DC, R); end; finally ABitmap.Free; end; end; function TdxBarFlatPainter.BarMarkItemRect(ABarControl: TdxBarControl): TRect; begin case ABarControl.DockingStyle of dsTop, dsBottom: with Result do begin Left := ABarControl.ClientWidth - MarkSizeX; Top := 0; Right := Left + MarkSizeX; Bottom := ABarControl.ClientHeight; end; dsLeft, dsRight: with Result do begin Left := 0; Top := ABarControl.ClientHeight - MarkSizeX; Right := ABarControl.ClientWidth; Bottom := Top + MarkSizeX; end; else Result := ABarControl.GetCaptionRect; with Result do begin Left := Right - (Bottom - Top); if ABarControl.HasCloseButton then OffsetRect(Result, -(cxRectWidth(ABarControl.CloseButtonRect) + FloatToolbarMarkIndent), 0); with ABarControl.GetCaptionRect do if Result.Left < Left{ - 3} then Result.Left := Left{ - 3}; end; end; end; class function TdxBarFlatPainter.BarToolbarBrushEx2(ABarControl: TdxBarControl): HBRUSH; begin Result := GetSysColorBrush(COLOR_WINDOW); end; class procedure TdxBarFlatPainter.DrawQuickCustItemFrame(ABarItemControl: TdxBarItemControl; DC: HDC; var R, ARect: TRect; Selected: Boolean); begin inherited; if not Selected then DrawBackgroundFrameRect(ABarItemControl, DC, R, BarToolbarBrush(ABarItemControl.Parent), False); InflateRect(R, -1, -1); end; class procedure TdxBarFlatPainter.DrawQuickCustItemFrameSelected(ABarItemControl: TdxBarItemControl; DC: HDC; WholeR, R: TRect; Selected: Boolean); begin if Selected then begin FrameFlatSelRect(DC, WholeR); with R do begin Left := Right; Right := Left + 2; // paint over! end; FillRect(DC, R, ABarItemControl.Parent.ToolbarSelBrush); end; end; class function TdxBarFlatPainter.IsQuickControlPopupOnRight: Boolean; begin Result := True; end; class procedure TdxBarFlatPainter.CorrectButtonControlDefaultHeight(var DefaultHeight: Integer); begin Inc(DefaultHeight, 2); end; class procedure TdxBarFlatPainter.CorrectButtonControlDefaultWidth(var DefaultWidth: Integer); begin Inc(DefaultWidth, 2 + 1 + 6); end; procedure TdxBarFlatPainter.DrawButtonControlArrow( const ADrawParams: TdxBarButtonLikeControlDrawParams; R1: TRect; ABrush: HBRUSH); var ADC: HDC; begin with ADrawParams do begin ADC := Canvas.Handle; if PaintType <> ptMenu then Dec(R1.Left); if (PaintType = ptMenu) or not DroppedDown then begin DrawFrameRect(BarItemControl, ADC, R1, ABrush, PaintType, DrawSelected, Downed); InflateRect(R1, -1, -1); DrawBackground(BarItemControl, ADC, R1, ABrush, DroppedDown or DrawSelected or BarItemControl.FNonRecent); InflateRect(R1, 1, 1); end; if PaintType = ptMenu then DrawLargeItemArrow(ADC, R1, adRight, BarItemControl.Parent.MenuArrowHeight, (IsHighContrastWhite and DrawSelected) or DroppedDown, Enabled and DropDownEnabled, True{Flat}) else DrawItemArrow(ADC, R1, adDown, Enabled and DropDownEnabled, DrawSelected and not DroppedDown and IsHighContrastWhite, True{Flat}); end; end; class function TdxBarFlatPainter.IsDropDownRepaintNeeded: Boolean; begin Result := True; end; class procedure TdxBarFlatPainter.ComboControlDrawSimpleButton( ABarComboControl: TdxBarItemControl; ADC: HDC; var ARect: TRect; ADroppedDown, ASelected: Boolean; ABrush: HBRUSH; APaintType: TdxBarPaintType); var ASpaceBrush: HBRUSH; begin if ASelected then begin InflateRect(ARect, 1, 1); FrameFlatSelRect(ADC, ARect); end else begin if ABarComboControl.Enabled then ASpaceBrush := TCustomdxBarComboControl(ABarComboControl).EditBkBrush else ASpaceBrush := ABarComboControl.Parent.BkBrush; FrameRect(ADC, ARect, ASpaceBrush); FillRect(ADC, Rect(ARect.Left - 1, ARect.Top, ARect.Left, ARect.Bottom), ASpaceBrush); end; InflateRect(ARect, -1, -1); FillRect(ADC, ARect, ABrush); end; class procedure TdxBarFlatPainter.ComboControlGetArrowParams( const ADrawParams: TdxBarEditLikeControlDrawParams; out ABrush: HBRUSH; out AArrowColor: COLORREF); begin inherited; if (ADrawParams.PaintType = ptMenu) and not ADrawParams.DrawSelected then ABrush := ADrawparams.BarItemControl.Parent.ToolbarBrush; if not ADrawParams.Enabled then AArrowColor := GetSysColor(COLOR_BTNSHADOW); end; class function TdxBarFlatPainter.DropDownListBoxBorderSize: Integer; begin Result := 2; end; class function TdxBarFlatPainter.SubMenuControlArrowsOffset: Integer; begin Result := 1; end; class function TdxBarFlatPainter.SubMenuControlBeginGroupRect( ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; const AItemRect: TRect): TRect; begin Result := AItemRect; Result.Bottom := Result.Top; Dec(Result.Top, SubMenuControlBeginGroupSize); end; class function TdxBarFlatPainter.SubMenuControlBeginGroupSize: Integer; begin Result := 2 + 1 + 2; end; class function TdxBarFlatPainter.SubMenuControlClientBorderSize: Integer; begin Result := 1; end; class procedure TdxBarFlatPainter.SubMenuControlCalcDrawingConsts(ACanvas: TcxCanvas; ATextSize: Integer; out AMenuArrowWidth, AMarkSize: Integer); var AArrowSize: Integer; begin inherited; AArrowSize := SubMenuControlMarkArrowSize(AMarkSize - 2); if Odd(AArrowSize) then AMarkSize := (AArrowSize - 1) * 2 + 2 * 3; end; class function TdxBarFlatPainter.SubMenuControlDetachCaptionAreaSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; begin Result := ABarSubMenuControl.DetachCaptionSize + 1; end; procedure TdxBarFlatPainter.SubMenuControlDrawBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); procedure DrawFlatBorder; begin FrameRect(DC, R, ABarSubMenuControl.BarManager.FlatToolbarsBorderBrush); BarDrawOwnerLink(ABarSubMenuControl, DC); end; begin with R do begin DrawFlatBorder; if ABarSubMenuControl.Detachable then begin InflateRect(R, -1, -1); Bottom := Top + 1; FillRect(DC, R, COLOR_WINDOW + 1); Top := Bottom; Bottom := Top + ABarSubMenuControl.DetachCaptionSize; FillRect(DC, Rect(Left, Top, Left + 1, Bottom), COLOR_WINDOW + 1); FillRect(DC, Rect(Right - 1, Top, Right, Bottom), COLOR_WINDOW + 1); SubMenuControlDrawDetachCaption(ABarSubMenuControl, DC, ABarSubMenuControl.DetachCaptionRect); end; end end; class procedure TdxBarFlatPainter.SubMenuControlDrawClientBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; const R: TRect; ABrush: HBRUSH); begin FrameRect(DC, R, ABarSubMenuControl.ToolbarItemsBrush); with R do FillRect(DC, Rect(Left, Top + 1, Left + 1, Bottom - 1), ABrush); end; procedure TdxBarFlatPainter.SubMenuControlDrawDetachCaption(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); const MarkSize = 33; Colors: array[Boolean] of COLORREF = (COLOR_BTNSHADOW, COLOR_BTNTEXT); var Brush: HBRUSH; I: Integer; begin if ABarSubMenuControl.DetachCaptionSelected then begin FrameFlatSelRect(DC, R); InflateRect(R, -1, -1); Brush := ABarSubMenuControl.ToolbarSelBrush; end else Brush := ABarSubMenuControl.BarManager.FlatToolbarsBrush; FillRect(DC, R, Brush); Brush := Colors[ABarSubMenuControl.DetachCaptionSelected] + 1; with R do begin InflateRect(R, -(Right - Left - MarkSize) div 2, -1); Right := Left + MarkSize; for I := Top to Bottom - 1 do if not Odd(I - Top) then FillRect(DC, Rect(Left, I, Right, I + 1), Brush); end; end; procedure TdxBarFlatPainter.SubMenuControlDrawBeginGroup(ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; ACanvas: TcxCanvas; const ABeginGroupRect: TRect); var R: TRect; ABrush: HBRUSH; LD, RD: Integer; AOpaque: Boolean; ADC: HDC; begin ADC := ACanvas.Handle; R := ABeginGroupRect; if not IgnoreNonRecentColor and AControl.FChangeRecentGroup and AControl.FNonRecent then ABrush := SubMenuControlToolbarItemsBrush(ABarSubMenuControl) else ABrush := ABarSubMenuControl.BkBrush; AOpaque := not IgnoreNonRecentColor and AControl.FNonRecent and not AControl.FChangeRecentGroup; with R do begin LD := Left + AControl.TextAreaOffset; DrawBackground(AControl, ADC, Rect(Left, Top, LD, Bottom), ABarSubMenuControl.BarManager.FlatToolbarsBrush, AOpaque); DrawBackground(AControl, ADC, Rect(LD, Top, Right, Bottom), ABrush, AOpaque); RD := (Top + Bottom) div 2; SubMenuControlDrawSeparator(ACanvas, Rect(LD + SubMenuBeginGroupIndent, RD, Right + 1, RD + 1)); end; end; procedure TdxBarFlatPainter.SubMenuControlDrawSeparator(ACanvas: TcxCanvas; const ARect: TRect); begin ACanvas.FrameRect(ARect, SubMenuControlGetSeparatorColor, 1, [bTop]); end; class function TdxBarFlatPainter.SubMenuControlGetSeparatorColor: TColor; begin Result := GetSysColor(COLOR_BTNSHADOW); end; class function TdxBarFlatPainter.SubMenuControlMarkArrowSize(AMarkSize: Integer): Integer; begin Result := (AMarkSize - 2 * 2) div 2; if (Result > 4) and Odd(Result) then Dec(Result); end; class function TdxBarFlatPainter.SubMenuControlNormalItemHeight: Integer; begin Result := 19 + 1; end; class procedure TdxBarFlatPainter.SubMenuControlOffsetDetachCaptionRect(ABarSubMenuControl: TdxBarSubMenuControl; var R: TRect); begin InflateRect(R, -2, -2); end; class procedure TdxBarFlatPainter.SubMenuControlPrepareBkBrush(ABarSubMenuControl: TdxBarSubMenuControl; var ABkBrush: HBRUSH); begin ABkBrush := SubMenuControlToolbarItemsBrush(ABarSubMenuControl); end; class function TdxBarFlatPainter.SubMenuControlTextSize(ACanvas: TcxCanvas): Integer; begin Result := inherited SubMenuControlTextSize(ACanvas) + 1; end; class function TdxBarFlatPainter.SubMenuControlToolbarItemsBrush(ABarSubMenuControl: TdxBarSubMenuControl): HBRUSH; begin Result := GetSysColorBrush(COLOR_WINDOW); end; class procedure TdxBarFlatPainter.CustomComboDrawItem(ABarCustomCombo: TdxBarCustomCombo; ACanvas: TCanvas; AIndex: Integer; ARect: TRect; AState: TOwnerDrawState; AInteriorIsDrawing: Boolean); var S: string; begin with ACanvas, ARect do begin if AIndex = -1 then S := ABarCustomCombo.Text else S := ABarCustomCombo.Items[AIndex]; FillRect(ARect); TextOut(Left + 2, Top + Byte(AInteriorIsDrawing) * 2, S); end; end; class function TdxBarFlatPainter.EditControlBorderOffsets: TRect; begin Result := Rect(1, 1, 1, 1); end; procedure TdxBarFlatPainter.EditControlDrawBorder( const ADrawParams: TdxBarEditLikeControlDrawParams; var ARect: TRect); begin with ADrawParams do begin if DrawSelected then FrameFlatSelRect(Canvas.Handle, ARect) else if (PaintType = ptMenu) and not IsTransparent then FrameRect(Canvas.Handle, ARect, BarEditControl.Parent.ToolbarBrush) else if not Enabled and not IsTransparent then FrameRect(Canvas.Handle, ARect, GetSysColorBrush(COLOR_BTNSHADOW)) else DrawBackgroundFrameRect(BarEditControl, Canvas.Handle, ARect, BarEditControl.Parent.BkBrush, IsTransparent and BarEditControl.FNonRecent); InflateRect(ARect, -1, -1); end; end; procedure TdxBarFlatPainter.EditControlDrawSelectionFrame(const ADrawParams: TdxBarEditLikeControlDrawParams; const ARect: TRect); begin inherited; ExcludeFrameRegion(ADrawParams.Canvas, ARect, cxRectInflate(ARect, -1, -1)); end; class function TdxBarFlatPainter.EditControlCaptionRightIndentIsOpaque( const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; begin with ADrawParams do Result := (PaintType = ptMenu) and (DrawSelected or BarItemControl.FNonRecent); end; procedure TdxBarFlatPainter.EditControlDrawTextField(ABarEditControl: TdxBarEditControl; DC: HDC; const ARect: TRect; AIgnoreEnabled: Boolean); begin inherited EditControlDrawTextField(ABarEditControl, DC, ARect, True); end; class function TdxBarFlatPainter.EditControlES_Style: Integer; begin Result := inherited EditControlES_Style or ES_MULTILINE; end; class function TdxBarFlatPainter.EditControlCaptionIconRelativeLeftIndent(const ADrawParams: TdxBarEditLikeControlDrawParams): Integer; begin Result := GetSubMenuItemTextIndent(ADrawParams) - ADrawParams.BarItemControl.Parent.GetIconAreaSize; end; class function TdxBarFlatPainter.EditControlCaptionLeftIndent(const ADrawParams: TdxBarEditLikeControlDrawParams): Integer; begin Result := 6; end; class function TdxBarFlatPainter.EditControlCaptionRightIndent: Integer; begin Result := 5; end; class function TdxBarFlatPainter.EditControlSubmenuGlyphIndents(const ADrawParams: TdxBarEditLikeControlDrawParams): TRect; begin Result := Rect(7, 0, 0, 0); end; class function TdxBarFlatPainter.EditControlGetRightCaptionIndentBrush(ABarEditControl: TdxBarCustomEditControl): HBRUSH; begin Result := ABarEditControl.CaptionBkBrush; end; class function TdxBarFlatPainter.EditControlGlyphIsDrawSelected(ABarEditControl: TdxBarCustomEditControl): Boolean; begin Result := ABarEditControl.DrawSelected and (ABarEditControl.GetPaintType = ptMenu) end; class procedure TdxBarFlatPainter.EditControlPrepareEditWnd(ABarEditControl: TdxBarEditControl; AHandle: HWND); var R: TRect; begin R := ABarEditControl.WindowRect; with R do begin OffsetRect(R, -Left, -Top); InflateRect(R, -2, -2); end; SendMessage(AHandle, EM_SETRECTNP, 0, LPARAM(@R)); end; class procedure TdxBarFlatPainter.EditControlUpdateWndText(ABarEditControl: TdxBarEditControl; AHandle: HWND; ANotEqual: Boolean); begin if ANotEqual then SendMessage(AHandle, WM_COMMAND, MAKEWPARAM(0, EN_CHANGE), AHandle); inherited EditControlUpdateWndText(ABarEditControl, AHandle, ANotEqual); end; class function TdxBarFlatPainter.HasEditControlExternalFrame( APaintType: TdxBarPaintType; ASelected: Boolean): Boolean; begin Result := ASelected and (APaintType = ptMenu); end; class procedure TdxBarFlatPainter.SysPanelDraw(AHandle: HWND; AllowResizing, MouseAboveCloseButton, CloseButtonIsTracking: Boolean; var CloseButtonRect, GripRect: TRect; Corner: TdxCorner); begin dxBarPopupNCPaint(AHandle, AllowResizing, True, MouseAboveCloseButton, CloseButtonIsTracking, CloseButtonRect, GripRect, Corner); end; class function TdxBarFlatPainter.IsDateNavigatorFlat: Boolean; begin Result := True; end; class procedure TdxBarFlatPainter.DateNavigatorDrawButton(ABarItem: TdxBarItem; DC: HDC; R: TRect; const ACaption: string; APressed: Boolean); begin with R do begin FrameRect(DC, R, GetSysColorBrush(COLOR_BTNSHADOW)); InflateRect(R, -1, -1); FrameRect(DC, R, GetSysColorBrush(COLOR_BTNFACE)); InflateRect(R, -1, -1); end; DateNavigatorDrawButtonCaption(DC, R, 0, ACaption, True); end; procedure TdxBarFlatPainter.SpinEditControlDrawButton(const ADrawParams: TdxBarSpinEditDrawParams; ARect: TRect; AButtonIndex: Integer); var AArrowPos: TPoint; begin with ADrawParams do begin FrameAndFillRect(BarEditControl, Canvas.Handle, ARect, Enabled, DrawSelected, ActiveButtonIndex = AButtonIndex); AArrowPos := GetSpinEditArrowPos(ADrawParams, ARect, AButtonIndex); DrawSpinEditArrow(ADrawParams, AArrowPos, AButtonIndex); end; end; class function TdxBarFlatPainter.ContainerControlSubMenuOffset: Integer; begin Result := 2 + 1 + 6; end; function TdxBarFlatPainter.InPlaceSubItemControlIsFlatItemText(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams): Boolean; begin Result := inherited InPlaceSubItemControlIsFlatItemText(ADrawParams) and IsFlatItemTextForMenu; end; function TdxBarFlatPainter.InPlaceSubItemControlIsArrowSelected(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams): Boolean; begin Result := not ADrawParams.DrawSelected or IsHighContrastWhite; end; function TdxBarFlatPainter.GetBorderSize: Integer; begin Result := 1; end; class procedure TdxBarFlatPainter.DrawGlyphBorder(ABarItemControl: TdxBarItemControl; ADC: HDC; ABrush: HBRUSH; ANeedBorder: Boolean; R: TRect; APaintType: TdxBarPaintType; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AIsSplit: Boolean); begin if ADroppedDown then BarDrawBarControlOwnerBorder(ABarItemControl.Parent, ADC, R, ABarItemControl, ABarItemControl.OwnedBarControl) else if ADowned or (ASelected and (APaintType <> ptMenu)) then FrameFlatSelRect(ADC, R) else if ANeedBorder then DrawBackgroundFrameRect(ABarItemControl, ADC, R, ABrush, ASelected or ADowned or ADrawDowned or ABarItemControl.FNonRecent or ABarItemControl.IsBkColorAssigned); end; class procedure TdxBarFlatPainter.DrawGlyphCheckMark(ABarItemControl: TdxBarItemControl; DC: HDC; X, Y, DoubleSize: Integer); //const // Colors: array[Boolean] of TColor = (clBlack, clWhite); var OffsetY, I: Integer; procedure DrawOneMark; begin with ABarItemControl.Parent.Canvas do begin MoveTo(X + DoubleSize * 1, Y + OffsetY + DoubleSize * 2); LineTo(X + DoubleSize * 3, Y + OffsetY + DoubleSize * 4); LineTo(X + DoubleSize * 8, Y + OffsetY - DoubleSize * 1); end; Inc(OffsetY); end; begin with ABarItemControl.Parent.Canvas do if ABarItemControl.Enabled then begin OffsetY := 0; if IsHighContrastWhite or IsHighContrast2 then Pen.Color := clWhite else{ if IsHighContrast2 then Pen.Color := clBlack else} Pen.Color := clBlack; // Pen.Color := Colors[GetSysColor(COLOR_BTNFACE) = 0]; for I := 1 to 2 * DoubleSize do DrawOneMark; end else begin OffsetY := 1; Pen.Color := GetSysColor(COLOR_BTNSHADOW); for I := 1 to 2 * DoubleSize do DrawOneMark; end; end; class procedure TdxBarFlatPainter.DrawGlyphImage(ABarItemControl: TdxBarItemControl; DC: HDC; ABrush: HBRUSH; NeedBorder: Boolean; R: TRect; const GlyphRect: TRect; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; Selected, Down, DrawDowned, ForceUseBkBrush, GrayScale, BarControlOwner: Boolean; PaintType: TdxBarPaintType); var ATransparent: Boolean; begin if NeedBorder then InflateRect(R, -1, -1); ATransparent := not ABarItemControl.FNonRecent and ABarItemControl.Parent.IsTransparent; if ATransparent then begin DrawBackground(ABarItemControl, DC, R, ABrush, Down or DrawDowned or Selected or ABarItemControl.FNonRecent or ABarItemControl.IsBkColorAssigned); ABrush := 0; end; TransparentDraw(ABarItemControl, DC, ABrush, R, GlyphRect, AGlyph, AImages, AImageIndex, ABarItemControl.BarManager.ImageListBkColor, ABarItemControl.GetImageEnabled(PaintType), GrayScale, True{Flat}, Selected, Down, DrawDowned, True{Shadow}, GetFaded(ABarItemControl.Parent){Faded}, ABarItemControl.BarManager.ImageOptions.SmoothGlyphs, ABarItemControl.BarManager.ImageOptions.UseLeftBottomPixelAsTransparent); if NeedBorder then InflateRect(R, 1, 1); end; class procedure TdxBarFlatPainter.DrawFrameRect(ABarItemControl: TdxBarItemControl; ADC: HDC; const ARect: TRect; ABrush: HBRUSH; APaintType: TdxBarPaintType; ASelected, ADowned: Boolean); begin if (APaintType = ptMenu) or ASelected or ADowned then if (APaintType = ptMenu) and not ASelected then FrameRect(ADC, ARect, GetSysColorBrush(COLOR_BTNSHADOW)) else FrameFlatSelRect(ADC, ARect) else FrameRect(ADC, ARect, ABarItemControl.Parent.BkBrush); end; class procedure TdxBarFlatPainter.FrameFlatSelRect(DC: HDC; const R: TRect); begin if IsHighContrastBlack or IsHighContrast2 then FrameRectByColor(DC, R, clHighlightText) else dxBar.FrameFlatSelRect(DC, R); end; class function TdxBarFlatPainter.GetToolbarBrush(ABarItemControl: TdxBarItemControl): HBRUSH; begin Result := ABarItemControl.BarManager.FlatToolbarsBrush; end; class function TdxBarFlatPainter.BarCaptionBkColor(ABarControl: TdxBarControl; AMainFormActive: Boolean): COLORREF; begin Result := inherited BarCaptionBkColor(ABarControl, False); end; class function TdxBarFlatPainter.BarMarkArrowColor(ABarControl: TdxBarControl; AState: TdxBarMarkState): COLORREF; begin if AState <> msNone then Result := GetSysColor(COLOR_BTNTEXT) else Result := inherited BarMarkArrowColor(ABarControl, AState); end; procedure TdxBarFlatPainter.BarDrawMarkBackground(ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect; AToolbarBrush: HBRUSH); begin if ABarControl.MarkDrawState = msPressed then BarDrawBarControlOwner(ABarControl, DC, ItemRect, ABarControl.FQuickPopup) else begin if ABarControl.MarkDrawState = msNone then FrameRect(DC, ItemRect, AToolbarBrush) else FrameFlatSelRect(DC, ItemRect); InflateRect(ItemRect, -1, -1); if ABarControl.MarkDrawState = msSelected then begin AToolbarBrush := ABarControl.ToolbarSelBrush; FillRect(DC, ItemRect, AToolbarBrush); end else ABarControl.FillBackground(DC, ItemRect, AToolbarBrush, clNone, True); InflateRect(ItemRect, 1, 1); end; end; class procedure TdxBarFlatPainter.BarOffsetFloatingBarCaption(ABarControl: TdxBarControl; var X: Integer; var R: TRect); begin Inc(X, 2); R.Right := ABarControl.MarkNCRect.Left; end; class function TdxBarFlatPainter.GetDrawMarkElementColor(ABarControl: TdxBarControl): Integer; begin if IsHighContrastWhite and (ABarControl.MarkDrawState = msSelected) then Result := COLOR_BTNFACE else Result := inherited GetDrawMarkElementColor(ABarControl); end; procedure TdxBarFlatPainter.SubMenuControlDrawNonRecentGroupSeparator(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; AArrowDirection: TcxArrowDirection); begin // do nothing end; procedure TdxBarFlatPainter.SubMenuControlDrawMarkSelection( ABarSubMenuControl: TdxBarSubMenuControl; ADC: HDC; const AMarkRect: TRect); begin FrameFlatSelRect(ADC, AMarkRect); DrawBackground(ABarSubMenuControl.BottomItemControl, ADC, cxRectInflate(AMarkRect, -1, -1), ABarSubMenuControl.ToolbarSelBrush, True); end; class procedure TdxBarFlatPainter.EditOffsetInteriorRect(var R: TRect); begin Inc(R.Top, 2); end; procedure TdxBarFlatPainter.DrawSpinEditArrow(const ADrawParams: TdxBarSpinEditDrawParams; AArrowPos: TPoint; AButtonIndex: Integer); var AColor: Integer; begin with ADrawParams do begin if Enabled then begin if IsHighContrastWhite and DrawSelected then AColor := COLOR_BTNFACE else AColor := COLOR_BTNTEXT; end else AColor := COLOR_BTNSHADOW; SpinEditControlDrawArrowByPoints(ADrawParams, AArrowPos, AColor, AButtonIndex); end; end; { TdxBarOffice11Painter } procedure TdxBarOffice11Painter.DrawGlyphAndTextInSubMenu( const ADrawParams: TdxBarButtonLikeControlDrawParams; var R: TRect); var I: Integer; AIconRect: TRect; AIsGlyphEmpty, AOpaque: Boolean; ABrush: HBRUSH; ADC: HDC; begin with ADrawParams do begin ADC := Canvas.Handle; if DrawSelected then begin AOpaque := True; Office11FrameSelectedRect(ADC, R) end else begin AOpaque := False; I := R.Left + 1 + BarItemControl.Parent.IconAreaSize; ABrush := BarItemControl.Parent.BkBrush; DrawBackground(BarItemControl, ADC, Rect(R.Left, R.Top, I, R.Top + 1), ABrush, AOpaque); DrawBackground(BarItemControl, ADC, Rect(R.Left, R.Bottom - 1, I, R.Bottom), ABrush, AOpaque); DrawBackground(BarItemControl, ADC, Rect(R.Left, R.Top + 1, R.Left + 1, R.Bottom - 1), ABrush, AOpaque); ABrush := BarItemControl.Parent.BkBrush; DrawBackground(BarItemControl, ADC, Rect(I, R.Top, R.Right, R.Top + 1), ABrush, AOpaque); DrawBackground(BarItemControl, ADC, Rect(I, R.Bottom - 1, R.Right, R.Bottom), ABrush, AOpaque); DrawBackground(BarItemControl, ADC, Rect(R.Right - 1, R.Top + 1, R.Right, R.Bottom - 1), ABrush, AOpaque); end; InflateRect(R, -1, -1); AIconRect := GetSubMenuItemIconRect(R, BarItemControl.Parent.IconAreaSize - 2); AIsGlyphEmpty := not BarItemControl.HasIcon(ViewSize, ViewStructure); DrawGlyph(BarItemControl, ADC, AIconRect, cxEmptyRect, ptMenu, AIsGlyphEmpty, DrawSelected, Downed, False, False, False, False, False); if DrawSelected then ABrush := BarItemControl.Parent.ToolbarSelBrush else ABrush := BarItemControl.Parent.BkBrush; R.Left := AIconRect.Right + 2; DrawBackground(BarItemControl, ADC, Rect(AIconRect.Right, AIconRect.Top, R.Left, AIconRect.Bottom), ABrush, AOpaque); if AIconRect.Top > R.Top then DrawBackground(BarItemControl, ADC, Rect(AIconRect.Left, R.Top, R.Left, AIconRect.Top), ABrush, AOpaque); if AIconRect.Bottom < R.Bottom then DrawBackground(BarItemControl, ADC, Rect(AIconRect.Left, AIconRect.Bottom, R.Left, R.Bottom), ABrush, AOpaque); if DrawSelected then ABrush := BarItemControl.Parent.ToolbarSelBrush else ABrush := BarItemControl.Parent.BkBrush; DrawBackground(BarItemControl, ADC, R, ABrush, AOpaque); Inc(R.Left, 8); DrawItemTextInSubMenu(ADrawParams, R); end; end; class procedure TdxBarOffice11Painter.FrameAndFillRect(ABarItemControl: TdxBarItemControl; DC: HDC; var R: TRect; Enabled, Selected, Pressed: Boolean); var Brush: HBRUSH; begin if Selected then begin FrameFlatSelRect(DC, R); if Pressed then Brush := ABarItemControl.Parent.ToolbarDownedSelBrush else Brush := ABarItemControl.Parent.ToolbarSelBrush; end else begin if Enabled then begin FrameRect(DC, R, ABarItemControl.Parent.BkBrush); Brush := dxOffice11OwnerControlDownedBrush; end else begin FrameRectByColor(DC, R, dxOffice11TextDisabledColor); Brush := GetSysColorBrush(COLOR_BTNFACE); end; end; InflateRect(R, -1, -1); FillRect(DC, R, Brush); end; class procedure TdxBarOffice11Painter.GetArrowParams( const ADrawParams: TdxBarItemControlDrawParams; out ABrush: HBRUSH; out AArrowColor: COLORREF); begin with ADrawParams do if Enabled then begin AArrowColor := dxOffice11TextEnabledColor; // TODO: XP? if DrawSelected then begin if IsHighContrastWhite then AArrowColor := clWhite else if DroppedDown and not IsXPStandardScheme then AArrowColor := ColorToRGB(clHighlightText); if DroppedDown then ABrush := BarItemControl.Parent.ToolbarDownedSelBrush else ABrush := BarItemControl.Parent.ToolbarSelBrush; end else ABrush := BarItemControl.Parent.BkBrush end else begin AArrowColor := dxOffice11TextDisabledColor; ABrush := GetSysColorBrush(COLOR_BTNFACE); end; end; class function TdxBarOffice11Painter.IsItemTextSelectedInverted: Boolean; begin if IsXPStandardScheme then Result := False else Result := inherited IsItemTextSelectedInverted; end; class function TdxBarOffice11Painter.StaticBorderBrush(ABarItemControl: TdxBarItemControl; ABorderStyle: TdxBarStaticBorderStyle): HBRUSH; begin Result := dxOffice11StaticBorderBrush; end; class function TdxBarOffice11Painter.BeforeFingersSize: Integer; begin Result := inherited BeforeFingersSize + BarBeforeFingersIndent; end; class function TdxBarOffice11Painter.BorderSizeX: Integer; begin Result := 3; end; class function TdxBarOffice11Painter.BorderSizeY: Integer; begin Result := 3; end; class function TdxBarOffice11Painter.EmptyFingersSize: Integer; begin Result := 2; end; class procedure TdxBarOffice11Painter.DockControlFillBackground(ADockControl: TdxDockControl; DC: HDC; ADestR, ASourceR, AWholeR: TRect; ABrush: HBRUSH; AColor: TColor); procedure FillBackgroundTempBitmap(ABitmap: TBitmap); var AColor1, AColor2: TColor; begin with AWholeR do begin ABitmap.Width := Right - Left; ABitmap.Height := Bottom - Top; end; GetDockColors(ADockControl, AColor1, AColor2); FillGradientRect(ABitmap.Canvas.Handle, AWholeR, AColor1, AColor2, True); end; begin if ADockControl.BackgroundTempBitmap.Empty then FillBackgroundTempBitmap(ADockControl.BackgroundTempBitmap); cxBitBlt(DC, ADockControl.BackgroundTempBitmap.Canvas.Handle, ADestR, ASourceR.TopLeft, SRCCOPY); end; class function TdxBarOffice11Painter.IsNativeBackground: Boolean; begin Result := True; end; class function TdxBarOffice11Painter.BarControlOwnerBrush(ABarManager: TdxBarManager): HBRUSH; begin Result := dxOffice11OwnerControlDownedBrush; end; class procedure TdxBarOffice11Painter.BarDrawBarControlOwnerFrame(ACustomBarControl: TCustomdxBarControl; DC: HDC; R: TRect); begin FrameRect(DC, R, dxOffice11DropDownBorderBrush1); end; class procedure TdxBarOffice11Painter.BarDrawBarControlOwnerLink(ACustomBarControl: TCustomdxBarControl; DC: HDC; R, ALinkR: TRect; ABarItemControl: TdxBarItemControl); var AColor: TColor; begin if (ABarItemControl = nil) or not IsMenuGradient(ABarItemControl) then inherited else begin if (ALinkR.Right - ALinkR.Left) > (ALinkR.Bottom - ALinkR.Top) then // Horz begin if ALinkR.Top > ((R.Bottom + R.Top) div 2) then // bottom AColor := dxOffice11MenuDownedColor2 else AColor := dxOffice11MenuDownedColor1; end else begin if ALinkR.Left > ((R.Right + R.Left) div 2) then // right AColor := dxOffice11MenuDownedColor2 else AColor := dxOffice11MenuDownedColor1; end; FillRectByColor(DC, ALinkR, AColor); end; end; procedure TdxBarOffice11Painter.BarDrawDockedBackground(ABarControl: TdxBarControl; DC: HDC; ADestR, ASourceR: TRect; ABrush: HBRUSH; AColor: TColor); var AWholeR: TRect; AClipRgn: HRGN; AClipRgnExists: Boolean; begin if (ABarControl is TdxBarControl) and ((TdxBarControl(ABarControl).Bar.BorderStyle = bbsNone) or ABarControl.IsMainMenu or ABarControl.IsBackgroundBitmap) then inherited else begin SaveClipRgn(DC, AClipRgn, AClipRgnExists); with ADestR do IntersectClipRect(DC, Left, Top, Right, Bottom); AWholeR := GetBarGradientRect(ABarControl); OffsetRect(AWholeR, -(ASourceR.Left - ADestR.Left), -(ASourceR.Top - ADestR.Top)); // NC offset FillTubeGradientRect(DC, AWholeR, dxOffice11ToolbarsColor1, dxOffice11ToolbarsColor2, (ABarControl is TdxBarControl) and TdxBarControl(ABarControl).Vertical); RestoreClipRgn(DC, AClipRgn, AClipRgnExists); end; end; class procedure TdxBarOffice11Painter.BarDrawFloatingBackground(ABarControl: TCustomdxBarControl; DC: HDC; ADestR, ASourceR: TRect; ABrush: HBRUSH; AColor: TColor); var R: TRect; AClipRgn: HRGN; AClipRgnExists: Boolean; begin if ABarControl.IsInternal or ABarControl.IsBackgroundBitmap then inherited else begin R := ABarControl.ClientRect; SaveClipRgn(DC, AClipRgn, AClipRgnExists); with ADestR do IntersectClipRect(DC, Left, Top, Right, Bottom); FillGradientRect(DC, R, dxOffice11ToolbarsColor1, dxOffice11ToolbarsColor2, False); RestoreClipRgn(DC, AClipRgn, AClipRgnExists); end; end; class procedure TdxBarOffice11Painter.BarDrawOwnerLink(ABarControl: TCustomdxBarControl; DC: HDC); var R: TRect; begin R := ABarControl.OwnerLinkBounds[False]; if not IsRectEmpty(R) then FillRect(DC, R, dxOffice11DropDownBorderBrush2); end; class function TdxBarOffice11Painter.BarHasShadow(ABarControl: TCustomdxBarControl): Boolean; begin Result := ABarControl.IsPopup; end; class function TdxBarOffice11Painter.BarToolbarBrush(ABarControl: TCustomdxBarControl): HBRUSH; begin // TODO: ? Result := dxOffice11MenuBrush; end; class function TdxBarOffice11Painter.BarToolbarBrushEx(ABarControl: TdxBarControl): HBRUSH; begin // TODO if not (ABarControl.IsMainMenu or ABarControl.Bar.IsStatusBar) then Result := inherited BarToolbarBrushEx(ABarControl) else Result := GetSysColorBrush(COLOR_BTNFACE); end; class function TdxBarOffice11Painter.BarToolbarDownedBrush(ABarControl: TCustomdxBarControl): HBRUSH; begin Result := dxOffice11DownedBrush; end; class function TdxBarOffice11Painter.BarToolbarDownedSelBrush(ABarControl: TCustomdxBarControl): HBRUSH; begin Result := dxOffice11DownedSelectedBrush; end; class function TdxBarOffice11Painter.BarToolbarSelBrush(ABarControl: TCustomdxBarControl): HBRUSH; begin Result := dxOffice11ToolbarSelectedBrush; end; class function TdxBarOffice11Painter.ComboBoxArrowWidth(ABarControl: TCustomdxBarControl; cX: Integer): Integer; begin Result := 13; end; class function TdxBarOffice11Painter.BarBeforeFingersIndent: Integer; begin Result := 2; end; class procedure TdxBarOffice11Painter.BarBorderPaintSizes(ABarControl: TdxBarControl; var R: TRect); begin BarBorderSizes(ABarControl.Bar, ABarControl.DockingStyle, R); end; class procedure TdxBarOffice11Painter.BarBorderSizes(ABar: TdxBar; AStyle: TdxBarDockingStyle; var R: TRect); begin if ABar.IsMainMenu then // SetRectEmpty(R) begin if AStyle in [dsTop, dsBottom] then R := Rect(0, 2, 0, 2) else R := Rect(2, 0, 2, 0); end else inherited; end; procedure TdxBarOffice11Painter.BarDrawBeginGroup(ABarControl: TCustomdxBarControl; DC: HDC; ABeginGroupRect: TRect; AToolbarBrush: HBRUSH; AHorz: Boolean); begin ABarControl.FillBackground(DC, ABeginGroupRect, AToolbarBrush, clNone, True); with ABeginGroupRect do if AHorz then begin InflateRect(ABeginGroupRect, 0, -BarBeginGroupSideSize); FillRect(DC, Rect(Left + 3, Top, Right - 4, Top + 1), dxOffice11BarSeparatorBrush1); FillRect(DC, Rect(Left + 3 + 1, Top + 1, Right - 4 + 1, Top + 2), dxOffice11BarSeparatorBrush2); end else begin InflateRect(ABeginGroupRect, -BarBeginGroupSideSize, 0); FillRect(DC, Rect(Left, Top + 3, Left + 1, Bottom - 4), dxOffice11BarSeparatorBrush1); FillRect(DC, Rect(Left + 1, Top + 3 + 1, Left + 1 + 1, Bottom - 4 + 1), dxOffice11BarSeparatorBrush2); end; end; class procedure TdxBarOffice11Painter.BarDrawCaptionElement(ABarControl: TdxBarControl; DC: HDC; R: TRect; AState: TdxBarMarkState); var AColor: TColor; begin if AState <> msNone then begin Office11FrameSelectedRect(DC, R); InflateRect(R, -1, -1); if AState = msSelected then AColor := dxOffice11SelectedColor1 else AColor := dxOffice11SelectedColor2; FillRectByColor(DC, R, AColor); end else FillRectByColor(DC, R, ABarControl.CaptionBkColor); end; procedure TdxBarOffice11Painter.BarDrawDockedBarBorder(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); var B1: HBRUSH; AMarkColor1, AMarkColor2, AColor6, AColor9: TColor; procedure DrawFinger(ARect: TRect); begin // TODO: ! // if ABarControl.Bar.NotDocking = [Low(TdxBarDockingStyle)..High(TdxBarDockingStyle)] then Exit; InflateRect(ARect, -2, -2); with ARect do if ABarControl.Horizontal then begin Inc(Left, BeforeFingersSize); Right := Left + GripperSize; InflateRect(ARect, 0, -3); end else begin Inc(Top, BeforeFingersSize); Bottom := Top + GripperSize; InflateRect(ARect, -3, 0); end; BarDrawFingerElements(ABarControl, DC, ARect, ABarControl.Horizontal); end; procedure FillParentBackground(DC: HDC; const R: TRect); begin BarFillParentBackground(ABarControl, DC, R, R, AToolbarBrush, clNone); end; procedure FillBackground(DC: HDC; const R: TRect); begin BarDrawDockedBackground(ABarControl, DC, R, R, AToolbarBrush, clNone); end; procedure DrawLeftBorder(var ARect: TRect); var ADockColor, AC11pxColor, AColor1, AColor2, AColor: TColor; R: TRect; begin GetDockColors(ABarControl.DockControl, AColor1, AColor2); with ARect do begin if ABarControl.Horizontal then begin FillParentBackground(DC, Rect(Left, Top, Left + BarBeforeFingersIndent, Bottom)); Inc(ARect.Left, BarBeforeFingersIndent); FillParentBackground(DC, Rect(Left, Top, Right, Top + 1)); Inc(ARect.Top); // only for Horizontal FillParentBackground(DC, Rect(Left, Bottom - 2, Left + 1, Bottom - 1)); FillParentBackground(DC, Rect(Left + 1, Bottom - 1, Left + 2, Bottom)); // left FillBackground(DC, Rect(Left, Top + 2, Left + 1, Bottom - 3)); // edge pixels SetPixel(DC, Left + 1, Bottom - 3, dxOffice11BarBorderColors[2]); // #3 = (Dock, #2, 50%) ADockColor := GetGradientColorRect(ABarControl.DockControl.ClientRect, ABarControl.PointBarToDock(Point(Left, Top)).X, AColor1, AColor2, True); AColor := GetMiddleRGB(ADockColor, dxOffice11BarBorderColors[2], 50); SetPixel(DC, Left, Bottom - 3, ColorToRGB(AColor)); SetPixel(DC, Left + 1, Bottom - 2, ColorToRGB(AColor)); // #4 = Dock, C1 + 1px ADockColor := GetGradientColorRect(ABarControl.DockControl.ClientRect, ABarControl.PointBarToDock(Point(Left, Top)).X, AColor1, AColor2, True); AC11pxColor := GetGradientColorRect(GetBarGradientRect(ABarControl), Top + 1, dxOffice11ToolbarsColor1, dxOffice11ToolbarsColor2, False); AColor := GetMiddleRGB(ADockColor, AC11pxColor, 50); SetPixel(DC, Left, Top + 1, AColor); SetPixel(DC, Left + 1, Top, AColor); end else begin FillParentBackground(DC, Rect(Left, Top, Right, Top + BarBeforeFingersIndent)); Inc(ARect.Top, BarBeforeFingersIndent); FillParentBackground(DC, Rect(Left, Top, Left + 1, Bottom)); Inc(ARect.Left); R := Rect(Left, Top + 2, Left + 1, Bottom - 2); if ABarControl.MarkExists then Dec(R.Bottom, MarkSizeX); FillBackground(DC, R); FillBackground(DC, Rect(Left + 2, Top, Right - 2, Top + 1)); // edge pixels SetPixel(DC, Right - 2, Top + 1, dxOffice11BarBorderColors[2]); // #3 = (Dock, #2, 50%) ADockColor := GetGradientColorRect(ABarControl.DockControl.ClientRect, ABarControl.PointBarToDock(Point(Left, Top)).X, AColor1, AColor2, True); AColor := GetMiddleRGB(ADockColor, dxOffice11BarBorderColors[2], 50); SetPixel(DC, Right - 2, Top, ColorToRGB(AColor)); SetPixel(DC, Right - 1, Top + 1, ColorToRGB(AColor)); // #4 = Dock, C1 + 1px ADockColor := GetGradientColorRect(ABarControl.DockControl.ClientRect, ABarControl.PointBarToDock(Point(Left, Top)).X, AColor1, AColor2, True); AC11pxColor := GetGradientColorRect(GetBarGradientRect(ABarControl), Left, dxOffice11ToolbarsColor1, dxOffice11ToolbarsColor2, True); AColor := GetMiddleRGB(ADockColor, AC11pxColor, 50); SetPixel(DC, Left, Top + 1, AColor); SetPixel(DC, Left + 1, Top, AColor); end; end; end; procedure DrawTopBorder(ARect: TRect); var ADockColor, AC11pxColor, AColor1, AColor2, AColor: TColor; R: TRect; begin GetDockColors(ABarControl.DockControl, AColor1, AColor2); with ARect do begin if ABarControl.Horizontal then begin R := Rect(Left + 2, Top, Right - 2, Top + 1); if ABarControl.MarkExists then Dec(R.Right, MarkSizeX); FillBackground(DC, R); ADockColor := GetGradientColorRect(ABarControl.DockControl.ClientRect, ABarControl.PointBarToDock(Point(Right, Top)).X, AColor1, AColor2, True); if ABarControl.MarkExists then begin // #6 SetPixel(DC, Right - MarkSizeX - 1, Top, AColor6); SetPixel(DC, Right - 2, Top + 1, AColor6); // #5 = #6, C1+1px AC11pxColor := GetGradientColorRect(GetBarGradientRect(ABarControl), Top + 1, dxOffice11ToolbarsColor1, dxOffice11ToolbarsColor2, False); AColor := GetMiddleRGB(AColor6, AC11pxColor, 50); SetPixel(DC, Right - MarkSizeX - 2, Top, AColor); // #7 = #6, Dock AColor := GetMiddleRGB(AColor6, ADockColor, 50); SetPixel(DC, Right - 2, Top, AColor); SetPixel(DC, Right - 1, Top + 1, AColor); end else begin // #5 = Dock, C1 + 1px AC11pxColor := GetGradientColorRect(GetBarGradientRect(ABarControl), Top + 1, dxOffice11ToolbarsColor1, dxOffice11ToolbarsColor2, False); AColor := GetMiddleRGB(ADockColor, AC11pxColor, 50); SetPixel(DC, Right - 2, Top, AColor); SetPixel(DC, Right - 1, Top + 1, AColor); end; end else begin ADockColor := GetGradientColorRect(ABarControl.DockControl.ClientRect, ABarControl.PointBarToDock(Point(Left, Bottom)).X, AColor1, AColor2, True); if ABarControl.MarkExists then begin // #5 = #6, C1+1px AC11pxColor := GetGradientColorRect(GetBarGradientRect(ABarControl), Left + 1, dxOffice11ToolbarsColor1, dxOffice11ToolbarsColor2, True); AColor := GetMiddleRGB(AColor6, AC11pxColor, 50); SetPixel(DC, Left, Bottom - MarkSizeX - 2, AColor); // #6 SetPixel(DC, Left, Bottom - MarkSizeX - 1, AColor6); SetPixel(DC, Left + 1, Bottom - 2, AColor6); // #7 = #6, Dock AColor := GetMiddleRGB(AColor6, ADockColor, 50); SetPixel(DC, Left, Bottom - 2, AColor); SetPixel(DC, Left + 1, Bottom - 1, AColor); end else begin // #5 = Dock, C1 + 1px AC11pxColor := GetGradientColorRect(GetBarGradientRect(ABarControl), Left + 1, dxOffice11ToolbarsColor1, dxOffice11ToolbarsColor2, True); AColor := GetMiddleRGB(ADockColor, AC11pxColor, 50); SetPixel(DC, Left, Bottom - 2, AColor); SetPixel(DC, Left + 1, Bottom - 1, AColor); end; end; end; end; procedure DrawRightBorder(ARect: TRect); var R: TRect; AClipRgn: HRGN; AClipRgnExists: Boolean; ADockColor, AColor1, AColor2, AColor: TColor; begin with ARect do begin if ABarControl.Horizontal then begin if not ABarControl.MarkExists then begin R := Rect(Right - 2, Top + 1, Right - 1, Bottom - 2); FillBackground(DC, R); end; end else begin R := Rect(Right - 2, Top + 2, Right - 1, Bottom - 2); if ABarControl.MarkExists then Dec(R.Bottom, MarkSizeX); FillBackground(DC, R); end; if ABarControl.MarkExists then begin SaveClipRgn(DC, AClipRgn, AClipRgnExists); if ABarControl.Horizontal then begin IntersectClipRect(DC, Right - MarkSizeX - 2 + 2, Top, Right - 2, Top + 1); AddClipRect(DC, Rect(Right - 2, Top + 2, Right, Bottom - 2)); AddClipRect(DC, Rect(Right - MarkSizeX - 1, Bottom - 1, Right - 2, Bottom)); AddClipRect(DC, Rect(Right - MarkSizeX, Bottom - 2, Right - 1, Bottom - 1)); R := Rect(Right - MarkSizeX - 1, Top, Right, Bottom); end else begin IntersectClipRect(DC, Left, Bottom - MarkSizeX, Left + 1, Bottom - 2); AddClipRect(DC, Rect(Left + 2, Bottom - 2, Right - 2, Bottom)); AddClipRect(DC, Rect(Right - 2, Bottom - MarkSizeX, Right - 1, Bottom - 1)); AddClipRect(DC, Rect(Right - 1, Bottom - MarkSizeX - 1, Right, Bottom - 2)); R := Rect(Left, Bottom - MarkSizeX - 1, Right, Bottom); end; FillTubeGradientRect(DC, R, AMarkColor1, AMarkColor2, not ABarControl.Horizontal); RestoreClipRgn(DC, AClipRgn, AClipRgnExists); // #8 = B, Dock GetDockColors(ABarControl.DockControl, AColor1, AColor2); ADockColor := GetGradientColorRect(ABarControl.DockControl.ClientRect, ABarControl.PointBarToDock(Point(Right, Bottom)).X, AColor1, AColor2, True); AColor := GetMiddleRGB(AMarkColor2, ADockColor, 50); SetPixel(DC, Right - 1, Bottom - 2, AColor); SetPixel(DC, Right - 2, Bottom - 1, AColor); end else begin if ABarControl.Horizontal then FillBackground(DC, Rect(Right - 1, Top + 2, Right, Bottom - 1)) else FillBackground(DC, Rect(Left + 2, Bottom - 1, Right - 1, Bottom)); end; end; end; procedure DrawBottomBorder(ARect: TRect); var ADockColor, AColor1, AColor2, AColor: TColor; R: TRect; begin with ARect do begin if ABarControl.Horizontal then begin R := Rect(Left + 2, Bottom - 2, Right - 2, Bottom - 1); if ABarControl.MarkExists then Dec(R.Right, MarkSizeX); FillBackground(DC, R); end else begin if not ABarControl.MarkExists then begin R := Rect(Left + 1, Bottom - 2, Right - 2, Bottom - 1); FillBackground(DC, R); end; end; if ABarControl.MarkExists then begin // #9 = B, #2 AColor := GetMiddleRGB(AMarkColor2, dxOffice11BarBorderColors[2], 50); if ABarControl.Horizontal then begin SetPixel(DC, Right - 2 - MarkSizeX, Bottom - 1, AColor); SetPixel(DC, Right - 1 - MarkSizeX, Bottom - 2, AColor); SetPixel(DC, Right - 2 - MarkSizeX, Bottom - 2, dxOffice11BarBorderColors[2]); FillRect(DC, Rect(Left + 2, Bottom - 1, Right - 2 - MarkSizeX, Bottom), B1); end else begin SetPixel(DC, Right - 2, Bottom - 1 - MarkSizeX, AColor); SetPixel(DC, Right - 1, Bottom - 2 - MarkSizeX, AColor); SetPixel(DC, Right - 2, Bottom - 2 - MarkSizeX, dxOffice11BarBorderColors[2]); FillRect(DC, Rect(Right - 1, Top + 2, Right, Bottom - MarkSizeX - 2), B1); end; end else begin // #9 = Dock, #2 GetDockColors(ABarControl.DockControl, AColor1, AColor2); ADockColor := GetGradientColorRect(ABarControl.DockControl.ClientRect, ABarControl.PointBarToDock(Point(Right, Bottom)).X, AColor1, AColor2, True); AColor := GetMiddleRGB(dxOffice11BarBorderColors[2], ADockColor, 50); SetPixel(DC, Right - 2, Bottom - 1, AColor); SetPixel(DC, Right - 1, Bottom - 2, AColor); SetPixel(DC, Right - 2, Bottom - 2, dxOffice11BarBorderColors[2]); if ABarControl.Horizontal then FillRect(DC, Rect(Left + 2, Bottom - 1, Right - 2, Bottom), B1) else FillRect(DC, Rect(Right - 1, Top + 2, Right, Bottom - 2), B1); end; end; end; procedure DrawBorder(ARect: TRect); begin DrawLeftBorder(ARect); DrawTopBorder(ARect); DrawRightBorder(ARect); DrawBottomBorder(ARect); with ARect do begin FillParentBackground(DC, Rect(Left, Top, Left + 1, Top + 1)); FillParentBackground(DC, Rect(Right - 1, Top, Right, Top + 1)); FillParentBackground(DC, Rect(Left, Bottom - 1, Left + 1, Bottom)); FillParentBackground(DC, Rect(Right - 1, Bottom - 1, Right, Bottom)); end; end; procedure DrawMainMenuBorder(ARect: TRect); begin with ARect do if ABarControl.Horizontal then begin FillParentBackground(DC, Rect(Left, Top, Right, Top + 2)); FillParentBackground(DC, Rect(Left, Bottom - 2, Right, Bottom)); end else begin FillParentBackground(DC, Rect(Left, Top, Left + 2, Bottom)); FillParentBackground(DC, Rect(Right - 2, Top, Right, Bottom)); end; end; begin B1 := CreateSolidBrush(dxOffice11BarBorderColors[1]); GetMarkColors(ABarControl, AMarkColor1, AMarkColor2, AColor6, AColor9); if ABarControl.IsMainMenu then DrawMainMenuBorder(R) else if ABarControl.Bar.BorderStyle = bbsSingle then DrawBorder(R); if ABarControl.CanMoving then DrawFinger(R); DeleteObject(B1); end; class procedure TdxBarOffice11Painter.BarDrawFloatingBarBorder(ABarControl: TdxBarControl; DC: HDC; var R, CR: TRect; AToolbarBrush: HBRUSH); var I: Integer; B1, B2: HBRUSH; begin if not ABarControl.IsInternal then begin B1 := CreateSolidBrush(dxOffice11BarFloatingBorderColor1); B2 := CreateSolidBrush(dxOffice11BarFloatingBorderColor2); FrameRect(DC, R, B1); InflateRect(R, -1, -1); FrameRect(DC, R, B1); InflateRect(R, -1, -1); FrameRect(DC, R, B2); with R do begin FillRect(DC, Rect(Left, Top, Left + 1, Top + 1), B1); FillRect(DC, Rect(Right - 1, Top, Right, Top + 1), B1); FillRect(DC, Rect(Right - 1, Bottom - 1, Right, Bottom), B1); FillRect(DC, Rect(Left, Bottom - 1, Left + 1, Bottom), B1); end; DeleteObject(B2); DeleteObject(B1); end else begin FrameRect(DC, R, dxOffice11DropDownBorderBrush1); for I := R.Left + 1 to CR.Left - 1 do begin InflateRect(R, -1, -1); FrameRect(DC, R, AToolbarBrush); end; end; end; class procedure TdxBarOffice11Painter.BarDrawFloatingBarCaption(ABarControl: TdxBarControl; DC: HDC; var R, CR: TRect; AToolbarBrush: HBRUSH); begin AToolbarBrush := CreateSolidBrush(dxOffice11BarFloatingBorderColor3); TdxBarFlatPainter.BarDrawFloatingBarCaption(ABarControl, DC, R, CR, AToolbarBrush); DeleteObject(AToolbarBrush); end; class procedure TdxBarOffice11Painter.BarDrawStatusBarGrip(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); begin if not ABarControl.BarManager.FThemeAvailable then inherited else TdxBarXPPainter.BarDrawStatusBarGrip(ABarControl, DC, R, AToolbarBrush); end; class procedure TdxBarOffice11Painter.BarDrawStatusBarTopBorder(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); begin if not ABarControl.BarManager.FThemeAvailable then inherited else TdxBarXPPainter.BarDrawStatusBarTopBorder(ABarControl, DC, R, AToolbarBrush); end; function TdxBarOffice11Painter.BarMarkRect(ABarControl: TdxBarControl): TRect; begin Result := inherited BarMarkRect(ABarControl); if not IsSimpleMark(ABarControl) then case ABarControl.DockingStyle of dsTop, dsBottom: begin Dec(Result.Top, 1); Inc(Result.Right, 2); Inc(Result.Bottom, 1); end; dsLeft, dsRight: begin Dec(Result.Left, 1); Inc(Result.Right, 1); Inc(Result.Bottom, 2); end; end; end; procedure TdxBarOffice11Painter.BarMarkRectInvalidate(ABarControl: TdxBarControl); begin inherited; if ABarControl.DockingStyle <> dsNone then SendMessage(ABarControl.Handle, WM_NCPAINT, 0, 0); end; class procedure TdxBarOffice11Painter.StatusBarFillBackground(ABarControl: TdxBarControl; DC: HDC; ADestR, ASourceR, AWholeR: TRect; ABrush: HBRUSH; AColor: TColor); begin if not ABarControl.BarManager.FThemeAvailable then inherited else TdxBarXPPainter.StatusBarFillBackground(ABarControl, DC, ADestR, ASourceR, AWholeR, ABrush, AColor); end; class function TdxBarOffice11Painter.StatusBarGripSize(ABarManager: TdxBarManager): TSize; begin if not ABarManager.FThemeAvailable then Result := inherited StatusBarGripSize(ABarManager) else Result := TdxBarXPPainter.StatusBarGripSize(ABarManager); end; class function TdxBarOffice11Painter.StatusBarTopBorderSize(ABarManager: TdxBarManager): Integer; begin if not ABarManager.FThemeAvailable then Result := inherited StatusBarTopBorderSize(ABarManager) else Result := TdxBarXPPainter.StatusBarTopBorderSize(ABarManager); end; class function TdxBarOffice11Painter.IsSingleMenuBorder(ABarSubMenuControl: TdxBarSubMenuControl): Boolean; begin Result := not ABarSubMenuControl.GetBackgroundBitmap.Empty or (ABarSubMenuControl.BarSize <> 0); end; class procedure TdxBarOffice11Painter.SubMenuControlCalcDrawingConsts(ACanvas: TcxCanvas; ATextSize: Integer; out AMenuArrowWidth, AMarkSize: Integer); begin inherited; AMarkSize := dxOffice11SubMenuExpandBitmap.Height + SubMenuControlClientBorderSize * 2; // AMarkSize := ACanvas.TextHeight('0') + 5; // to scale end; procedure TdxBarOffice11Painter.SubMenuControlDrawBackground(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; ARect: TRect; ABrush: HBRUSH; AColor: TColor); var W1: Integer; W2: Integer; AColor1, AColor2: TColor; begin if not ABarSubMenuControl.GetBackgroundBitmap.Empty then inherited else begin W1 := ABarSubMenuControl.GetIndent1; W2 := ABarSubMenuControl.GetIndent2; ACanvas.SaveClipRegion; try ACanvas.SetClipRegion(TcxRegion.Create(ARect), roIntersect); with ARect do begin // fill if ABarSubMenuControl.FNonRecent then begin AColor1 := dxOffice11MenuNonRecentIndentColor1; AColor2 := dxOffice11MenuNonRecentIndentColor2; end else begin AColor1 := dxOffice11MenuIndentColor1; AColor2 := dxOffice11MenuIndentColor2; end; FillTubeGradientRect(ACanvas.Handle, Rect(0, Top, W1, Bottom), AColor1, AColor2, True); if W2 <> 0 then FillRectByColor(ACanvas.Handle, Rect(W1, Top, W1 + W2, Bottom), AColor2); if Right > (W1 + W2) then FillRect(ACanvas.Handle, Rect(W1 + W2, Top, Right, Bottom), ABrush); end; finally ACanvas.RestoreClipRegion; end; end; end; class procedure TdxBarOffice11Painter.SubMenuControlDrawClientBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; const R: TRect; ABrush: HBRUSH); begin if IsSingleMenuBorder(ABarSubMenuControl) then FrameRect(DC, R, dxOffice11MenuBrush) else with R do begin FillRect(DC, Rect(Left, Top, Right, Top + 1), dxOffice11MenuBrush); FillRect(DC, Rect(Right - 1, Top, Right, Bottom), dxOffice11MenuBrush); FillRect(DC, Rect(Left, Bottom - 1, Right, Bottom), dxOffice11MenuBrush); // Indent FillRectByColor(DC, Rect(Left, Top + 1, Left + 1, Bottom - 1), dxOffice11MenuIndentColor1); end; end; class function TdxBarOffice11Painter.SubMenuControlDetachCaptionAreaSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; begin Result := ABarSubMenuControl.DetachCaptionSize + 5; end; procedure TdxBarOffice11Painter.SubMenuControlDrawBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); procedure DrawFlatBorder; var ARect: TRect; begin FrameRect(DC, R, dxOffice11DropDownBorderBrush1); ARect := ABarSubMenuControl.OwnerLinkBounds[False]; if not IsRectEmpty(ARect) then FillRect(DC, ARect, dxOffice11MenuBrush); end; begin with R do begin DrawFlatBorder; if ABarSubMenuControl.Detachable then begin InflateRect(R, -1, -1); Bottom := Top + ABarSubMenuControl.DetachCaptionSize + 3 + 2; FrameRect(DC, R, dxOffice11MenuBrush); InflateRect(R, 0, -1); FillRect(DC, Rect(Left, Top, Right, Top + 2), dxOffice11MenuBrush); FillRect(DC, Rect(Left, Bottom - 1, Right, Bottom), dxOffice11MenuBrush); SubMenuControlDrawDetachCaption(ABarSubMenuControl, DC, ABarSubMenuControl.DetachCaptionRect); end; end end; procedure TdxBarOffice11Painter.SubMenuControlDrawDetachCaption(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); var ABrush: HBRUSH; DXY: Integer; begin if ABarSubMenuControl.DetachCaptionSelected then begin Office11FrameSelectedRect(DC, R); InflateRect(R, -1, -1); ABrush := dxOffice11DetachableSelectedBrush; DXY := 0; end else begin ABrush := dxOffice11DetachableBrush; DXY := 1; end; FillRect(DC, R, ABrush); // draw marks InflateRect(R, -(((R.Right - R.Left + DXY * 2) div 4)), -(DXY + 1)); BarDrawFingerElements(ABarSubMenuControl, DC, R, False); end; class function TdxBarOffice11Painter.SubMenuControlGetSeparatorColor: TColor; begin Result := dxOffice11BarSeparatorColor1; end; class procedure TdxBarOffice11Painter.SubMenuControlOffsetDetachCaptionRect(ABarSubMenuControl: TdxBarSubMenuControl; var R: TRect); begin InflateRect(R, -2, -4); end; class function TdxBarOffice11Painter.SubMenuControlToolbarItemsBrush(ABarSubMenuControl: TdxBarSubMenuControl): HBRUSH; begin Result := dxOffice11MenuBrush; end; procedure TdxBarOffice11Painter.DropDownListBoxDrawBorder(DC: HDC; AColor: TColor; ARect: TRect); begin FrameRect(DC, ARect, dxOffice11DropDownBorderBrush1); InflateRect(ARect, -1, -1); FrameRect(DC, ARect, dxOffice11DropDownBorderBrush2); end; class function TdxBarOffice11Painter.BarToolbarBrushEx2(ABarControl: TdxBarControl): HBRUSH; begin Result := dxOffice11MenuBrush; end; class procedure TdxBarOffice11Painter.DrawQuickCustItemFrameSelected(ABarItemControl: TdxBarItemControl; DC: HDC; WholeR, R: TRect; Selected: Boolean); begin if Selected then begin Office11FrameSelectedRect(DC, WholeR); with R do begin Left := Right; Right := Left + 2; // paint over! end; FillRect(DC, R, ABarItemControl.Parent.ToolbarSelBrush); end; end; procedure TdxBarOffice11Painter.EditButtonDrawBackground(const ADrawParams: TdxBarEditLikeControlDrawParams; AState: Integer; ARect: TRect; ABrush: HBrush); begin if ADrawParams.PaintType = ptMenu then FillRect(ADrawParams.Canvas.Handle, ARect, dxOffice11OwnerControlDownedBrush) else DrawBackground(ADrawParams.BarItemControl, ADrawParams.Canvas.Handle, ARect, ABrush, ADrawParams.BarItemControl.NonRecent); end; class function TdxBarOffice11Painter.EditButtonIsCustomBackground(AState: Integer): Boolean; begin Result := AState in [DXBAR_NORMAL, DXBAR_ACTIVE]; end; class function TdxBarOffice11Painter.EditControlBorderOffsets: TRect; begin Result := Rect(1, 1, 1, 1); end; procedure TdxBarOffice11Painter.EditControlDrawBorder( const ADrawParams: TdxBarEditLikeControlDrawParams; var ARect: TRect); begin with ADrawParams do begin if DrawSelected then Office11FrameSelectedRect(Canvas.Handle, ARect) else if not Enabled and not IsTransparent then FrameRectByColor(Canvas.Handle, ARect, dxOffice11TextDisabledColor) else if (PaintType = ptMenu) and not IsTransparent then FrameRect(Canvas.Handle, ARect, dxOffice11OwnerControlDownedBrush) else DrawBackgroundFrameRect(BarEditControl, Canvas.Handle, ARect, BarEditControl.Parent.BkBrush, False); InflateRect(ARect, -1, -1); end; end; class function TdxBarOffice11Painter.EditControlCaptionBackgroundIsOpaque( const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; begin Result := (ADrawParams.PaintType = ptMenu) and ADrawParams.DrawSelected; end; class function TdxBarOffice11Painter.EditControlCaptionLeftIndent( const ADrawParams: TdxBarEditLikeControlDrawParams): Integer; begin if ADrawParams.PaintType = ptMenu then Result := GetSubMenuItemTextIndent(ADrawParams) else Result := ADrawParams.BarItemControl.GetControlCaptionOffset; end; class function TdxBarOffice11Painter.EditControlCaptionRightIndentIsOpaque( const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; begin Result := (ADrawParams.PaintType = ptMenu) and ADrawParams.DrawSelected; end; class function TdxBarOffice11Painter.EditControlShowIconDefault( const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; begin Result := ADrawParams.PaintType = ptMenu; end; class function TdxBarOffice11Painter.EditControlSubmenuGlyphIndents(const ADrawParams: TdxBarEditLikeControlDrawParams): TRect; begin Result := cxEmptyRect; Result.Left := ADrawParams.BarItemControl.SubMenuParent.GetIconAreaSize - ADrawParams.BarItemControl.GetGlyphSize(ADrawParams.ViewSize).cx; end; class procedure TdxBarOffice11Painter.ComboControlDrawSimpleButton( ABarComboControl: TdxBarItemControl; ADC: HDC; var ARect: TRect; ADroppedDown, ASelected: Boolean; ABrush: HBRUSH; APaintType: TdxBarPaintType); var AColor1, AColor2: TColor; ASpaceBrush: HBRUSH; begin if ASelected then begin InflateRect(ARect, 1, 1); Office11FrameSelectedRect(ADC, ARect); InflateRect(ARect, -1, -1); GetSelectedColors(ABarComboControl, ADroppedDown, ASelected, AColor1, AColor2); FillGradientRect(ADC, ARect, AColor1, AColor2, False); InflateRect(ARect, -1, -1); end else begin if ABarComboControl.Enabled then ASpaceBrush := TCustomdxBarComboControl(ABarComboControl).EditBkBrush else ASpaceBrush := ABrush; FrameRect(ADC, ARect, ASpaceBrush); FillRect(ADC, Rect(ARect.Left - 1, ARect.Top, ARect.Left, ARect.Bottom), ASpaceBrush); InflateRect(ARect, -1, -1); if (APaintType = ptMenu) and ABarComboControl.Enabled then FillRect(ADC, ARect, dxOffice11OwnerControlDownedBrush) else DrawBackground(ABarComboControl, ADC, ARect, ABrush, not ABarComboControl.Enabled); if ADroppedDown then OffsetRect(ARect, 1, 1); end; end; class procedure TdxBarOffice11Painter.ComboControlGetArrowParams( const ADrawParams: TdxBarEditLikeControlDrawParams; out ABrush: HBRUSH; out AArrowColor: COLORREF); begin GetArrowParams(ADrawParams, ABrush, AArrowColor); with ADrawParams do if Enabled then begin if DrawSelected then ABrush := BarItemControl.Parent.ToolbarSelBrush else if DroppedDown then ABrush := BarItemControl.Parent.ToolbarDownedSelBrush; end; end; class function TdxBarOffice11Painter.ProgressControlIndent(const ADrawParams: TdxBarItemControlDrawParams): Integer; begin Result := 0; if not (cpIcon in ADrawParams.ViewStructure) and (ADrawParams.PaintType = ptMenu) then Inc(Result, TdxBarSubMenuControl(ADrawParams.BarItemControl.Parent).GetIndent1); end; class procedure TdxBarOffice11Painter.DateNavigatorDrawButton(ABarItem: TdxBarItem; DC: HDC; R: TRect; const ACaption: string; APressed: Boolean); begin if not ABarItem.BarManager.FThemeAvailable then inherited else TdxBarXPPainter.DateNavigatorDrawButton(ABarItem, DC, R, ACaption, APressed); end; function TdxBarOffice11Painter.DateNavigatorHeaderColor: TColor; begin Result := dxOffice11DateHeaderColor; end; class function TdxBarOffice11Painter.InPlaceSubItemControlBrush: HBRUSH; begin Result := dxOffice11InPlaceSubItemBrush; end; function TdxBarOffice11Painter.EditGetDisabledBkColor(ABarItemControl: TdxBarCustomEditControl): COLORREF; begin Result := GetSysColor(COLOR_BTNFACE); end; function TdxBarOffice11Painter.EditGetEnabledTextColor: COLORREF; begin Result := dxOffice11TextEnabledColor; end; function TdxBarOffice11Painter.EditGetDisabledTextColor: COLORREF; begin Result := dxOffice11TextDisabledColor; end; procedure TdxBarOffice11Painter.DrawSeparatorGlyphAndCaption(const ADrawParams: TdxBarSeparatorControlDrawParams; const ARect: TRect); var APrevBrush: HBRUSH; begin APrevBrush := ADrawParams.BarItemControl.FBkBrush; ADrawParams.BarItemControl.FBkBrush := CreateSolidBrush(dxOffice11MenuIndentColor2); inherited; DeleteGDIObject(ADrawParams.BarItemControl.FBkBrush); ADrawParams.BarItemControl.FBkBrush := APrevBrush; end; class procedure TdxBarOffice11Painter.DrawGlyphBorder(ABarItemControl: TdxBarItemControl; DC: HDC; ABrush: HBRUSH; NeedBorder: Boolean; R: TRect; PaintType: TdxBarPaintType; IsGlyphEmpty, Selected, Down, DrawDowned, ADroppedDown, IsSplit: Boolean); var AOpaque, AVertical: Boolean; AColor1, AColor2: TColor; begin if (PaintType = ptMenu) and Selected and IsGlyphEmpty and not Down or ABarItemControl.IsBkColorAssigned then FillRect(DC, R, ABrush) else begin AOpaque := Selected or Down or DrawDowned; AVertical := ABarItemControl.Parent.IsRealVertical; if ADroppedDown and IsMenuGradient(ABarItemControl) and not Down then FillGradientRect(DC, R, dxOffice11MenuDownedColor1, dxOffice11MenuDownedColor2, AVertical) else begin if (PaintType <> ptMenu) and (Selected or Down or DrawDowned) then begin GetSelectedColors(ABarItemControl, Down or DrawDowned, Selected, AColor1, AColor2); FillGradientRect(DC, R, AColor1, AColor2, AVertical); end else DrawBackground(ABarItemControl, DC, R, ABrush, AOpaque); end; if Down or (Selected and (PaintType <> ptMenu)) or ADroppedDown then begin if ADroppedDown then BarDrawBarControlOwnerBorder(ABarItemControl.Parent, DC, R, ABarItemControl, ABarItemControl.OwnedBarControl) else if Selected or (Down and (ABarItemControl is TdxBarButtonControl) and TdxBarButtonControl(ABarItemControl).Down) then Office11FrameSelectedRect(DC, R) else FrameRect(DC, R, dxOffice11SelectedBorderBrush); end else if NeedBorder then DrawBackgroundFrameRect(ABarItemControl, DC, R, ABrush, AOpaque); end; end; class procedure TdxBarOffice11Painter.DrawGlyphImage(ABarItemControl: TdxBarItemControl; DC: HDC; ABrush: HBRUSH; NeedBorder: Boolean; R: TRect; const GlyphRect: TRect; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; Selected, Down, DrawDowned, ForceUseBkBrush, GrayScale, BarControlOwner: Boolean; PaintType: TdxBarPaintType); begin if NeedBorder then InflateRect(R, -1, -1); TransparentDraw(ABarItemControl, DC, 0, R, GlyphRect, AGlyph, AImages, AImageIndex, ABarItemControl.BarManager.ImageListBkColor, ABarItemControl.GetImageEnabled(PaintType), GrayScale, False{Flat}, Selected, Down, DrawDowned, False{Shadow}, GetFaded(ABarItemControl.Parent){Faded}, ABarItemControl.BarManager.ImageOptions.SmoothGlyphs, ABarItemControl.BarManager.ImageOptions.UseLeftBottomPixelAsTransparent); if NeedBorder then InflateRect(R, 1, 1); end; class procedure TdxBarOffice11Painter.DrawItemArrow(DC: HDC; R: TRect; ArrowType: TcxArrowDirection; Enabled, Selected, Flat: Boolean); begin Office11DrawItemArrow(DC, R, ArrowType = adDown, Enabled, Selected, Flat); end; procedure TdxBarOffice11Painter.DrawLargeItemArrow(DC: HDC; R: TRect; ArrowType: TcxArrowDirection; Size: Integer; Selected, Enabled, Flat: Boolean); begin Office11DrawLargeItemArrow(DC, R, ArrowType = adDown, Size, Selected, Enabled, Flat); end; class procedure TdxBarOffice11Painter.DrawFrameRect(ABarItemControl: TdxBarItemControl; ADC: HDC; const ARect: TRect; ABrush: HBRUSH; APaintType: TdxBarPaintType; ASelected, ADowned: Boolean); begin if (APaintType = ptMenu) or ASelected or ADowned then if (APaintType = ptMenu) and not ASelected then FrameRect(ADC, ARect, dxOffice11BarSeparatorBrush1) else Office11FrameSelectedRect(ADC, ARect) else DrawBackgroundFrameRect(ABarItemControl, ADC, ARect, ABrush, False); end; class procedure TdxBarOffice11Painter.FrameFlatSelRect(DC: HDC; const R: TRect); begin Office11FrameSelectedRect(DC, R); end; class function TdxBarOffice11Painter.GetBarGradientRect(ABarControl: TCustomdxBarControl): TRect; begin Result := Rect(0, 0, ABarControl.Width, ABarControl.Height); if ABarControl is TdxBarControl then begin if TdxBarControl(ABarControl).Horizontal then InflateRect(Result, 0, -1) else InflateRect(Result, -1, 0); end; end; class procedure TdxBarOffice11Painter.GetDockColors(ADockControl: TdxDockControl; var AColor1, AColor2: TColor); begin AColor1 := dxOffice11DockColor1; AColor2 := dxOffice11DockColor2; if ADockControl.Align = alLeft then AColor2 := AColor1 else if ADockControl.Align = alRight then AColor1 := AColor2; end; class procedure TdxBarOffice11Painter.GetMarkColors(ABarControl: TdxBarControl; var AMarkColor1, AMarkColor2, AColor6, AColor9: TColor); var I: Integer; begin I := Integer(ABarControl.MarkDrawState) + 1; AMarkColor1 := dxOffice11BarMarkColors1[I]; AMarkColor2 := dxOffice11BarMarkColors2[I]; AColor6 := dxOffice11BarBorderMarkColors[1, I]; AColor9 := dxOffice11BarBorderMarkColors[2, I]; end; class procedure TdxBarOffice11Painter.GetSelectedColors(ABarItemControl: TdxBarItemControl; ADown, ASelected: Boolean; var AColor1, AColor2: TColor); begin //#DG if ABarItemControl.Parent.NeedShowGlyphAndCheckForItem then - ??? if ABarItemControl.Parent.IsInternal then begin if ADown then AColor1 := dxOffice11OwnerControlDownedColor else AColor1 := dxOffice11SelectedColor1; AColor2 := AColor1; end else begin if ADown then begin if not ASelected then begin AColor1 := dxOffice11SelectedDownColor1; AColor2 := dxOffice11SelectedDownColor2; if AColor1 = AColor2 then begin AColor1 := dxOffice11DownedColor; //dxOffice11SelectedColor1; AColor2 := AColor1; end; end else begin AColor1 := dxOffice11SelectedDownColor2; AColor2 := dxOffice11SelectedDownColor1; end; end else begin AColor1 := dxOffice11SelectedColor1; AColor2 := dxOffice11SelectedColor2; end; end; end; class function TdxBarOffice11Painter.GetToolbarBrush(ABarItemControl: TdxBarItemControl): HBRUSH; begin Result := ABarItemControl.Parent.ToolbarBrush; end; function TdxBarOffice11Painter.GetDefaultEnabledTextColor( ABarItemControl: TdxBarItemControl; ASelected, AFlat: Boolean): TColor; begin if (ABarItemControl.IsInvertTextColor or True) and ASelected and not AFlat then begin Result := dxOffice11InPlaceSubItemTextColor; // GetSysColor(COLOR_HIGHLIGHTTEXT) if IsHighContrastWhite then Result := clWhite; end else Result := dxOffice11TextEnabledColor; end; procedure TdxBarOffice11Painter.GetDisabledTextColors( ABarItemControl: TdxBarItemControl; ASelected, AFlat: Boolean; var AColor1, AColor2: TColor); begin AColor1 := dxOffice11TextDisabledColor; AColor2 := AColor1; end; class function TdxBarOffice11Painter.GetFaded(ABarControl: TCustomdxBarControl): Boolean; begin Result := True; end; class function TdxBarOffice11Painter.IgnoreNonRecentColor: Boolean; begin Result := True; end; class function TdxBarOffice11Painter.IsMenuGradient(ABarItemControl: TdxBarItemControl): Boolean; begin Result := not ABarItemControl.Parent.NeedShowGlyphAndCheckForItem and ((ABarItemControl is TdxBarSubItemControl) or ((ABarItemControl is TdxBarButtonControl) and TdxBarButtonControl(ABarItemControl).DroppedDownFlat)); end; class function TdxBarOffice11Painter.IsSimpleMark(ABarControl: TdxBarControl): Boolean; begin Result := (ABarControl.Bar.BorderStyle = bbsNone) or ABarControl.IsMainMenu; end; class function TdxBarOffice11Painter.BarCaptionBkColor(ABarControl: TdxBarControl; AMainFormActive: Boolean): COLORREF; begin Result := dxOffice11BarFloatingCaptionColor; end; class function TdxBarOffice11Painter.BarCaptionColor(ABarControl: TdxBarControl): COLORREF; begin Result := dxOffice11BarFloatingCaptionTextColor1; end; class function TdxBarOffice11Painter.BarMarkArrowColor(ABarControl: TdxBarControl; AState: TdxBarMarkState): COLORREF; begin case AState of msSelected: Result := dxOffice11BarFloatingCaptionTextColor2; msPressed: Result := dxOffice11BarFloatingCaptionTextColor3; else // msNone Result := dxOffice11BarFloatingCaptionTextColor1; end; end; class procedure TdxBarOffice11Painter.BarDrawFingerElements(ABarControl: TCustomdxBarControl; DC: HDC; ARect: TRect; AHorizontal: Boolean); begin Office11DrawFingerElements(DC, ARect, AHorizontal); end; procedure TdxBarOffice11Painter.BarDrawMarkBackground(ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect; AToolbarBrush: HBRUSH); var R1, R2, R3: TRect; C1, C2, AColor6, C4: TColor; AC11pxColor, AColor: TColor; begin // TODO: states and colors GetMarkColors(ABarControl, C1, C2, AColor6, C4); if (ABarControl.Bar.BorderStyle = bbsNone) or ABarControl.IsMainMenu then begin R2 := ItemRect; { if ABarControl.Bar.IsMainMenu then begin InflateRect(R2, 0, -1); with R2 do begin ABarControl.FillBackground(DC, Rect(Left, Top - 1, Right, Top), AToolbarBrush, clNone, True); ABarControl.FillBackground(DC, Rect(Left, Bottom, Right, Bottom + 1), AToolbarBrush, clNone, True); end; end;} end else begin R1 := ItemRect; R2 := ItemRect; if ABarControl.Horizontal then begin R1.Right := R1.Left + 2; Inc(R2.Left, 2); InflateRect(R2, 0, 2); with R1 do R3 := Rect(Right - 1, Top, Right, Top + 1); AC11pxColor := GetGradientColorRect(GetBarGradientRect(ABarControl), R3.Top + 2, dxOffice11ToolbarsColor1, dxOffice11ToolbarsColor2, False); end else begin R1.Bottom := R1.Top + 2; Inc(R2.Top, 2); InflateRect(R2, 2, 0); with R1 do R3 := Rect(Left, Bottom - 1, Left + 1, Bottom); AC11pxColor := GetGradientColorRect(GetBarGradientRect(ABarControl), R3.Left + 2, dxOffice11ToolbarsColor1, dxOffice11ToolbarsColor2, True); end; ABarControl.FillBackground(DC, R1, AToolbarBrush, clNone, True); AColor := GetMiddleRGB(AColor6, AC11pxColor, 50); SetPixel(DC, R3.Left, R3.Top, AColor); end; FillTubeGradientRect(DC, R2, C1, C2, not ABarControl.Horizontal); end; procedure TdxBarOffice11Painter.BarDrawMarkElements(ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect); procedure DrawArrow(X, Y: Integer; AVertical: Boolean; AColor: COLORREF); const YOffset = 3; var P: array[1..3] of TPoint; begin if AVertical then begin FillRectByColor(DC, Rect(X, Y, X + 1, Y + 5), AColor); P[1] := Point(X + YOffset, Y); P[2] := Point(X + YOffset, Y + 4); P[3] := Point(X + YOffset + 2, Y + 2); end else begin FillRectByColor(DC, Rect(X, Y, X + 5, Y + 1), AColor); P[1] := Point(X, Y + YOffset); P[2] := Point(X + 4, Y + YOffset); P[3] := Point(X + 2, Y + 2 + YOffset); end; PolygonByColor(DC, P, AColor, AColor); end; procedure DrawArrows(X, Y: Integer; Vertical: Boolean); begin DrawArrow(X + 1, Y + 1, Vertical, dxOffice11BarMarkArrowColor2); DrawArrow(X, Y, Vertical, dxOffice11BarMarkArrowColor1); end; procedure DrawMark(X, Y: Integer; AVertical: Boolean; AColor: COLORREF); var P: array[1..3] of TPoint; begin if AVertical then begin P[1] := Point(X, Y); P[2] := Point(X + 1, Y + 1); P[3] := Point(X + 2, Y); end else begin P[1] := Point(X, Y); P[2] := Point(X + 1, Y + 1); P[3] := Point(X, Y + 2); end; PolygonByColor(DC, P, AColor, AColor); end; procedure DrawMarks(X, Y: Integer; Vertical: Boolean); var AOffsetX, AOffsetY: Integer; begin DrawMark(X + 1, Y + 1, Vertical, dxOffice11BarMarkArrowColor2); DrawMark(X, Y, Vertical, dxOffice11BarMarkArrowColor1); if Vertical then begin AOffsetX := 0; AOffsetY := 4; end else begin AOffsetX := 4; AOffsetY := 0; end; DrawMark(X + 1 + AOffsetX, Y + 1 + AOffsetY, Vertical, dxOffice11BarMarkArrowColor2); DrawMark(X + AOffsetX, Y + AOffsetY, Vertical, dxOffice11BarMarkArrowColor1); end; var AOffsetX, AOffsetY: Integer; begin with ItemRect do begin if (ABarControl.Bar.BorderStyle = bbsNone) or ABarControl.IsMainMenu then begin AOffsetX := 2; AOffsetY := 1; end else begin AOffsetX := 0; AOffsetY := 0; end; if ABarControl.Horizontal then begin DrawArrows(Right - 6 - AOffsetX, Bottom - 8 - AOffsetY, False); if ABarControl.FTruncated then DrawMarks(Right - 7 - AOffsetX, Top + 3 - AOffsetY, False); // TODO end else begin DrawArrows(Right - 8 - AOffsetY, Bottom - 6 - AOffsetX, True); if ABarControl.FTruncated then DrawMarks(Left + 3 - AOffsetX, Bottom - 7 - AOffsetY, True); // TODO end; end; end; procedure TdxBarOffice11Painter.SubMenuControlDrawMark(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect; ASelected: Boolean); begin TransparentDraw(DC, SubMenuControlGetMarkRect(R), dxOffice11SubMenuExpandBitmap); end; function TdxBarOffice11Painter.SubMenuControlGetMarkRect(const ADrawRect: TRect): TRect; var AMarkSize: TSize; begin AMarkSize.cx := cxRectHeight(ADrawRect) - SubMenuControlClientBorderSize * 2; AMarkSize.cy := AMarkSize.cx; Result := cxRectCenter(ADrawRect, AMarkSize); end; class procedure TdxBarOffice11Painter.ComboControlDrawOneArrow(ABarItemControl: TdxBarItemControl; DC: HDC; X, Y, Size: Integer; Color: COLORREF); var P: array[1..3] of TPoint; begin P[1] := Point(X, Y); P[2] := Point(X + Size - 1, Y); P[3] := Point(X + Size div 2, Y + Size div 2); PolygonByColor(DC, P, Color, Color); end; { TdxBarXPPainter } constructor TdxBarXPPainter.Create(AData: Integer); begin inherited Create(AData); InitParams; end; procedure TdxBarXPPainter.DrawGlyphAndTextInSubMenu( const ADrawParams: TdxBarButtonLikeControlDrawParams; var R: TRect); var AIconRect: TRect; AIsGlyphEmpty, AOpaque: Boolean; Brush: HBRUSH; ADC: HDC; begin // TODO: !!! with ADrawParams do begin ADC := Canvas.Handle; AIconRect := GetSubMenuItemIconRect(R, BarItemControl.Parent.IconAreaSize); AIsGlyphEmpty := not BarItemControl.HasIcon(ViewSize, ViewStructure); DrawGlyph(BarItemControl, ADC, AIconRect, cxEmptyRect, ptMenu, AIsGlyphEmpty, DrawSelected, Downed, False, False, False, False, False); if DrawSelected and AIsGlyphEmpty and not Downed then Brush := BarItemControl.Parent.ToolbarSelBrush else Brush := BarItemControl.Parent.BkBrush; R.Left := AIconRect.Right + 1; AOpaque := DrawSelected or BarItemControl.FNonRecent; DrawBackground(BarItemControl, ADC, Rect(AIconRect.Right, AIconRect.Top, R.Left, AIconRect.Bottom), Brush, AOpaque); if AIconRect.Top > R.Top then DrawBackground(BarItemControl, ADC, Rect(AIconRect.Left, R.Top, R.Left, AIconRect.Top), Brush, AOpaque); if AIconRect.Bottom < R.Bottom then DrawBackground(BarItemControl, ADC, Rect(AIconRect.Left, AIconRect.Bottom, R.Left, R.Bottom), Brush, AOpaque); if DrawSelected then Brush := BarItemControl.Parent.ToolbarSelBrush else Brush := BarItemControl.Parent.BkBrush; DrawBackground(BarItemControl, ADC, R, Brush, AOpaque); Inc(R.Left, 2); DrawItemTextInSubMenu(ADrawParams, R); end; end; class procedure TdxBarXPPainter.DrawLowered(DC: HDC; var R: TRect); begin TdxBarStandardPainter.DrawLowered(DC, R); end; class procedure TdxBarXPPainter.GetCaptionParams(out AOffsets: TRect; out AHeightCorrection: Integer); begin AOffsets := Rect(2, 2, 2, 3); AHeightCorrection := 0; end; class function TdxBarXPPainter.GlyphBkgndBrush(ABarItemControl: TdxBarItemControl; APaintType: TdxBarPaintType; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AForceUseBkBrush, AGrayScale: Boolean): HBRUSH; begin if ASelected and (APaintType = ptMenu) and AGlyphEmpty and not ADowned then // TODO: ref func Result := ABarItemControl.Parent.ToolbarSelBrush else Result := ABarItemControl.BkBrush; end; class function TdxBarXPPainter.GlyphDownShift(ABarItemControl: TdxBarItemControl): Integer; begin Result := 1; end; class function TdxBarXPPainter.GlyphDrawDownedShift(ABarItemControl: TdxBarItemControl; ADown: Boolean): Integer; begin if not ADown then Result := 1 else Result := 0; end; class function TdxBarXPPainter.BeforeFingersSize: Integer; begin // Result := 3; Result := 0; end; class function TdxBarXPPainter.FingersSize: Integer; begin Result := BeforeFingersSize + GripperSize + 2; end; class function TdxBarXPPainter.GripperSize: Integer; begin Result := FdxBarXPPainterParams.GripperSize; end; class function TdxBarXPPainter.RealButtonArrowWidth(ABarManager: TdxBarManager): Integer; begin Result := inherited RealButtonArrowWidth(ABarManager); Inc(Result, 3); end; class function TdxBarXPPainter.RealLargeButtonArrowWidth(ABarManager: TdxBarManager): Integer; begin Result := inherited RealLargeButtonArrowWidth(ABarManager); Inc(Result, 3); end; class procedure TdxBarXPPainter.DockControlFillBackground(ADockControl: TdxDockControl; DC: HDC; ADestR, ASourceR, AWholeR: TRect; ABrush: HBRUSH; AColor: TColor); procedure FillBackgroundTempBitmap(ABitmap: TBitmap); var ATheme: TdxTheme; begin ATheme := OpenTheme(totRebar); with AWholeR do begin ABitmap.Width := Right - Left; ABitmap.Height := Bottom - Top; end; DrawThemeBackground(ATheme, ABitmap.Canvas.Handle, 0, CHEVS_NORMAL, AWholeR); end; procedure DrawBarSeparators(DC: HDC); function GetRowBar(ARow: TdxDockRow): TdxBar; var I: Integer; ABar: TdxBar; begin if ARow.ColCount = 0 then begin Result := nil; Exit; end; Result := ARow.Cols[0].BarControl.Bar; if Result.BorderStyle = bbsNone then for I := 1 to ARow.ColCount - 1 do begin ABar := ARow.Cols[I].BarControl.Bar; if ABar.BorderStyle <> bbsNone then begin Result := ABar; Break; end; end; end; function IsNoBorder(ARow: TdxDockRow): Boolean; var ABar: TdxBar; begin ABar := GetRowBar(ARow); Result := (ABar <> nil) and ((ABar.BorderStyle = bbsNone) or ABar.IsStatusBar); end; procedure CalcLines(ARow: TdxDockRow; AHorz: Boolean; var AIsFirstLineNeeded, AIsLastLineNeeded: Boolean); var AIsTop, AIsBottom, AIsTopBottom, AIsLeft, AIsRight: Boolean; begin if IsNoBorder(ARow) then begin AIsFirstLineNeeded := False; AIsLastLineNeeded := False; end else begin AIsFirstLineNeeded := True; AIsLastLineNeeded := True; if AHorz then begin AIsTop := (ADockControl.DockingStyle = dsTop) and (ARow = ADockControl.Rows[0]); AIsBottom := (ADockControl.DockingStyle = dsBottom) and (ARow = ADockControl.Rows[ADockControl.RowCount - 1]); AIsTopBottom := (ADockControl.DockingStyle = dsTop) and (ARow = ADockControl.Rows[ADockControl.RowCount - 1]); if AIsTop then AIsFirstLineNeeded := False; if AIsBottom or AIsTopBottom then AIsLastLineNeeded := False; end else begin AIsLeft := (ADockControl.DockingStyle = dsLeft) and (ARow = ADockControl.Rows[0]); AIsRight := (ADockControl.DockingStyle = dsRight) and (ARow = ADockControl.Rows[ADockControl.RowCount - 1]); if AIsLeft then AIsFirstLineNeeded := False; if AIsRight then AIsLastLineNeeded := False; end; end; end; var I: Integer; R, R1, R2: TRect; AHorz: Boolean; AIsFirstLineNeeded, AIsLastLineNeeded: Boolean; begin AHorz := ADockControl.DockingStyle in [dsTop, dsBottom]; for I := 0 to ADockControl.RowCount - 1 do begin // rects R := ADockControl.GetRectForRow(I); if AHorz then begin R1 := Rect(R.Left, R.Top, R.Right, R.Top + 1); R2 := Rect(R.Left, R.Bottom - 1, R.Right, R.Bottom); end else begin R1 := Rect(R.Left, R.Top, R.Left + 1, R.Bottom); R2 := Rect(R.Right - 1, R.Top, R.Right, R.Bottom); end; // draw CalcLines(ADockControl.Rows[I], AHorz, AIsFirstLineNeeded, AIsLastLineNeeded); if AIsFirstLineNeeded then FillRect(DC, R1, GetSysColorBrush(COLOR_BTNHIGHLIGHT)); if AIsLastLineNeeded then FillRect(DC, R2, GetSysColorBrush(COLOR_BTNSHADOW)); // TODO: color? end; end; begin if ADockControl.BackgroundTempBitmap.Empty then begin FillBackgroundTempBitmap(ADockControl.BackgroundTempBitmap); DrawBarSeparators(ADockControl.BackgroundTempBitmap.Canvas.Handle); end; cxBitBlt(DC, ADockControl.BackgroundTempBitmap.Canvas.Handle, ADestR, ASourceR.TopLeft, SRCCOPY); end; class function TdxBarXPPainter.IsNativeBackground: Boolean; begin Result := True; end; {class function TdxBarXPPainter.BarChildrenHaveShadows(ABarControl: TCustomdxBarControl): Boolean; begin Result := False; end;} class function TdxBarXPPainter.BarHasShadow(ABarControl: TCustomdxBarControl): Boolean; begin Result := ABarControl.DockingStyle = dsNone; end; class function TdxBarXPPainter.BarToolbarBrush(ABarControl: TCustomdxBarControl): HBRUSH; begin Result := ABarControl.BarManager.ThemeToolbarsBrush; end; class function TdxBarXPPainter.BarToolbarBrushEx(ABarControl: TdxBarControl): HBRUSH; begin Result := BarToolbarBrush(ABarControl); end; class function TdxBarXPPainter.BarToolbarDownedBrush(ABarControl: TCustomdxBarControl): HBRUSH; begin // TODO Result := PatternBrush; // Result := ABarControl.BarManager.FlatToolbarsDownedBrush; end; class function TdxBarXPPainter.BarToolbarDownedSelBrush(ABarControl: TCustomdxBarControl): HBRUSH; begin // TODO Result := GetSysColorBrush(COLOR_BTNFACE); // Result := ABarControl.BarManager.FlatToolbarsDownedSelBrush; end; class function TdxBarXPPainter.BarToolbarSelBrush(ABarControl: TCustomdxBarControl): HBRUSH; begin // TODO Result := GetSysColorBrush(COLOR_HIGHLIGHT); // Result := ABarControl.BarManager.FlatToolbarsSelBrush; end; class function TdxBarXPPainter.ComboBoxArrowWidth(ABarControl: TCustomdxBarControl; cX: Integer): Integer; begin Result := FdxBarXPPainterParams.ComboBoxArrowWidth; end; class procedure TdxBarXPPainter.GetEditTextVerticalOffsets( out ATop, ABottom: Integer); begin ATop := 2; ABottom := 2; end; class function TdxBarXPPainter.BarAllowHotTrack: Boolean; begin Result := True; end; class function TdxBarXPPainter.BarAllowQuickCustomizing: Boolean; begin Result := True; end; class function TdxBarXPPainter.BarBeginGroupSideSize: Integer; begin // don't use in xp painter Result := (BarBeginGroupSize - 1{|}) div 2; end; class function TdxBarXPPainter.BarBeginGroupSize: Integer; begin Result := FdxBarXPPainterParams.BarBeginGroupSize; end; class function TdxBarXPPainter.BarBorderSize: Integer; begin Result := 0; end; class procedure TdxBarXPPainter.BarCaptionFillBackground(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); const CaptionBkColors: array[Boolean] of Integer = (COLOR_INACTIVECAPTION, COLOR_ACTIVECAPTION); //const // CaptionStates: array[Boolean] of Integer = (CS_INACTIVE, CS_ACTIVE); //var // ATheme: TdxTheme; begin // ATheme := OpenTheme(totWindow); // DrawThemeBackground(ATheme, DC, WP_SMALLCAPTION, // CaptionStates[ABarControl.BarManager.MainFormActive], @R); FillRect(DC, R, GetSysColorBrush(CaptionBkColors[ABarControl.BarManager.MainFormActive])); end; {class function TdxBarXPPainter.BarCaptionSize: Integer; var ATheme: TdxTheme; ASize: TSize; begin ATheme := OpenTheme(totWindow); GetThemePartSize(ATheme, 0, WP_SMALLCAPTION, CS_ACTIVE, TS_TRUE, ASize); Result := ASize.cy; end;} class function TdxBarXPPainter.BarCaptionTransparent: Boolean; begin Result := True; end; class function TdxBarXPPainter.BarCloseButtonSize: TSize; begin Result := FdxBarXPPainterParams.BarCloseButtonSize; end; procedure TdxBarXPPainter.BarDrawBeginGroup(ABarControl: TCustomdxBarControl; DC: HDC; ABeginGroupRect: TRect; AToolbarBrush: HBRUSH; AHorz: Boolean); var ATheme: TdxTheme; begin ATheme := OpenTheme(totToolBar); // * IsThemeBackgroundPartiallyTransparent ABarControl.FillBackground(DC, ABeginGroupRect, AToolbarBrush, clNone, True); if AHorz then DrawThemeBackground(ATheme, DC, TP_SEPARATORVERT, TS_NORMAL, ABeginGroupRect) else DrawThemeBackground(ATheme, DC, TP_SEPARATOR, TS_NORMAL, ABeginGroupRect); end; class procedure TdxBarXPPainter.BarDrawCloseButton(ABarControl: TdxBarControl; DC: HDC; R: TRect); const ButtonStates: array [TdxBarMarkState] of Integer = (CBS_NORMAL, CBS_HOT, CBS_PUSHED); var ATheme: TdxTheme; begin ATheme := OpenTheme(totWindow); // FillTransparent is not needed (BarCaptionTransparent) DrawThemeBackground(ATheme, DC, WP_SMALLCLOSEBUTTON, ButtonStates[ABarControl.CloseButtonState], R); end; procedure TdxBarXPPainter.BarDrawDockedBarBorder(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); const Grippers: array[Boolean] of Integer = (RP_GRIPPER, RP_GRIPPERVERT); var ATheme: TdxTheme; begin InflateRect(R, -2, -2); if not ABarControl.CanMoving then Exit; ATheme := OpenTheme(totRebar); with R do if ABarControl.Horizontal then begin Inc(Left, BeforeFingersSize); Right := Left + GripperSize; InflateRect(R, 0, -0); end else begin Inc(Top, BeforeFingersSize); Bottom := Top + GripperSize; InflateRect(R, -0, 0); end; // FillTransparent is not needed (FillBackgroundRgn) DrawThemeBackground(ATheme, DC, Grippers[ABarControl.Vertical], CHEVS_NORMAL, R); end; class procedure TdxBarXPPainter.BarDrawFloatingBarBorder(ABarControl: TdxBarControl; DC: HDC; var R, CR: TRect; AToolbarBrush: HBRUSH); begin TdxBarFlatPainter.BarDrawFloatingBarBorder(ABarControl, DC, R, CR, AToolbarBrush); end; class function TdxBarXPPainter.StatusBarGripSize(ABarManager: TdxBarManager): TSize; begin Result := FdxBarXPPainterParams.StatusBarGripSize; end; class procedure TdxBarXPPainter.BarDrawMDIButton(ABarControl: TdxBarControl; AButton: TdxBarMDIButton; ASelected, APressed: Boolean; DC: HDC; R: TRect); const Buttons: array[TdxBarMDIButton] of Integer = (WP_MDIMINBUTTON, WP_MDIRESTOREBUTTON, WP_MDICLOSEBUTTON); States: array[TdxBarMDIButton, 1..4] of Integer = ( (MINBS_DISABLED, MINBS_HOT, MINBS_NORMAL, MINBS_PUSHED), (RBS_DISABLED, RBS_HOT, RBS_NORMAL, RBS_PUSHED), (CBS_DISABLED, CBS_HOT, CBS_NORMAL, CBS_PUSHED)); var ATheme: TdxTheme; AState: Integer; begin ATheme := OpenTheme(totWindow); // * IsThemeBackgroundPartiallyTransparent // ABarControl.MDIButtonEnabled(AButton, MF_GRAYED) // MINBS_DISABLED, MINBS_HOT, MINBS_NORMAL, MINBS_PUSHED AState := 3; if not ABarControl.MDIButtonEnabled(AButton, MF_GRAYED) then AState := 1 else if ASelected then begin if APressed then AState := 4 else AState := 2; end; ABarControl.FillBackground(DC, R, ABarControl.ToolbarBrush, clNone, True); DrawThemeBackground(ATheme, DC, Buttons[AButton], States[AButton, AState], R); end; function TdxBarXPPainter.BarMarkItemRect(ABarControl: TdxBarControl): TRect; begin with TdxBarFlatPainter.Create(0) do begin Result := BarMarkItemRect(ABarControl); Free; end; end; class procedure TdxBarXPPainter.StatusBarFillBackground(ABarControl: TdxBarControl; DC: HDC; ADestR, ASourceR, AWholeR: TRect; ABrush: HBRUSH; AColor: TColor); procedure FillBackgroundTempBitmap(ABitmap: TBitmap); var ATheme: TdxTheme; begin ATheme := OpenTheme(totStatus); with AWholeR do begin ABitmap.Width := Right - Left; ABitmap.Height := Bottom - Top; end; DrawThemeBackground(ATheme, ABitmap.Canvas.Handle, 0, 0, AWholeR); end; begin if ABarControl.BackgroundTempBitmap.Empty then FillBackgroundTempBitmap(ABarControl.BackgroundTempBitmap); cxBitBlt(DC, ABarControl.BackgroundTempBitmap.Canvas.Handle, ADestR, ASourceR.TopLeft, SRCCOPY); end; class function TdxBarXPPainter.SubMenuControlArrowsOffset: Integer; begin Result := 1; end; class function TdxBarXPPainter.SubMenuControlBeginGroupRect( ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; const AItemRect: TRect): TRect; begin Result := AItemRect; Result.Bottom := Result.Top; Dec(Result.Top, ABarSubMenuControl.BeginGroupSize); end; class function TdxBarXPPainter.SubMenuControlBeginGroupSize: Integer; begin Result := FdxBarXPPainterParams.SubMenuControlBeginGroupSize; end; class function TdxBarXPPainter.SubMenuControlClientBorderSize: Integer; begin Result := 1; end; class function TdxBarXPPainter.SubMenuControlDetachCaptionAreaSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; begin Result := ABarSubMenuControl.DetachCaptionSize + 1; end; procedure TdxBarXPPainter.SubMenuControlDrawBeginGroup(ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; ACanvas: TcxCanvas; const ABeginGroupRect: TRect); begin // * IsThemeBackgroundPartiallyTransparent DrawBackground(AControl, ACanvas.Handle, ABeginGroupRect, ABarSubMenuControl.BkBrush, AControl.FNonRecent and not AControl.FChangeRecentGroup); SubMenuControlDrawSeparator(ACanvas, ABeginGroupRect) end; procedure TdxBarXPPainter.SubMenuControlDrawSeparator(ACanvas: TcxCanvas; const ARect: TRect); begin DrawThemeBackground(OpenTheme(totToolBar), ACanvas.Handle, TP_SEPARATORVERT, TS_NORMAL, ARect); end; procedure TdxBarXPPainter.SubMenuControlDrawBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); begin FrameRect(DC, R, GetSysColorBrush(COLOR_BTNSHADOW)); if ABarSubMenuControl.Detachable then begin InflateRect(R, -1, -1); R.Bottom := R.Top + ABarSubMenuControl.DetachCaptionAreaSize + 1; FrameRect(DC, R, ABarSubMenuControl.ToolbarItemsBrush); SubMenuControlDrawDetachCaption(ABarSubMenuControl, DC, ABarSubMenuControl.DetachCaptionRect); end; end; class procedure TdxBarXPPainter.SubMenuControlDrawClientBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; const R: TRect; ABrush: HBRUSH); begin FrameRect(DC, R, ABarSubMenuControl.ToolbarItemsBrush); end; class procedure TdxBarXPPainter.SubMenuControlOffsetDetachCaptionRect(ABarSubMenuControl: TdxBarSubMenuControl; var R: TRect); begin InflateRect(R, -2, -2); end; class procedure TdxBarXPPainter.SubMenuControlPrepareBkBrush(ABarSubMenuControl: TdxBarSubMenuControl; var ABkBrush: HBRUSH); begin ABkBrush := SubMenuControlToolbarItemsBrush(ABarSubMenuControl); end; class function TdxBarXPPainter.SubMenuControlToolbarItemsBrush(ABarSubMenuControl: TdxBarSubMenuControl): HBRUSH; begin Result := GetSysColorBrush(COLOR_MENU); end; class function TdxBarXPPainter.DropDownListBoxBorderSize: Integer; begin Result := TdxBarFlatPainter.DropDownListBoxBorderSize; end; procedure TdxBarXPPainter.ColorComboDrawCustomButton( const ADrawParams: TdxBarColorComboControlDrawParams; ARect: TRect); begin with ADrawParams do DrawGlyphBorder(BarItemControl, Canvas.Handle, BarItemControl.Parent.BkBrush, True, ARect, ptHorz, True, DrawSelected, False, IsPressed, False, False); DrawDots(ADrawParams, ARect); end; procedure TdxBarXPPainter.ColorComboDrawCustomButtonAdjacentZone( const ADrawParams: TdxBarColorComboControlDrawParams; ARect: TRect); begin with ADrawParams do DrawBackgroundFrameRect(BarItemControl, Canvas.Handle, ARect, BarItemControl.Parent.BkBrush, False); end; function TdxBarXPPainter.GetCustomColorButtonIndents( const ADrawParams: TdxBarColorComboControlDrawParams): TRect; begin Result := Rect(1, 1, 1, 1); end; class function TdxBarXPPainter.IsDateNavigatorFlat: Boolean; begin Result := True; end; class procedure TdxBarXPPainter.DateNavigatorDrawButton(ABarItem: TdxBarItem; DC: HDC; R: TRect; const ACaption: string; APressed: Boolean); var ATheme: TdxTheme; AState: Integer; AOffset: Integer; begin ATheme := OpenTheme(totToolbar); FillRect(DC, R, GetSysColorBrush(COLOR_WINDOW)); if APressed then begin AState := TS_PRESSED; AOffset := 1; end else begin AState := TS_HOT; AOffset := 0; end; DrawThemeBackground(ATheme, DC, TP_BUTTON, AState, R); DateNavigatorDrawButtonCaption(DC, R, AOffset, ACaption, False); end; class procedure TdxBarXPPainter.SysPanelDraw(AHandle: HWND; AllowResizing, MouseAboveCloseButton, CloseButtonIsTracking: Boolean; var CloseButtonRect, GripRect: TRect; Corner: TdxCorner); var R, CR: TRect; B: Integer; BorderBrush: HBRUSH; DC: HDC; AStyle: Longint; begin DC := GetWindowDC(AHandle); try GetWindowRect(AHandle, R); CloseButtonRect := R; GripRect := R; GetClientRect(AHandle, CR); MapWindowRect(0, AHandle, R); B := -R.Left; OffsetRect(CR, -R.Left, -R.Top); OffsetRect(R, -R.Left, -R.Top); BorderBrush := GetSysColorBrush(COLOR_BTNSHADOW); FrameRect(DC, R, BorderBrush); if not AllowResizing then begin SetRectEmpty(CloseButtonRect); SetRectEmpty(GripRect); Exit; end; InflateRect(R, -B, -B); if Corner in [coBottomLeft, coBottomRight] then begin R.Top := R.Bottom - SysPanelSize + 1; FillRect(DC, Rect(R.Left, R.Top - 1, R.Right, R.Top), BorderBrush); end else begin R.Bottom := R.Top + SysPanelSize - 1; FillRect(DC, Rect(R.Left, R.Bottom, R.Right, R.Bottom + 1), BorderBrush); end; CR := R; ThemeDrawSizeGrip(DC, CR, Corner); // TODO: with CR do ExcludeClipRect(DC, Left, Top, Right, Bottom); InflateRect(CR, 2, 2); if CR.Top < R.Top then CR.Top := R.Top; if CR.Bottom > R.Bottom then CR.Bottom := R.Bottom; OffsetRect(CR, GripRect.Left, GripRect.Top); GripRect := CR; CR := R; ThemeDrawCloseButton(DC, CR, MouseAboveCloseButton or CloseButtonIsTracking, MouseAboveCloseButton and CloseButtonIsTracking, Corner); with CR do ExcludeClipRect(DC, Left, Top, Right, Bottom); with CloseButtonRect do OffsetRect(CR, Left, Top); CloseButtonRect := CR; FillRect(DC, R, COLOR_BTNFACE + 1); if Corner in [coBottomLeft, coBottomRight] then begin AStyle := GetWindowLong(AHandle, GWL_STYLE); if (AStyle and WS_HSCROLL <> 0) and (AStyle and WS_VSCROLL <> 0) then with R do begin Left := Right - GetSystemMetrics(SM_CXVSCROLL); Bottom := Top - 1; Top := Bottom - GetSystemMetrics(SM_CYHSCROLL); FillRect(DC, R, GetSysColorBrush(COLOR_BTNFACE)); end; end; finally ReleaseDC(AHandle, DC); end; end; class function TdxBarXPPainter.SysPanelSize: Integer; var ASizeGripSize: Integer; begin Result := ThemeCloseButtonSize.cy + 2 * 2; ASizeGripSize := ThemeSizeGripSize.cy + 1; if Result < ASizeGripSize then Result := ASizeGripSize; end; procedure TdxBarXPPainter.SpinEditControlDrawButton(const ADrawParams: TdxBarSpinEditDrawParams; ARect: TRect; AButtonIndex: Integer); function GetState: Integer; begin with ADrawParams do if not Enabled then Result := UPS_DISABLED else if AButtonIndex = ActiveButtonIndex then Result := UPS_PRESSED else if AButtonIndex = HotPartIndex then Result := UPS_HOT else Result := UPS_NORMAL; end; const AThemePartId: array [Boolean] of Integer = (SPNP_DOWN, SPNP_UP); begin with ADrawParams do begin // * IsThemeBackgroundPartiallyTransparent DrawBackground(BarEditControl, Canvas.Handle, ARect, BarEditControl.Parent.BkBrush, False); DrawThemeBackground(OpenTheme(totSpin), Canvas.Handle, AThemePartId[AButtonIndex = secButtonUp], GetState, ARect); end; end; function TdxBarXPPainter.GetSpinEditButtonIndents: TRect; begin Result := cxEmptyRect; end; class function TdxBarXPPainter.ProgressControlBarBrushColor: TColorRef; var ATheme: TdxTheme; begin ATheme := OpenTheme(totProgress); if FAILED(GetThemeColor(ATheme, PP_CHUNK, 0, TMT_FILLCOLOR, Result)) then Result := inherited ProgressControlBarBrushColor; end; class function TdxBarXPPainter.ProgressControlBarHeight(ABarItemControl: TdxBarItemControl): Integer; begin Result := FdxBarXPPainterParams.ProgressControlBarHeight; end; procedure TdxBarXPPainter.ProgressControlDrawBar(const ADrawParams: TdxbarProgressControlDrawParams; BarR: TRect; ABarBrushColor: TColorRef); const BarParts: array[Boolean] of Integer = (PP_BAR, PP_BARVERT); ChunkParts: array[Boolean] of Integer = (PP_CHUNK, PP_CHUNKVERT); var ATheme: TdxTheme; ABarPartId, AChunkPartId: Integer; CR: TRect; ALeft, ARight: ^Integer; procedure DrawChunk; var ABarBrush: HBRUSH; begin if ADrawParams.Smooth then begin ABarBrush := CreateSolidBrush(ABarBrushColor); FillRect(ADrawParams.Canvas.Handle, CR, ABarBrush); DeleteObject(ABarBrush); end else DrawThemeBackground(ATheme, ADrawParams.Canvas.Handle, AChunkPartId, 0, @CR); end; begin with ADrawParams do begin ATheme := OpenTheme(totProgress); // * IsThemeBackgroundPartiallyTransparent ABarPartId := BarParts[PaintType = ptVert]; AChunkPartId := ChunkParts[PaintType = ptVert]; if IsThemeBackgroundPartiallyTransparent(ATheme, ABarPartId, 0) then DrawBackground(BarItemControl, Canvas.Handle, BarR, BarItemControl.Parent.BkBrush, False); GetThemeBackgroundContentRect(ATheme, Canvas.Handle, ABarPartId, 0, BarR, CR); // calc rect with CR do if PaintType = ptVert then begin ALeft := @Top; ARight := @Bottom; end else begin ALeft := @Left; ARight := @Right; end; ARight^ := ALeft^ + MulDiv(ARight^ - ALeft^, Position - Min, Max - Min); // draw chunk DrawThemeBackground(ATheme, Canvas.Handle, ABarPartId, 0, BarR); DrawChunk; end; end; function TdxBarXPPainter.EditGetEnabledBkColor(ABarItemControl: TdxBarCustomEditControl): COLORREF; begin Result := ThemeEditColor(OpenTheme(totEdit), ETS_NORMAL); end; function TdxBarXPPainter.EditGetDisabledBkColor(ABarItemControl: TdxBarCustomEditControl): COLORREF; begin Result := ThemeEditColor(OpenTheme(totEdit), ETS_DISABLED); end; function TdxBarXPPainter.EditGetEnabledTextColor: COLORREF; begin Result := ThemeEditTextColor(OpenTheme(totEdit), ETS_NORMAL); end; function TdxBarXPPainter.EditGetDisabledTextColor: COLORREF; begin Result := ThemeEditTextColor(OpenTheme(totEdit), ETS_DISABLED); end; function TdxBarXPPainter.SubMenuGetSeparatorSize: Integer; begin Result := FdxBarXPPainterParams.SubMenuControlBeginGroupSize; end; class function TdxBarXPPainter.IsQuickControlPopupOnRight: Boolean; begin Result := True; end; function TdxBarXPPainter.GetButtonBorderHeight: Integer; begin Result := FdxBarXPPainterParams.ButtonBorderHeight; end; function TdxBarXPPainter.GetButtonBorderWidth: Integer; begin Result := GetButtonBorderHeight; end; class procedure TdxBarXPPainter.CorrectButtonControlDefaultHeight(var DefaultHeight: Integer); begin // Inc(DefaultHeight, 2); // TODO: check!!! Inc(DefaultHeight, 1); end; procedure TdxBarXPPainter.DrawButtonControlArrow( const ADrawParams: TdxBarButtonLikeControlDrawParams; R1: TRect; ABrush: HBRUSH); function GetState: Integer; begin with ADrawParams do if not (Enabled and DropDownEnabled) then Result := TS_DISABLED else if DroppedDown or IsArrowButtonDowned(PaintType, IsPressed) then Result := TS_PRESSED else if Downed and (PaintType <> ptMenu) then Result := TS_CHECKED else if DrawSelected then Result := TS_HOT else Result := TS_NORMAL; end; var ATheme: TdxTheme; ADC: HDC; begin with ADrawParams do begin ADC := Canvas.Handle; ATheme := OpenTheme(totToolBar); // * IsThemeBackgroundPartiallyTransparent DrawBackground(BarItemControl, ADC, R1, ABrush, BarItemControl.FNonRecent); if PaintType = ptMenu then begin DrawThemeBackground(ATheme, ADC, TP_BUTTON, GetState, R1); DrawLargeItemArrow(ADC, R1, adRight, BarItemControl.Parent.MenuArrowHeight, DroppedDown, Enabled and DropDownEnabled, True{Flat}) end else DrawThemeBackground(ATheme, ADC, TP_SPLITBUTTONDROPDOWN, GetState, R1); end; end; class procedure TdxBarXPPainter.OffsetCaptionBounds(ADown, APressed: Boolean; var R: TRect); begin if ADown or APressed then OffsetRect(R, 1, 1); end; class procedure TdxBarXPPainter.OffsetEllipsisBounds(APressed: Boolean; var R: TRect); begin if APressed then OffsetRect(R, 1, 1); end; class function TdxBarXPPainter.EditControlBorderOffsets: TRect; begin Result := FdxBarXPPainterParams.EditControlBorderOffsets; end; procedure TdxBarXPPainter.EditControlDrawBorder( const ADrawParams: TdxBarEditLikeControlDrawParams; var ARect: TRect); var ATheme: TdxTheme; AClipRgn: HRGN; AClipRgnExists: Boolean; AEditState: Integer; R: TRect; begin with ADrawParams do begin ATheme := OpenTheme(totEdit); AEditState := ThemeEditState(BarEditControl); R := ARect; GetThemeBackgroundContentRect(ATheme, Canvas.Handle, EP_EDITTEXT, AEditState, R, ARect); SaveClipRgn(Canvas.Handle, AClipRgn, AClipRgnExists); with ARect do ExcludeClipRect(Canvas.Handle, Left, Top, Right, Bottom); if (not Enabled or (PaintType = ptMenu)) and not IsTransparent or DrawSelected then DrawThemeBackground(ATheme, Canvas.Handle, EP_EDITTEXT, AEditState, R) else DrawBackground(BarEditControl, Canvas.Handle, R, BarEditControl.Parent.BkBrush, BarEditControl.FNonRecent); RestoreClipRgn(Canvas.Handle, AClipRgn, AClipRgnExists); end; end; class function TdxBarXPPainter.EditControlCaptionRightIndentIsOpaque( const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; begin with ADrawParams do Result := (PaintType = ptMenu) and (DrawSelected or BarItemControl.FNonRecent); end; procedure TdxBarXPPainter.EditControlDrawTextField(ABarEditControl: TdxBarEditControl; DC: HDC; const ARect: TRect; AIgnoreEnabled: Boolean); var ATextColor, ABkColor: COLORREF; AClipRgn: HRGN; AClipRgnExists: Boolean; APrevFont: HFONT; begin EditGetColors(ABarEditControl, ATextColor, ABkColor); SaveClipRgn(DC, AClipRgn, AClipRgnExists); try with ARect do IntersectClipRect(DC, Left, Top, Right, Bottom); SetTextColor(DC, ATextColor); with ABarEditControl.Parent.Canvas do begin Font.Color := ATextColor; Brush.Color := ABkColor; Handle; // RequiredState(csAllValid) end; APrevFont := SelectObject(DC, ABarEditControl.EditFont.Handle); try ABarEditControl.Item.DrawInterior(ABarEditControl, ABarEditControl.Canvas.Canvas, ARect, ABarEditControl.ItemLink); finally if GetObjectType(APrevFont) = OBJ_FONT then SelectObject(DC, APrevFont); end; finally RestoreClipRgn(DC, AClipRgn, AClipRgnExists); end; end; class function TdxBarXPPainter.EditControlES_Style: Integer; begin Result := TdxBarFlatPainter.EditControlES_Style; end; class function TdxBarXPPainter.EditControlCaptionLeftIndent( const ADrawParams: TdxBarEditLikeControlDrawParams): Integer; begin Result := 6; end; class function TdxBarXPPainter.EditControlCaptionRightIndent: Integer; begin Result := 5; end; class function TdxBarXPPainter.EditControlSubmenuGlyphIndents( const ADrawParams: TdxBarEditLikeControlDrawParams): TRect; begin Result := Rect(5, 0, 0, 0); end; class function TdxBarXPPainter.EditControlGetRightCaptionIndentBrush(ABarEditControl: TdxBarCustomEditControl): HBRUSH; begin Result := ABarEditControl.CaptionBkBrush; end; class procedure TdxBarXPPainter.EditControlPrepareEditWnd(ABarEditControl: TdxBarEditControl; AHandle: HWND); begin TdxBarFlatPainter.EditControlPrepareEditWnd(ABarEditControl, AHandle); end; class procedure TdxBarXPPainter.EditControlUpdateWndText(ABarEditControl: TdxBarEditControl; AHandle: HWND; ANotEqual: Boolean); begin TdxBarFlatPainter.EditControlUpdateWndText(ABarEditControl, AHandle, ANotEqual); end; class procedure TdxBarXPPainter.CustomComboDrawItem(ABarCustomCombo: TdxBarCustomCombo; ACanvas: TCanvas; AIndex: Integer; ARect: TRect; AState: TOwnerDrawState; AInteriorIsDrawing: Boolean); begin TdxBarFlatPainter.CustomComboDrawItem(ABarCustomCombo, ACanvas, AIndex, ARect, AState, AInteriorIsDrawing); end; class function TdxBarXPPainter.ComboControlArrowOffset: Integer; begin Result := 0; end; procedure TdxBarXPPainter.ComboControlDrawArrowButton(const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); function GetState: Integer; begin with ADrawParams do if not Enabled then Result := CBXS_DISABLED else if DroppedDown then Result := CBXS_PRESSED else if DrawSelected then Result := CBXS_HOT else Result := CBXS_NORMAL; end; begin with ADrawParams do begin // * IsThemeBackgroundPartiallyTransparent DrawThemeBackground(OpenTheme(totComboBox), Canvas.Handle, CP_DROPDOWNBUTTON, GetState, ARect); end; end; class procedure TdxBarXPPainter.DrawGlyphBorder(ABarItemControl: TdxBarItemControl; DC: HDC; ABrush: HBRUSH; NeedBorder: Boolean; R: TRect; PaintType: TdxBarPaintType; IsGlyphEmpty, Selected, Down, DrawDowned, ADroppedDown, IsSplit: Boolean); var ATheme: TdxTheme; AState: Integer; begin ATheme := OpenTheme(totToolBar); // * IsThemeBackgroundPartiallyTransparent if (PaintType = ptMenu) and (Selected or ABarItemControl.FNonRecent) and IsGlyphEmpty and not Down or ABarItemControl.IsBkColorAssigned then FillRect(DC, R, ABrush) else begin DrawBackground(ABarItemControl, DC, R, ABrush, False); if IsMenuItem(ABarItemControl) and (PaintType <> ptMenu) and (Selected or DrawDowned or Down or ADroppedDown) then FillRect(DC, R, GetSysColorBrush(COLOR_HIGHLIGHT)) // *** else begin if not ABarItemControl.Enabled then AState := TS_DISABLED else if DrawDowned then AState := TS_PRESSED else if Down or ADroppedDown and not IsSplit then AState := TS_CHECKED else if Selected then AState := TS_HOT else AState := TS_NORMAL; if IsSplit then DrawThemeBackground(ATheme, DC, TP_SPLITBUTTON, AState, R) else DrawThemeBackground(ATheme, DC, TP_BUTTON, AState, R); end; end; end; class procedure TdxBarXPPainter.DrawGlyphCheckMark(ABarItemControl: TdxBarItemControl; DC: HDC; X, Y, DoubleSize: Integer); begin TdxBarFlatPainter.DrawGlyphCheckMark(ABarItemControl, DC, X, Y, DoubleSize); end; class procedure TdxBarXPPainter.DrawGlyphImage(ABarItemControl: TdxBarItemControl; DC: HDC; ABrush: HBRUSH; NeedBorder: Boolean; R: TRect; const GlyphRect: TRect; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; Selected, Down, DrawDowned, ForceUseBkBrush, GrayScale, BarControlOwner: Boolean; PaintType: TdxBarPaintType); begin if NeedBorder then InflateRect(R, -1, -1); TransparentDraw(ABarItemControl, DC, 0, R, GlyphRect, AGlyph, AImages, AImageIndex, ABarItemControl.BarManager.ImageListBkColor, ABarItemControl.GetImageEnabled(PaintType), GrayScale, True{Flat}, Selected, Down, DrawDowned, False{Shadow}, GetFaded(ABarItemControl.Parent){Faded}, ABarItemControl.BarManager.ImageOptions.SmoothGlyphs, ABarItemControl.BarManager.ImageOptions.UseLeftBottomPixelAsTransparent); if NeedBorder then InflateRect(R, 1, 1); end; class function TdxBarXPPainter.GetFaded(ABarControl: TCustomdxBarControl): Boolean; begin Result := True; end; class function TdxBarXPPainter.IsArrowButtonDowned(APaintStyle: TdxBarPaintType; AIsPressed: Boolean): Boolean; begin Result := (APaintStyle <> ptMenu) and AIsPressed; end; class function TdxBarXPPainter.IsMenuItem(ABarItemControl: TdxBarItemControl): Boolean; begin Result := ABarItemControl.IsMenuItem; end; class procedure TdxBarXPPainter.BarDrawGrip(ABarControl: TdxBarControl; DC: HDC; R: TRect; AToolbarBrush: HBRUSH); var ATheme: TdxTheme; begin ATheme := OpenTheme(totStatus); // * IsThemeBackgroundPartiallyTransparent ABarControl.FillBackground(DC, R, AToolbarBrush, clNone, False); DrawThemeBackground(ATheme, DC, SP_GRIPPER, 0, R); end; procedure TdxBarXPPainter.BarDrawMarkBackground(ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect; AToolbarBrush: HBRUSH); const States: array[TdxBarMarkState] of Integer = (TS_NORMAL, TS_HOT, TS_PRESSED); var ATheme: TdxTheme; begin ATheme := OpenTheme(totToolbar); // * IsThemeBackgroundPartiallyTransparent ABarControl.FillBackground(DC, ItemRect, AToolbarBrush, clNone, True); if ABarControl.Bar.BorderStyle = bbsNone then begin if ABarControl.Horizontal then InflateRect(ItemRect, 0, -2) else InflateRect(ItemRect, -2, 0); end; DrawThemeBackground(ATheme, DC, TP_BUTTON, States[ABarControl.MarkDrawState], ItemRect); end; class procedure TdxBarXPPainter.BarOffsetFloatingBarCaption(ABarControl: TdxBarControl; var X: Integer; var R: TRect); begin Inc(X, 2); R.Right := ABarControl.MarkNCRect.Left; end; procedure TdxBarXPPainter.DrawDot(const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); begin if ADrawParams.Enabled then FillRect(ADrawParams.Canvas.Handle, ARect, COLOR_BTNTEXT + 1) else inherited; end; function TdxBarXPPainter.GetDotSpaceAfter(ADotWidth: Integer): Integer; begin Result := ADotWidth * 2; end; class procedure TdxBarXPPainter.EditOffsetInteriorRect(var R: TRect); begin Inc(R.Top, 2); end; procedure TdxBarXPPainter.BarBeginGroupSizeInit; var ATheme: TdxTheme; ASize: TSize; begin ATheme := OpenTheme(totToolBar); GetThemePartSize(ATheme, 0, TP_SEPARATOR, TS_NORMAL, TS_MIN, ASize); FdxBarXPPainterParams.BarBeginGroupSize := ASize.cx; end; procedure TdxBarXPPainter.BarCloseButtonSizeInit; var ATheme: TdxTheme; begin ATheme := OpenTheme(totWindow); GetThemePartSize(ATheme, 0, WP_SMALLCLOSEBUTTON, CBS_NORMAL, TS_TRUE, FdxBarXPPainterParams.BarCloseButtonSize); end; procedure TdxBarXPPainter.ButtonBorderHeightInit; var R, RC: TRect; begin R := Rect(0, 0, 100, 100); GetThemeBackgroundContentRect(OpenTheme(totToolBar), 0, TP_SPLITBUTTON, TS_NORMAL, R, RC); // ? FdxBarXPPainterParams.ButtonBorderHeight := cxRectHeight(R) - cxRectHeight(RC); end; procedure TdxBarXPPainter.ComboBoxArrowWidthInit; var ATheme: TdxTheme; ASize: TSize; begin ATheme := OpenTheme(totComboBox); GetThemePartSize(ATheme, 0, CP_DROPDOWNBUTTON, CBXS_NORMAL, TS_TRUE, ASize); FdxBarXPPainterParams.ComboBoxArrowWidth := ASize.cx; end; procedure TdxBarXPPainter.EditControlBorderOffsetsInit; var AContentRect, R: TRect; begin R := Rect(0, 0, 100, 100); GetThemeBackgroundContentRect(OpenTheme(totEdit), 0, EP_EDITTEXT, ETS_NORMAL, R, AContentRect); FdxBarXPPainterParams.EditControlBorderOffsets := Rect(AContentRect.Left, AContentRect.Top, R.Right - AContentRect.Right, R.Bottom - AContentRect.Bottom); end; procedure TdxBarXPPainter.GripperSizeInit; var ATheme: TdxTheme; ASize: TSize; begin ATheme := OpenTheme(totRebar); GetThemePartSize(ATheme, 0, RP_GRIPPER, CHEVS_NORMAL, TS_TRUE, ASize); FdxBarXPPainterParams.GripperSize := ASize.cx; end; procedure TdxBarXPPainter.InitParams; begin BarBeginGroupSizeInit; BarCloseButtonSizeInit; ButtonBorderHeightInit; ComboBoxArrowWidthInit; EditControlBorderOffsetsInit; GripperSizeInit; ProgressControlBarHeightInit; SubMenuControlBeginGroupSizeInit; StatusBarGripSizeInit; end; procedure TdxBarXPPainter.ProgressControlBarHeightInit; var ATheme: TdxTheme; ASize: TSize; R, CR: TRect; begin ATheme := OpenTheme(totProgress); GetThemePartSize(ATheme, 0, PP_CHUNK, 0, TS_TRUE, ASize); GetThemeBackgroundContentRect(ATheme, 0, PP_BAR, 0, R, CR); FdxBarXPPainterParams.ProgressControlBarHeight := ASize.cy + (R.Right - R.Left) - (CR.Right - CR.Left); end; procedure TdxBarXPPainter.StatusBarGripSizeInit; var ATheme: TdxTheme; begin ATheme := OpenTheme(totStatus); GetThemePartSize(ATheme, 0, SP_GRIPPER, 0, TS_TRUE, FdxBarXPPainterParams.StatusBarGripSize); end; procedure TdxBarXPPainter.SubMenuControlBeginGroupSizeInit; var ATheme: TdxTheme; ASize: TSize; begin ATheme := OpenTheme(totToolBar); GetThemePartSize(ATheme, 0, TP_SEPARATORVERT, TS_NORMAL, TS_TRUE, ASize); FdxBarXPPainterParams.SubMenuControlBeginGroupSize := ASize.cy; end; { TdxBarSkinnedPainter } constructor TdxBarSkinnedPainter.Create(AData: Integer); begin inherited Create(AData); FSkinnedObject := TObject(AData); end; procedure TdxBarSkinnedPainter.CalculateButtonParts( const ADrawParams: TdxBarButtonLikeControlDrawParams; var AParts: array of TRect; const AItemRect: TRect); var ACaptionHeight: Integer; begin if ADrawParams.IsDropDown then begin if (ADrawParams.PaintType = ptMenu) or (ADrawParams.ViewSize = cvsSmall) then inherited else begin ACaptionHeight := cxRectHeight(cxGetTextRect(ADrawParams.Canvas.Handle, ADrawParams.Caption, GetMaxLineCount, True)) + 2{!!!}; AParts[bcpDropButton].Top := AParts[bcpDropButton].Bottom - ACaptionHeight; AParts[bcpButton].Bottom := AParts[bcpDropButton].Top; end; end; end; procedure TdxBarSkinnedPainter.CalculateSpinEditParts(const ADrawParams: TdxBarEditLikeControlDrawParams; var AParts: array of TRect; const AItemRect: TRect); begin inherited; Dec(AParts[secButtonUp].Bottom); AParts[ecpEdit].Right := AParts[secButtonUp].Left; end; procedure TdxBarSkinnedPainter.DrawArrow(ADC: HDC; ARect: TRect; AArrowState: Integer); begin Inc(ARect.Left, (cxRectWidth(ARect) div 2) - (GetDefaultArrowSignSize.cx div 2)); Inc(ARect.Top, (cxRectHeight(ARect) div 2) - (GetDefaultArrowSignSize.cy div 2)); ARect.Right := ARect.Left + GetDefaultArrowSignSize.cx; ARect.Bottom := ARect.Top + GetDefaultArrowSignSize.cy; Skin.DrawBackground(ADC, ARect, DXBAR_ARROWDOWN, AArrowState); end; class function TdxBarSkinnedPainter.GetDefaultTextSize(ACanvas: TcxCanvas): Integer; begin Result := ACanvas.TextHeight('Wg') + 3; end; class procedure TdxBarSkinnedPainter.DrawBackground(ABarItemControl: TdxBarItemControl; DC: HDC; const R: TRect; ABrush: HBRUSH; AOpaque: Boolean); begin if ABarItemControl.GetPaintType = ptMenu then if not ABarItemControl.DrawSelected then inherited; end; procedure TdxBarSkinnedPainter.DrawItemBackgroundInSubMenu(const ADrawParams: TdxBarButtonLikeControlDrawParams; var R: TRect); begin with ADrawParams do if DrawSelected then if Enabled then Skin.DrawBackground(Canvas.Handle, R, DXBAR_SMALLBUTTON, DXBAR_ACTIVE) else Skin.DrawBackground(Canvas.Handle, R, DXBAR_SMALLBUTTON, DXBAR_ACTIVEDISABLED) else BarItemControl.SubMenuParent.FillBackgroundEx(Canvas, R, 0, clNone, True); end; procedure TdxBarSkinnedPainter.DrawGlyphAndBkgnd( ABarItemControl: TdxBarItemControl; ADC: HDC; R: TRect; const AGlyphRect: TRect; APaintType: TdxBarPaintType; AGlyph: TBitmap; AImages: TCustomImageList; AImageIndex: Integer; AGlyphEmpty, ASelected, ADowned, ADrawDowned, ADroppedDown, AForceUseBkBrush, AGrayScale, AIsSplit: Boolean); var ACheckRect: TRect; AState: Integer; begin if (APaintType = ptMenu) and ADowned then begin if ABarItemControl.Enabled then AState := DXBAR_NORMAL else AState := DXBAR_DISABLED; ACheckRect := R; InflateRect(ACheckRect, -1, -1); if AGlyphEmpty then Skin.DrawBackground(ADC, ACheckRect, DXBAR_MENUCHECKMARK, AState) else Skin.DrawBackground(ADC, ACheckRect, DXBAR_MENUCHECK, AState); end; if not AGlyphEmpty then TransparentDraw(ABarItemControl, ADC, 0, R, AGlyphRect, AGlyph, AImages, AImageIndex, ABarItemControl.BarManager.ImageListBkColor, ABarItemControl.GetImageEnabled(APaintType), AGrayScale, False {Flat}, ASelected, ADowned, ADrawDowned, False{Shadow}, GetFaded(ABarItemControl.Parent){Faded}, ABarItemControl.BarManager.ImageOptions.SmoothGlyphs, ABarItemControl.BarManager.ImageOptions.UseLeftBottomPixelAsTransparent); end; procedure TdxBarSkinnedPainter.DrawGlyphAndTextInSubMenu( const ADrawParams: TdxBarButtonLikeControlDrawParams; var R: TRect); var AIsGlyphEmpty: Boolean; AIconRect: TRect; begin with ADrawParams do begin DrawItemBackgroundInSubMenu(ADrawParams, R); AIconRect := GetSubMenuItemIconRect(R, BarItemControl.Parent.IconAreaSize); AIsGlyphEmpty := not BarItemControl.HasIcon(ViewSize, ViewStructure); DrawGlyph(BarItemControl, Canvas.Handle, AIconRect, cxEmptyRect, ptMenu, AIsGlyphEmpty, DrawSelected, Downed, False, False, False, False, False); Inc(R.Left, GetSubMenuItemTextIndent(ADrawParams)); DrawItemTextInSubMenu(ADrawParams, R); end; end; class function TdxBarSkinnedPainter.GetSubMenuItemTextIndent(const ADrawParams: TdxBarItemControlDrawParams): Integer; begin with ADrawParams.BarItemControl do if SubMenuParent.ItemLinks.ItemSize = misNormal then Result := SubMenuParent.IconAreaSize + SubMenuControlTextIndent else Result := SubMenuParent.IconAreaSize + 4; //! end; function TdxBarSkinnedPainter.GetToolbarContentOffsets(ABar: TdxBar; ADockingStyle: TdxBarDockingStyle; AHasSizeGrip: Boolean): TRect; begin Result := Skin.GetContentOffsets(DXBAR_TOOLBAR); end; function TdxBarSkinnedPainter.GetToolbarsOffsetForAutoAlign: Integer; begin Result := Skin.GetPartOffset(DXBAR_TOOLBAR); end; class function TdxBarSkinnedPainter.RealButtonArrowWidth(ABarManager: TdxBarManager): Integer; begin Result := 13; end; class function TdxBarSkinnedPainter.LoweredBorderSize(ABarItemControl: TdxBarItemControl): Integer; begin Result := 0; end; procedure TdxBarSkinnedPainter.BarDrawBackground(ABarControl: TdxBarControl; ADC: HDC; const ADestRect, ASourceRect: TRect; ABrush: HBRUSH; AColor: TColor); begin BarCanvas.BeginPaint(ADC); try BarCanvas.SetClipRegion(TcxRegion.Create(ADestRect), roIntersect); DrawToolbarContentPart(ABarControl, BarCanvas); finally BarCanvas.EndPaint; end; end; procedure TdxBarSkinnedPainter.BarDrawDockedBackground( ABarControl: TdxBarControl; DC: HDC; ADestR, ASourceR: TRect; ABrush: HBRUSH; AColor: TColor); begin Skin.DrawBackground(DC, ADestR, DXBAR_TOOLBAR, GetBarControlState(ABarControl)); end; class function TdxBarSkinnedPainter.ComboBoxArrowWidth(ABarControl: TCustomdxBarControl; cX: Integer): Integer; begin Result := cX + 8; end; class procedure TdxBarSkinnedPainter.SetWindowRgn(AHandle: THandle; const AWindowRect: TRect; ARedraw: Boolean = False); var ARegion: HRGN; begin with AWindowRect do ARegion := CreateRoundRectRgn(0, 0, Right + 1, Bottom + 1, 2, 2); Windows.SetWindowRgn(AHandle, ARegion, ARedraw); end; procedure TdxBarSkinnedPainter.BarDrawBeginGroup( ABarControl: TCustomdxBarControl; DC: HDC; ABeginGroupRect: TRect; AToolbarBrush: HBRUSH; AHorz: Boolean); begin InternalDrawBeginGroup(DC, ABeginGroupRect, AHorz, $EBE8E6, $AAA6A2); end; class function TdxBarSkinnedPainter.GetTailAreaSize(const ADrawParams: TdxBarItemControlDrawParams): Integer; begin if ADrawParams.ViewSize = cvsLarge then Result := ADrawParams.BarItemControl.Parent.TextSize else Result := inherited GetTailAreaSize(ADrawParams); end; function TdxBarSkinnedPainter.GetButtonBorderHeight: Integer; begin with Skin.GetContentOffsets(DXBAR_SMALLBUTTON) do Result := Top + Bottom; end; function TdxBarSkinnedPainter.GetButtonBorderWidth: Integer; begin with Skin.GetContentOffsets(DXBAR_SMALLBUTTON) do Result := Left + Right; end; function TdxBarSkinnedPainter.GetButtonHeight(AIconSize, ATextSize: Integer): Integer; begin Result := Max(AIconSize, ATextSize) + GetButtonBorderHeight; if Odd(Result) then Inc(Result); end; function TdxBarSkinnedPainter.GetButtonWidth(AIconSize, ATextSize: Integer): Integer; begin Result := Max(AIconSize, ATextSize) + GetButtonBorderWidth; if Odd(Result) then Inc(Result); end; class procedure TdxBarSkinnedPainter.CorrectButtonControlDefaultHeight(var DefaultHeight: Integer); begin // do nothing end; procedure TdxBarSkinnedPainter.DrawButtonLikeControl( const ADrawParams: TdxBarButtonLikeControlDrawParams; ARect: TRect); var AImageBounds: TRect; begin with ADrawParams do begin if PaintType = ptMenu then DrawGlyphAndTextInSubMenu(ADrawParams, ARect) else begin DrawButtonBackground(ADrawParams); DrawGlyph(BarItemControl, Canvas.Handle, ARect, ARect, AImageBounds, PaintType, ViewStructure, ViewSize, not (cpIcon in ViewStructure), DrawSelected, Downed, IsPressed, DroppedDown, False, False, False, SplitDropDown and IsDropDown); DrawButtonLikeControlCaption(ADrawParams, ARect, AImageBounds); end; if IsDropDown and not IsMenuItem then if SplitDropDown then DrawSplitControlArrow(ADrawParams, ARect) else DrawAssociateControlArrow(ADrawParams, ARect); end; end; procedure TdxBarSkinnedPainter.DrawButtonControlArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; R1: TRect; ABrush: HBRUSH); begin if ADrawParams.PaintType = ptMenu then ButtonLikeControlDrawMenuArrow(ADrawParams, adRight, R1) else if ADrawParams.ViewSize <> cvsLarge then DrawArrow(ADrawParams.Canvas.Handle, GetArrowRect(ADrawParams, R1), GetButtonPartState(ADrawParams, bcpDropButton)); end; procedure TdxBarSkinnedPainter.DrawSplitControlArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; ARect: TRect); var ARatio: Double; begin DrawButtonControlArrow(ADrawParams, ARect, 0); if (ADrawParams.PaintType = ptMenu) and (ADrawParams.ViewSize <> cvsLarge) then begin ARect := GetArrowRect(ADrawParams, ARect); ARatio := Max(1, cxRectHeight(ARect) / SubMenuControlNormalItemHeight); InflateRect(ARect, 0, -Round((cxRectHeight(ARect) - 14 * ARatio) / 2)); ADrawParams.Canvas.DrawComplexFrame(ARect, Skin.GetPartColor(DXBAR_MENUARROWSEPARATOR), clNone, [bLeft]); end; end; procedure TdxBarSkinnedPainter.DrawAssociateControlArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; ARect: TRect); begin DrawButtonControlArrow(ADrawParams, ARect, 0); end; function TdxBarSkinnedPainter.GetBorderSize: Integer; begin Result := 2; end; function TdxBarSkinnedPainter.GetIconAreaSize(ABarControl: TCustomdxBarControl): Integer; begin Result := inherited GetIconAreaSize(ABarControl); if (ABarControl.Kind = bkSubMenu) and (ABarControl.ItemLinks.ItemSize = misNormal) then Inc(Result, MenuSeparatorSize); end; procedure TdxBarSkinnedPainter.CorrectCaptionParams( const ADrawParams: TdxBarButtonLikeControlDrawParams; var ATextBounds: TRect; const AImageBounds: TRect; out ATextAlignment: DWORD); var ACaptionRect: TRect; begin ACaptionRect := GetControlCaptionRect(ADrawParams); if ADrawParams.ViewSize = cvsSmall then begin if cpIcon in ADrawParams.ViewStructure then begin InflateRect(ATextBounds, -GetButtonBorderWidth div 2, 0); ATextBounds.Left := AImageBounds.Right + GetControlTextIndents.Left; end else InflateRect(ATextBounds, -ADrawParams.BarItemControl.GetControlCaptionOffset, 0); InflateRect(ATextBounds, 0, -(cxRectHeight(ATextBounds) - cxRectHeight(ACaptionRect)) div 2); ATextAlignment := DT_LEFT; end else begin OffsetRect(ACaptionRect, ATextBounds.Left + (cxRectWidth(ATextBounds) - cxRectWidth(ACaptionRect)) div 2, ATextBounds.Top + cxRectHeight(ATextBounds) - (cxRectHeight(ACaptionRect) + 1)); ATextBounds := ACaptionRect; ATextAlignment := DT_CENTER; end; end; procedure TdxBarSkinnedPainter.BarDrawMarkElements( ABarControl: TdxBarControl; DC: HDC; ItemRect: TRect); function GetMarkState: Integer; begin case ABarControl.MarkDrawState of msSelected: Result := DXBAR_HOT; msPressed: Result := DXBAR_PRESSED; else {msNone} Result := DXBAR_NORMAL; end; end; begin if ABarControl.FTruncated then Skin.DrawBackground(DC, ItemRect, DXBAR_MARKTRUNCATED, GetMarkState) else Skin.DrawBackground(DC, ItemRect, DXBAR_MARKARROW, GetMarkState); end; procedure TdxBarSkinnedPainter.DropDownListBoxDrawBorder(DC: HDC; AColor: TColor; ARect: TRect); begin Skin.DrawBackground(DC, ARect, DXBAR_DROPDOWNBORDER, DXBAR_NORMAL); end; class function TdxBarSkinnedPainter.SubMenuControlArrowWidth(ATextSize: Integer): Integer; begin Result := ATextSize; end; class function TdxBarSkinnedPainter.SubMenuControlBeginGroupSize: Integer; begin Result := 3; end; class function TdxBarSkinnedPainter.SubMenuControlDetachCaptionAreaSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; begin Result := 2 + ABarSubMenuControl.DetachCaptionSize + 1; end; procedure TdxBarSkinnedPainter.SubMenuControlDrawScrollBandBackground(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; AArrowDirection: TcxArrowDirection); begin // do nothing end; procedure TdxBarSkinnedPainter.SubMenuControlDrawScrollButton(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; AArrowDirection: TcxArrowDirection); var AState: Integer; ARect: TRect; begin ARect := SubMenuControlGetScrollBandBounds(ABarSubMenuControl, AArrowDirection); if (AArrowDirection = adUp) and (ABarSubMenuControl.MouseOnUpArrow) or (AArrowDirection = adDown) and (ABarSubMenuControl.MouseOnDownArrow) then AState := DXBAR_HOT else AState := DXBAR_NORMAL; ABarSubMenuControl.FillBackgroundEx(ACanvas, ARect, 0, clNone, True); Skin.DrawBackground(ACanvas.Handle, ARect, DXBAR_MENUSCROLLAREA, AState); ACanvas.ExcludeClipRect(ARect); end; procedure TdxBarSkinnedPainter.SubMenuControlDrawBackground(ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; ARect: TRect; ABrush: HBRUSH; AColor: TColor); begin SubMenuControlDrawItemBackground(ABarSubMenuControl, ACanvas, ARect); end; procedure TdxBarSkinnedPainter.SubMenuControlDrawBeginGroup(ABarSubMenuControl: TdxBarSubMenuControl; AControl: TdxBarItemControl; ACanvas: TcxCanvas; const ABeginGroupRect: TRect); var ASeparatorRect: TRect; begin with ABeginGroupRect do ASeparatorRect := cxRect(Left + ABarSubMenuControl.GetIndent1 + SubMenuControlTextIndent, Bottom - SubMenuGetSeparatorSize, Right, Bottom); SubMenuControlDrawBackground(ABarSubMenuControl, ACanvas, ABeginGroupRect, 0, clNone); SubMenuControlDrawSeparator(ACanvas, ASeparatorRect); end; procedure TdxBarSkinnedPainter.SubMenuControlDrawSeparator(ACanvas: TcxCanvas; const ARect: TRect); begin Skin.DrawBackground(ACanvas.Handle, ARect, DXBAR_MENUSEPARATORHORZ, DXBAR_NORMAL); end; procedure TdxBarSkinnedPainter.SubMenuControlDrawBorder( ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); var AContentRect: TRect; begin BarCanvas.BeginPaint(DC); try AContentRect := cxRectOffset(ABarSubMenuControl.ContentRect, ABarSubMenuControl.GetClientOffset.TopLeft); BarCanvas.ExcludeClipRect(AContentRect); Skin.DrawBackground(DC, R, DXBAR_DROPDOWNBORDER, DXBAR_NORMAL); if ABarSubMenuControl.Detachable then begin InflateRect(R, -SubMenuControlBorderSize, -SubMenuControlBorderSize); FillRectByColor(DC, R, Skin.GetPartColor(DXBAR_MENUDETACHCAPTIONAREA)); SubMenuControlDrawDetachCaption(ABarSubMenuControl, DC, ABarSubMenuControl.DetachCaptionRect); end; finally BarCanvas.EndPaint; end; end; class procedure TdxBarSkinnedPainter.SubMenuControlDrawClientBorder( ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; const R: TRect; ABrush: HBRUSH); begin // SubMenuControlDrawBorder has already drawn end; procedure TdxBarSkinnedPainter.SubMenuControlDrawDetachCaption( ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect); const DetachCaptionStates: array[Boolean] of Integer = (DXBAR_NORMAL, DXBAR_HOT); begin Skin.DrawBackground(DC, R, DXBAR_MENUDETACHCAPTION, DetachCaptionStates[ABarSubMenuControl.DetachCaptionSelected]); end; procedure TdxBarSkinnedPainter.SubMenuControlDrawItemBackground( ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; AItemRect: TRect); var AContentRect, ABarRect, ABandRect, ASeparatorRect, AControlRect: TRect; begin cxRectIntersect(AContentRect, ABarSubMenuControl.ContentRect, AItemRect); ABarRect := ABarSubMenuControl.BarRect; ABandRect := Rect(ABarRect.Right, AContentRect.Top, ABarRect.Right + ABarSubMenuControl.BandSize, AContentRect.Bottom); ASeparatorRect := Rect(ABandRect.Right, AContentRect.Top, ABandRect.Right + MenuSeparatorSize, AContentRect.Bottom); AControlRect := Rect(ASeparatorRect.Right, AContentRect.Top, AContentRect.Right, AContentRect.Bottom); if ABarSubMenuControl.ItemLinks.ItemSize = misNormal then begin Skin.DrawBackground(ACanvas.Handle, ABandRect, DXBAR_MENUGLYPH); Skin.DrawBackground(ACanvas.Handle, ASeparatorRect, DXBAR_MENUSEPARATORVERT); end else begin Skin.DrawBackground(ACanvas.Handle, ABandRect, DXBAR_MENUCONTENT); Skin.DrawBackground(ACanvas.Handle, ASeparatorRect, DXBAR_MENUCONTENT); end; Skin.DrawBackground(ACanvas.Handle, AControlRect, DXBAR_MENUCONTENT); end; class function TdxBarSkinnedPainter.SubMenuControlGetBandSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; begin Result := SubMenuControlInternalBorderSize + ABarSubMenuControl.IconAreaSize - MenuSeparatorSize; end; class function TdxBarSkinnedPainter.SubMenuControlNormalItemHeight: Integer; begin Result := 22; end; class function TdxBarSkinnedPainter.SubMenuControlTextIndent: Integer; begin Result := 7; end; class function TdxBarSkinnedPainter.SubMenuControlInternalBorderSize: Integer; begin Result := 2; end; class function TdxBarSkinnedPainter.SubMenuControlInternalBorderOffset: Integer; begin Result := 1; end; class function TdxBarSkinnedPainter.SubMenuControlTextSize(ACanvas: TcxCanvas): Integer; begin Result := GetDefaultTextSize(ACanvas) + (SubMenuControlInternalBorderSize + SubMenuControlInternalBorderOffset) * 2; end; procedure TdxBarSkinnedPainter.ApplicationMenuDrawBorder(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; const ARect: TRect); begin BarCanvas.BeginPaint(DC); try BarCanvas.ExcludeClipRect(cxRectInflate(ARect, -SubMenuControlInternalBorderSize, -SubMenuControlInternalBorderSize)); Skin.DrawBackground(BarCanvas.Handle, ARect, DXBAR_APPLICATIONMENUBORDER); finally BarCanvas.EndPaint; end; end; procedure TdxBarSkinnedPainter.ApplicationMenuDrawButton(const ADrawParams: TdxBarApplicationMenuButtonControlDrawParams; var R: TRect); var AImageBounds: TRect; begin with ADrawParams do begin DrawItemBackgroundInSubMenu(ADrawParams, R); if not DrawSelected then Skin.DrawBackground(Canvas.Handle, R, DXBAR_APPLICATIONMENUBUTTON); R.Left := R.Left + Max((cxRectWidth(R) - ContentWidth) div 2, 0); DrawGlyph(BarItemControl, Canvas.Handle, R, R, AImageBounds, PaintType, ViewStructure, ViewSize, not (cpIcon in ViewStructure), DrawSelected, False, False, False, False, False, False, False); DrawButtonLikeControlCaption(ADrawParams, R, AImageBounds) end; end; procedure TdxBarSkinnedPainter.ApplicationMenuDrawContentArea( ABarSubMenuControl: TdxBarSubMenuControl; ACanvas: TcxCanvas; const AContentRect, AItemsArea: TRect); var AInnerBorderRect, AOuterBorderRect, AHeaderRect, AFooterRect, ALeftSideRect, ARightSideRect: TRect; begin AInnerBorderRect := cxRectInflate(AItemsArea, 1, 1); AOuterBorderRect := cxRectInflate(AInnerBorderRect, 1, 1); AHeaderRect := AContentRect; AHeaderRect.Bottom := AOuterBorderRect.Top; AFooterRect := AContentRect; AFooterRect.Top := AOuterBorderRect.Bottom; ALeftSideRect := Rect(AContentRect.Left, AHeaderRect.Bottom, AOuterBorderRect.Left, AFooterRect.Top); ARightSideRect := Rect(AOuterBorderRect.Right, AHeaderRect.Bottom, AContentRect.Right, AFooterRect.Top); ACanvas.FrameRect(AInnerBorderRect, Skin.GetPartColor(DXBAR_APPLICATIONMENUCONTENTINNERBORDER)); ACanvas.FrameRect(AOuterBorderRect, Skin.GetPartColor(DXBAR_APPLICATIONMENUCONTENTOUTERBORDER)); Skin.DrawBackground(ACanvas.Handle, AHeaderRect, DXBAR_APPLICATIONMENUCONTENTHEADER); Skin.DrawBackground(ACanvas.Handle, AFooterRect, DXBAR_APPLICATIONMENUCONTENTFOOTER); ACanvas.FillRect(ALeftSideRect, Skin.GetPartColor(DXBAR_APPLICATIONMENUCONTENTSIDES)); ACanvas.FillRect(ARightSideRect, Skin.GetPartColor(DXBAR_APPLICATIONMENUCONTENTSIDES)); end; function TdxBarSkinnedPainter.ApplicationMenuGetFrameSizes: TRect; begin Result := Rect(4, 16, 4, 27); end; procedure TdxBarSkinnedPainter.ExtraMenuControlDrawBackground(AExtraMenuControl: TCustomdxBarControl; ACanvas: TcxCanvas; ARect: TRect; ABrush: HBRUSH; AColor: TColor); begin ExtraMenuControlDrawItemBackground(AExtraMenuControl, ACanvas, ARect); end; procedure TdxBarSkinnedPainter.ExtraMenuControlDrawBeginGroup(AExtraMenuControl: TCustomdxBarControl; ACanvas: TcxCanvas; ABeginGroupRect: TRect; AToolbarBrush: HBRUSH; AHorz: Boolean); begin InternalDrawBeginGroup(ACanvas.Handle, ABeginGroupRect, AHorz, $F5F5F5, $D8D8D8); end; procedure TdxBarSkinnedPainter.ExtraMenuControlDrawItemBackground(AExtraMenuControl: TCustomdxBarControl; ACanvas: TcxCanvas; AItemRect: TRect); var AExtraPaneRect, AContentRect, ASeparatorRect: TRect; begin ACanvas.SaveClipRegion; try ACanvas.SetClipRegion(TcxRegion.Create(AItemRect), roIntersect); AExtraPaneRect := AExtraMenuControl.ClientRect; ASeparatorRect := Rect(AExtraPaneRect.Left, AExtraPaneRect.Top, AExtraPaneRect.Left + MenuSeparatorSize, AExtraPaneRect.Bottom); AContentRect := Rect(ASeparatorRect.Right, AExtraPaneRect.Top, AExtraPaneRect.Right, AExtraPaneRect.Bottom); Skin.DrawBackground(ACanvas.Handle, ASeparatorRect, DXBAR_MENUSEPARATORVERT); FillRectByColor(ACanvas.Handle, AContentRect, Skin.GetPartColor(DXBAR_MENUEXTRAPANE)); finally ACanvas.RestoreClipRegion; end; end; function TdxBarSkinnedPainter.EditButtonAllowOffsetContent: Boolean; begin Result := False; end; procedure TdxBarSkinnedPainter.EditButtonDrawBackground(const ADrawParams: TdxBarEditLikeControlDrawParams; AState: Integer; ARect: TRect; ABrush: HBrush); begin Skin.DrawBackground(ADrawParams.Canvas.Handle, ARect, DXBAR_EDIT_BUTTON, AState); end; procedure TdxBarSkinnedPainter.EditButtonDrawBorder( const ADrawParams: TdxBarItemControlDrawParams; AState: Integer; var ADrawRect: TRect; out AContentRect: TRect); begin AContentRect := EditControlGetContentRect(ADrawRect); if AState in [DXBAR_HOT..DXBAR_HOTCHECK] then with ADrawParams do begin Canvas.SaveClipRegion; Canvas.SetClipRegion(TcxRegion.Create(ADrawRect), roSet); FrameRectByColor(Canvas.Handle, ADrawRect, Skin.GetPartColor(DXBAR_EDIT_BUTTON_BORDER, AState)); Canvas.RestoreClipRegion; ADrawRect := AContentRect; end; end; function TdxBarSkinnedPainter.EditButtonAllowCompositeFrame: Boolean; begin Result := True; end; class function TdxBarSkinnedPainter.EditButtonAllowHotTrack(const ADrawParams: TdxBarItemControlDrawParams): Boolean; begin Result := True; end; class function TdxBarSkinnedPainter.EditButtonIsCustomBorder: Boolean; begin Result := True; end; class function TdxBarSkinnedPainter.EditButtonIsCustomBackground(AState: Integer): Boolean; begin Result := True; end; class function TdxBarSkinnedPainter.EditControlCaptionBackgroundIsOpaque( const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; begin Result := False; end; class function TdxBarSkinnedPainter.EditControlCaptionRightIndentIsOpaque( const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; begin Result := EditControlCaptionBackgroundIsOpaque(ADrawParams); end; procedure TdxBarSkinnedPainter.EditControlDrawBorder( const ADrawParams: TdxBarEditLikeControlDrawParams; var ARect: TRect); begin with ADrawParams do begin if not IsTransparent then FrameRectByColor(ADrawParams.Canvas.Handle, ARect, Skin.GetPartColor(DXBAR_EDIT_BORDER, GetEditPartState(ADrawParams, ecpEdit))) else if PaintType = ptMenu then DrawBackgroundFrameRect(BarEditControl, Canvas.Handle, ARect, BarEditControl.Parent.BkBrush, False); InflateRect(ARect, -1, -1); end; end; procedure TdxBarSkinnedPainter.EditControlDrawSelectionFrame( const ADrawParams: TdxBarEditLikeControlDrawParams; const ARect: TRect); procedure DrawSelection(AState: Integer); begin with ADrawParams do begin Skin.DrawBackground(Canvas.Handle, ARect, DXBAR_SMALLBUTTON, AState); Canvas.DrawComplexFrame(cxRectInflate(BarEditControl.GetEditRect, 0, -1), Skin.GetPartColor(DXBAR_MENUEDITSEPARATOR, AState), clNone, [bLeft]); end; end; var AState: Integer; begin with ADrawParams do begin Canvas.SaveClipRegion; Canvas.SetClipRegion(TcxRegion.Create(EditControlGetContentRect(BarEditControl.GetEditRect)), roSubtract); try if Enabled then AState := DXBAR_ACTIVE else AState := DXBAR_ACTIVEDISABLED; DrawSelection(AState); finally Canvas.RestoreClipRegion; end; end; end; class function TdxBarSkinnedPainter.EditGetRealPaintStyle(ABarManager: TdxBarManager): TdxBarManagerStyle; begin if ABarManager.FThemeAvailable then Result := bmsXP else Result := inherited EditGetRealPaintStyle(ABarManager); end; function TdxBarSkinnedPainter.EditGetBkColor( const ADrawParams: TdxBarEditLikeControlDrawParams): COLORREF; begin Result := Skin.GetPartColor(DXBAR_EDIT_BACKGROUND, GetEditPartState(ADrawParams, ecpEdit)); end; procedure TdxBarSkinnedPainter.EditControlDrawGlyph( const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); begin with ADrawParams do if PaintType = ptMenu then DrawBackground(BarEditControl, Canvas.Handle, ARect, BarEditControl.CaptionBkBrush, False); inherited; end; class function TdxBarSkinnedPainter.EditControlShowIconDefault( const ADrawParams: TdxBarEditLikeControlDrawParams): Boolean; begin Result := True; end; class function TdxBarSkinnedPainter.ComboControlArrowOffset: Integer; begin Result := 0; end; class function TdxBarSkinnedPainter.ComboControlButtonOffsets: TRect; begin Result := cxEmptyRect; end; procedure TdxBarSkinnedPainter.ComboControlDrawArrowButton( const ADrawParams: TdxBarEditLikeControlDrawParams; ARect: TRect); begin InternalDrawEditButton(ADrawParams, ccpDropButton, ARect); end; procedure TdxBarSkinnedPainter.ColorComboCorrectFrameRect( const ADrawParams: TdxBarColorComboControlDrawParams; var ARect: TRect); begin if IsCustomColorButtonVisible(ADrawParams) then ARect.Right := ADrawParams.BarItemControl.FParts[clcpCustomColorButton].Right + GetCustomColorButtonIndents(ADrawParams).Right; end; procedure TdxBarSkinnedPainter.ColorComboDrawCustomButton( const ADrawParams: TdxBarColorComboControlDrawParams; ARect: TRect); begin InternalDrawEditButton(ADrawParams, clcpCustomColorButton, ARect); end; procedure TdxBarSkinnedPainter.ColorComboDrawCustomButtonAdjacentZone( const ADrawParams: TdxBarColorComboControlDrawParams; ARect: TRect); begin // do nothing end; function TdxBarSkinnedPainter.GetCustomColorButtonIndents( const ADrawParams: TdxBarColorComboControlDrawParams): TRect; begin Result := cxEmptyRect; end; function TdxBarSkinnedPainter.DateNavigatorHeaderColor: TColor; begin Result := Skin.GetPartColor(DXBAR_DATENAVIGATOR_HEADER); end; class function TdxBarSkinnedPainter.InPlaceSubItemGetArrowWidth(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams): Integer; begin Result := ADrawParams.ArrowWidth; end; procedure TdxBarSkinnedPainter.InPlaceSubItemControlDrawArrow(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams; ADirection: TcxArrowDirection; ARect: TRect); begin ButtonLikeControlDrawMenuArrow(ADrawParams, ADirection, ARect); end; procedure TdxBarSkinnedPainter.InPlaceSubItemControlDrawBackground(const ADrawParams: TdxBarInPlaceSubItemControlDrawParams; ARect: TRect); begin if ADrawParams.DrawSelected then DrawItemBackgroundInSubMenu(ADrawParams, ARect) else Skin.DrawBackground(ADrawParams.Canvas.Handle, ARect, DXBAR_MENUGLYPH); end; procedure TdxBarSkinnedPainter.ProgressControlDrawBackground( const ADrawParams: TdxBarItemControlDrawParams; var R: TRect); begin inherited; Skin.DrawBackground(ADrawParams.Canvas.Handle, R, DXBAR_PROGRESSSUBSTRATE, DXBAR_NORMAL); InflateRect(R, -2, -2); end; procedure TdxBarSkinnedPainter.ProgressControlFillContent( const ADrawParams: TdxBarItemControlDrawParams; const R: TRect; ABarBrush: HBRUSH); begin Skin.DrawBackground(ADrawParams.Canvas.Handle, R, DXBAR_PROGRESSSOLIDBAND, DXBAR_NORMAL); end; procedure TdxBarSkinnedPainter.ProgressControlFillDiscreteContent( const ADrawParams: TdxBarItemControlDrawParams; const R: TRect; ABarBrush: HBRUSH); begin Skin.DrawBackground(ADrawParams.Canvas.Handle, R, DXBAR_PROGRESSDISCRETEBAND, DXBAR_NORMAL); end; function TdxBarSkinnedPainter.GetSpinEditArrowPos( const ADrawParams: TdxBarSpinEditDrawParams; ARect: TRect; AButtonIndex: Integer): TPoint; var AYArrowOffset: Integer; begin with ADrawParams do begin Result.X := ARect.Left + (cxRectWidth(ARect) div 2) - (ArrowSize.cx div 2); AYArrowOffset := (cxRectHeight(ARect) div 2) - (ArrowSize.cy div 2); if AButtonIndex = secButtonUp then Result.Y := ARect.Bottom - AYArrowOffset else Result.Y := ARect.Top + AYArrowOffset - 1; end; end; procedure TdxBarSkinnedPainter.SpinEditCorrectFrameRect( const ADrawParams: TdxBarItemControlDrawParams; var ARect: TRect); begin // do nothing; end; function TdxBarSkinnedPainter.GetSpinEditArrowSize(AHeight: Integer): TSize; begin Result := Size(5, 3); end; function TdxBarSkinnedPainter.GetSpinEditButtonBounds(const ARect: TRect; AButton: TdxBarSpinEditButton): TRect; var AButtonWidth: Integer; begin Result := ARect; InflateRect(Result, -1, -1); AButtonWidth := cxRectHeight(Result) div 2 * 8 div 5 + 1; Result.Left := Result.Right - AButtonWidth; case AButton of sbUp: Result.Bottom := (Result.Bottom + Result.Top) div 2; sbDown: Result.Top := (Result.Bottom + Result.Top) div 2; end; end; procedure TdxBarSkinnedPainter.SpinEditControlDrawButton( const ADrawParams: TdxBarSpinEditDrawParams; ARect: TRect; AButtonIndex: Integer); procedure DrawButtonFrame(AState: Integer; var ARect: TRect; out AContentRect: TRect); begin AContentRect := cxRectInflate(ARect, -1, -1); if AState in [DXBAR_NORMAL, DXBAR_DISABLED, DXBAR_ACTIVE, DXBAR_ACTIVEDISABLED] then begin if AButtonIndex = secButtonUp then Inc(ARect.Bottom) else Dec(ARect.Top); end else FrameRectByColor(ADrawParams.Canvas.Handle, ARect, Skin.GetPartColor(DXBAR_EDIT_BUTTON_BORDER, AState)); InflateRect(ARect, -1, -1); end; var AEditButtonState: Integer; AArrowPos: TPoint; AContentRect: TRect; begin with ADrawParams do begin AEditButtonState := GetSpinEditPartState(TdxBarSpinEditDrawParams(BarEditControl.DrawParams), AButtonIndex); DrawButtonFrame(AEditButtonState, ARect, AContentRect); EditButtonDrawBackground(ADrawParams, AEditButtonState, ARect, 0); AArrowPos := GetSpinEditArrowPos(ADrawParams, AContentRect, AButtonIndex); DrawSpinEditArrow(ADrawParams, AArrowPos, AButtonIndex); end; end; procedure TdxBarSkinnedPainter.SpinEditControlDrawButtonsAdjacentZone(const ADrawParams: TdxBarSpinEditDrawParams; const ARect: TRect); begin SpinEditControlDrawButtonsExternalFrame(ADrawParams, ARect); end; procedure TdxBarSkinnedPainter.SpinEditControlDrawButtonsExternalFrame(const ADrawParams: TdxBarSpinEditDrawParams; ARect: TRect); var AEditState: Integer; AColor: TColor; begin with ADrawParams do begin AEditState := GetEditPartState(ADrawParams, ecpEdit); if not (HotPartIndex in ecpHeaderParts) and (HotPartIndex <> icpNone) then AColor := Skin.GetPartColor(DXBAR_EDIT_BUTTON_BORDER, DXBAR_ACTIVE) else if AEditState = DXBAR_DISABLED then AColor := Skin.GetPartColor(DXBAR_EDIT_BACKGROUND, DXBAR_DISABLED) else AColor := Skin.GetPartColor(DXBAR_EDIT_BACKGROUND, DXBAR_NORMAL); FrameRectByColor(Canvas.Handle, ARect, AColor); end; end; function TdxBarSkinnedPainter.GetSpinEditButtonIndents: TRect; begin Result := cxEmptyRect; end; procedure TdxBarSkinnedPainter.DrawStaticBorder(const ADrawParams: TdxBarStaticLikeControlDrawParams; var ARect: TRect); begin with ADrawParams do begin if BorderStyle = sbsNone then Exit; Canvas.FrameRect(ARect, Skin.GetPartColor(DXBAR_EDIT_BORDER)); InflateRect(ARect, -1, -1); end; end; class function TdxBarSkinnedPainter.StaticBackgroundIsOpaque(const ADrawParams: TdxBarItemControlDrawParams): Boolean; begin Result := False; end; procedure TdxBarSkinnedPainter.DrawSeparatorGlyphAndCaption(const ADrawParams: TdxBarSeparatorControlDrawParams; const ARect: TRect); var ACaptionRect: TRect; begin with ADrawParams do begin FillRectByColor(Canvas.Handle, ARect, Skin.GetPartColor(DXBAR_SEPARATOR_BACKGROUND)); ACaptionRect := ARect; ACaptionRect.Left := ACaptionRect.Left + SeparatorControlGetIndents(ADrawParams, cpText).Left; DrawItemText(BarItemControl, Canvas.Handle, Caption, ACaptionRect, SystemAlignmentsHorz[Alignment], Enabled, False, PaintType = ptVert, True, False); end; end; procedure TdxBarSkinnedPainter.DrawToolbarContentPart( ABarControl: TdxBarControl; ACanvas: TcxCanvas); var APrevWindowOrg: TPoint; DC: HDC; begin DC := ACanvas.Handle; with ABarControl.NCOffset do OffsetWindowOrgEx(DC, X, Y, APrevWindowOrg); try Skin.DrawBackground(DC, ABarControl.NCRect, DXBAR_TOOLBAR, GetBarControlState(ABarControl)); finally SetWindowOrgEx(DC, APrevWindowOrg.X, APrevWindowOrg.Y, nil); end; end; procedure TdxBarSkinnedPainter.DrawToolbarNonContentPart( ABarControl: TdxBarControl; DC: HDC); var ABarControlState: Integer; ACaptionRect: TRect; begin with ABarControl.ClientBounds do ExcludeClipRect(DC, Left, Top, Right, Bottom); ABarControlState := GetBarControlState(ABarControl); Skin.DrawBackground(DC, ABarControl.NCRect, DXBAR_TOOLBAR, ABarControlState); ACaptionRect := Skin.GetCaptionRect(ABarControl.NCRect, DXBAR_TOOLBAR); if ABarControl.CaptionButtons.Count > 0 then ACaptionRect.Right := ACaptionRect.Right - cxRectWidth(ABarControl.CaptionButtons.Rect) - Skin.GetContentOffsets(DXBAR_TOOLBAR).Right; Skin.DrawCaption(DC, ABarControl.GetCaption, ACaptionRect, DXBAR_TOOLBAR, ABarControlState); end; class function TdxBarSkinnedPainter.GetDefaultArrowSignSize: TSize; begin Result := Size(5, 4); end; class function TdxBarSkinnedPainter.GetControlTextIndents: TRect; begin Result := Rect(3, 0, 2, 0); end; class function TdxBarSkinnedPainter.GetControlCaptionRect(const ADrawParams: TdxBarItemControlDrawParams): TRect; begin if (ADrawParams.ViewSize = cvsLarge) and (ADrawParams.PaintType <> ptMenu) then Result := cxGetTextRect(ADrawParams.Canvas.Handle, ADrawParams.Caption + GetTextInsteadArrow(ADrawParams), GetMaxLineCount, True) else Result := inherited GetControlCaptionRect(ADrawParams); end; function TdxBarSkinnedPainter.GetLargeImageBounds(AItemControl: TdxBarItemControl; const AImageSize: TSize; const ADrawRect: TRect; APaintType: TdxBarPaintType; AViewStructure: TdxBarItemControlViewStructure; AGlyphLayout: TdxBarGlyphLayout): TRect; function GetImageOffset(const AImageSize: TSize): TSize; var ACaptionRect: TRect; begin ACaptionRect := GetControlCaptionRect(AItemControl.FDrawParams); Result.cx := (ADrawRect.Left + ADrawRect.Right - AImageSize.cx) div 2; Result.cy := (ADrawRect.Top + ADrawRect.Bottom - cxRectHeight(ACaptionRect) - AImageSize.cy) div 2; end; function GetCenterImageRect(const AImageSize: TSize): TRect; var AOffset: TSize; begin Result := Rect(0, 0, AImageSize.cx, AImageSize.cy); AOffset := GetImageOffset(AImageSize); OffsetRect(Result, AOffset.cx, AOffset.cy); end; function GetStretchImageRect: TRect; var ACaptionRect: TRect; AImageSize: Integer; begin ACaptionRect := GetControlCaptionRect(AItemControl.FDrawParams); AImageSize := Min(cxRectWidth(ADrawRect) - GetButtonBorderWidth, cxRectHeight(ADrawRect) - cxRectHeight(ACaptionRect) - GetButtonBorderHeight); Result := GetCenterImageRect(Size(AImageSize, AImageSize)); end; begin { if AItemControl.BarManager.ImageOptions.StretchGlyphs then Result := GetStretchImageRect else } Result := GetCenterImageRect(AImageSize); end; function TdxBarSkinnedPainter.GetDefaultEnabledTextColor( ABarItemControl: TdxBarItemControl; ASelected, AFlat: Boolean): TColor; begin Result := Skin.GetPartColor(DXBAR_ITEMTEXT, GetPartState(ABarItemControl.FDrawParams, icpControl)); end; function TdxBarSkinnedPainter.GetEnabledTextColor( ABarItemControl: TdxBarItemControl; ASelected, AFlat: Boolean): TColor; begin // Result := ABarItemControl.Parent.Font.Color; // if Result = clDefault then Result := inherited GetEnabledTextColor(ABarItemControl, ASelected, AFlat); end; procedure TdxBarSkinnedPainter.GetDisabledTextColors( ABarItemControl: TdxBarItemControl; ASelected, AFlat: Boolean; var AColor1, AColor2: TColor); begin AColor1 := GetDefaultEnabledTextColor(ABarItemControl, ASelected, AFlat); AColor2 := AColor1; end; function TdxBarSkinnedPainter.GetToolbarCaptionRect( const ARect: TRect): TRect; begin Result := Skin.GetCaptionRect(ARect, DXBAR_TOOLBAR); end; procedure TdxBarSkinnedPainter.InflateSizeForArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; var ASize: Integer); begin if (ADrawParams.PaintType <> ptMenu) and (ADrawParams.ViewSize = cvsSmall) and ADrawParams.IsDropDown then if ADrawParams.SplitDropDown then Inc(ASize, GetControlTextIndents.Right + ADrawParams.ArrowWidth) else Inc(ASize, ADrawParams.ArrowWidth); end; class function TdxBarSkinnedPainter.IsCompoundPainting: Boolean; begin Result := True; end; class function TdxBarSkinnedPainter.GetButtonPartState(const ADrawParams: TdxBarButtonLikeControlDrawParams; AControlPart: Integer): Integer; begin Result := DXBAR_NORMAL; if not ADrawParams.IsCustomizing then case AControlPart of bcpButton: if ADrawParams.IsPressed then Result := DXBAR_PRESSED else if ADrawParams.Downed then if (ADrawParams.HotPartIndex = AControlPart) or ADrawParams.SelectedByKey and not ADrawParams.IsDropDown then Result := DXBAR_HOTCHECK else Result := DXBAR_CHECKED else if ADrawParams.DroppedDown then if ADrawParams.IsDropDown and ADrawParams.SplitDropDown then Result := DXBAR_ACTIVE else Result := DXBAR_DROPPEDDOWN else Result := GetPartState(ADrawParams, AControlPart); bcpDropButton: if ADrawParams.DroppedDown then Result := DXBAR_DROPPEDDOWN else if ADrawParams.Downed and (ADrawParams.HotPartIndex = icpNone) and not ADrawParams.SelectedByKey then Result := DXBAR_CHECKED else Result := GetPartState(ADrawParams, AControlPart); end else if ADrawParams.Downed then Result := DXBAR_CHECKED else if ADrawParams.DroppedDown then Result := DXBAR_DROPPEDDOWN; end; class function TdxBarSkinnedPainter.GetEditPartState(const ADrawParams: TdxBarEditLikeControlDrawParams; AControlPart: Integer): Integer; begin Result := DXBAR_NORMAL; if not ADrawParams.IsCustomizing then case AControlPart of ecpEdit: if ADrawParams.DroppedDown then Result := DXBAR_DROPPEDDOWN else if ADrawParams.Focused then Result := DXBAR_FOCUSED else Result := GetPartState(ADrawParams, AControlPart, ecpHeaderParts); ccpDropButton: if ADrawParams.DroppedDown then Result := DXBAR_DROPPEDDOWN else if ADrawParams.IsPressed and (ADrawParams.HotPartIndex = AControlPart) or ADrawParams.Focused then Result := DXBAR_HOT else Result := GetPartState(ADrawParams, AControlPart, ecpHeaderParts); clcpCustomColorButton: if ADrawParams.IsPressed then Result := DXBAR_PRESSED else if ADrawParams.DroppedDown or ADrawParams.Focused then Result := DXBAR_HOT else Result := GetPartState(ADrawParams, AControlPart, ecpHeaderParts); end; end; class function TdxBarSkinnedPainter.GetSpinEditPartState(const ADrawParams: TdxBarSpinEditDrawParams; AControlPart: Integer): Integer; begin Result := DXBAR_NORMAL; if not ADrawParams.IsCustomizing then if (AControlPart = ADrawParams.ActiveButtonIndex) and (AControlPart = ADrawParams.HotPartIndex) then Result := DXBAR_DROPPEDDOWN else begin Result := GetPartState(ADrawParams, AControlPart, ecpHeaderParts); if (Result = DXBAR_ACTIVE) and ((ADrawParams.HotPartIndex = icpNone) or (ADrawParams.HotPartIndex in ecpHeaderParts)) then Result := DXBAR_NORMAL; end; end; class function TdxBarSkinnedPainter.GetPartState( const ADrawParams: TdxBarItemControlDrawParams; AControlPart: Integer; AForbiddenParts: TdxByteSet = []): Integer; function IsControlSelected: Boolean; begin Result := ADrawParams.DrawSelected; { Result := ADrawParams.SelectedByKey or (ADrawParams.HotPartIndex <> icpNone) and (not (ADrawParams.HotPartIndex in AForbiddenParts) or (ADrawParams.PaintType = ptMenu)); } end; begin if (ADrawParams.HotPartIndex = AControlPart) and ADrawParams.CanSelect then Result := DXBAR_HOT else if ADrawParams.CanSelect and IsControlSelected then if not ADrawParams.Enabled then Result := DXBAR_ACTIVEDISABLED else Result := DXBAR_ACTIVE else if not ADrawParams.Enabled then Result := DXBAR_DISABLED else Result := DXBAR_NORMAL; end; function TdxBarSkinnedPainter.GetBarControlState( ABarControl: TdxBarControl): Integer; const BarControlStates: array [TdxBarViewState] of Integer = (DXBAR_NORMAL, DXBAR_HOT); begin Result := BarControlStates[ABarControl.ViewState]; end; class function TdxBarSkinnedPainter.GetBarItemContolHintPosition( ABarControl: TCustomdxBarControl; const AItemBounds: TRect; const ACursorPos: TPoint; AHeight: Integer): TPoint; var R: TRect; begin Result := inherited GetBarItemContolHintPosition(ABarControl, AItemBounds, ACursorPos, AHeight); R := AItemBounds; MapWindowRect(ABarControl.Handle, 0, R); ABarControl.AdjustHintWindowPosition(Result, R, AHeight); end; function TdxBarSkinnedPainter.CreateHintViewInfo(ABarManager: TdxBarManager; AHintText: string; const AShortCut: string; AScreenTip: TdxBarScreenTip): TdxBarCustomHintViewInfo; begin Result := dxBarCreateScreenTipViewInfo(ABarManager, AHintText, AShortCut, AScreenTip, FSkinnedObject); end; procedure TdxBarSkinnedPainter.ButtonLikeControlDoDrawCaption( const ADrawParams: TdxBarButtonLikeControlDrawParams; const ATextBounds: TRect; ATextAlignment: DWORD); procedure DrawArrowInEnd(ALastLine: string; var ARectOut: TRect); var ATextRect, AArrowRect, ATextArrowRect: TRect; begin if ALastLine <> '' then begin ATextRect := cxGetTextRect(ADrawParams.Canvas.Handle, ALastLine, 1); ALastLine := ALastLine + GetTextInsteadArrow(ADrawParams); ATextArrowRect := cxGetTextRect(ADrawParams.Canvas.Handle, ALastLine, 1); ARectOut := cxRectOffset(ATextArrowRect, ARectOut.Left + (cxRectWidth(ARectOut) - cxRectWidth(ATextArrowRect)) div 2, ARectOut.Top); AArrowRect := ARectOut; AArrowRect.Left := AArrowRect.Right - GetDefaultArrowSignSize.cx; ARectOut.Right := ARectOut.Left + cxRectWidth(ATextRect); end else AArrowRect := ARectOut; DrawArrow(ADrawParams.Canvas.Handle, AArrowRect, GetButtonPartState(ADrawParams, bcpDropButton)); end; var ALines: TStrings; I, ATextHeight: Integer; ARectOut: TRect; AColor1, AColor2: TColor; begin with ADrawParams do begin SetBkMode(Canvas.Handle, TRANSPARENT); if BarItemControl <> nil then GetTextColors(BarItemControl, Enabled, DrawSelected, IsFlatText, AColor1, AColor2) else AColor1 := Skin.GetPartColor(DXBAR_ITEMTEXT, GetPartState(ADrawParams, icpControl)); SetTextColor(Canvas.Handle, AColor1); ARectOut := ATextBounds; if ViewSize = cvsLarge then begin ALines := TStringList.Create; try cxGetTextLines(Caption, Canvas, ATextBounds, ALines); for I := ALines.Count + 1 to GetMaxLineCount do ALines.Add(''); ATextHeight := cxTextSize(Canvas.Handle, 'Wg').cy; ARectOut.Bottom := ARectOut.Top + ATextHeight; for I := 0 to ALines.Count - 1 do begin if (I = ALines.Count - 1) and IsDropDown then DrawArrowInEnd(ALines[I], ARectOut); cxDrawText(Canvas.Handle, ALines[I], ARectOut, DT_SINGLELINE or ATextAlignment); OffsetRect(ARectOut, 0, ATextHeight); end; finally ALines.Free; end; end else cxDrawText(Canvas.Handle, Caption, ARectOut, DT_SINGLELINE or ATextAlignment); SetBkMode(Canvas.Handle, OPAQUE); end; end; procedure TdxBarSkinnedPainter.ButtonLikeControlDrawMenuArrow(const ADrawParams: TdxBarButtonLikeControlDrawParams; ADirection: TcxArrowDirection; ARect: TRect); var AArrowRect: TRect; ARatio: Double; APart: Integer; begin ARatio := ADrawParams.BarItemControl.Parent.Ratio; ARect := GetArrowRect(ADrawParams, ARect); if ADirection = adRight then begin AArrowRect := Rect(0, 0, Round(4 * ARatio), Trunc(7 * ARatio)); APart := DXBAR_MENUARROWRIGHT; end else begin AArrowRect := Rect(0, 0, Trunc(7 * ARatio), Round(4 * ARatio)); APart := DXBAR_MENUARROWDOWN; end; OffsetRect(AArrowRect, ARect.Left + (cxRectWidth(ARect) - cxRectWidth(AArrowRect)) div 2, ARect.Top + (cxRectHeight(ARect) - cxRectHeight(AArrowRect)) div 2); Skin.DrawBackground(ADrawParams.Canvas.Handle, AArrowRect, APart, DXBAR_NORMAL); end; procedure TdxBarSkinnedPainter.DrawSpinEditArrow(const ADrawParams: TdxBarSpinEditDrawParams; AArrowPos: TPoint; AButtonIndex: Integer); var P: TcxArrowPoints; AArrowDirection: TcxArrowDirection; begin case AButtonIndex of secButtonUp: AArrowDirection := adUp; else {secButtonDown} AArrowDirection := adDown; end; CalculateArrowPoints(ADrawParams.BarEditControl.FParts[AButtonIndex], ADrawParams.ArrowSize.cy, AArrowDirection, P); ADrawParams.Canvas.SaveClipRegion; try SetArrowRegion(ADrawParams.Canvas, AArrowDirection, P, roSet); Skin.DrawBackground(ADrawParams.Canvas.Handle, GetArrowRectByPoints(P, AArrowDirection), DXBAR_SCROLLARROW); finally ADrawParams.Canvas.RestoreClipRegion; end; SetArrowRegion(ADrawParams.Canvas, AArrowDirection, P, roSubtract); end; procedure TdxBarSkinnedPainter.SubMenuControlDrawMark(ABarSubMenuControl: TdxBarSubMenuControl; DC: HDC; R: TRect; ASelected: Boolean); begin Skin.DrawBackground(DC, SubMenuControlGetMarkRect(R), DXBAR_MENUMARK); end; procedure TdxBarSkinnedPainter.SubMenuControlDrawMarkSelection( ABarSubMenuControl: TdxBarSubMenuControl; ADC: HDC; const AMarkRect: TRect); begin Skin.DrawBackground(ADC, AMarkRect, DXBAR_SMALLBUTTON, DXBAR_HOT); end; procedure TdxBarSkinnedPainter.SubMenuControlFillScrollArrow(ACanvas: TcxCanvas; ARect: TRect; AColor: TColor); begin Skin.DrawBackground(ACanvas.Handle, ARect, DXBAR_SCROLLARROW); end; function TdxBarSkinnedPainter.SubMenuControlGetScrollBandSize(ABarSubMenuControl: TdxBarSubMenuControl): Integer; begin Result := inherited SubMenuControlGetScrollBandSize(ABarSubMenuControl); Result := (Result - 6) * 3 div 4; end; class function TdxBarSkinnedPainter.SubMenuControlGetScrollArrowSize(ATextSize: Integer): Integer; begin Result := ATextSize div 7; end; class function TdxBarSkinnedPainter.SubMenuControlUseScrollButtons: Boolean; begin Result := True; end; function TdxBarSkinnedPainter.GetSkin: IdxSkin; begin Supports(FSkinnedObject, IdxSkin, Result); end; procedure TdxBarSkinnedPainter.DrawButtonBackground( const ADrawParams: TdxBarButtonLikeControlDrawParams); procedure InternalDrawBackground(AControlPart, ASkinPart: Integer); function GetButtonGroupPosition: TdxBarButtonGroupRealPosition; begin Result := ADrawParams.ButtonGroup; if ADrawParams.SplitDropDown and ADrawParams.IsDropDown then case AControlPart of bcpButton: case Result of bgrpFinish: Result := bgrpMember; bgrpSingle: Result := bgrpStart; end; bcpDropButton: case Result of bgrpStart: Result := bgrpMember; bgrpSingle: Result := bgrpFinish; end; end end; procedure CalculateRects(var APartRect: TRect; out ALeftBorderRect, ARightBorderRect, AMiddleButtonRect, ASplitRect: TRect); begin ALeftBorderRect := APartRect; ALeftBorderRect.Right := ALeftBorderRect.Left + 2; ASplitRect := APartRect; ASplitRect.Left := ASplitRect.Left - 1; ASplitRect.Right := ASplitRect.Left + 2; ARightBorderRect := APartRect; ARightBorderRect.Left := ARightBorderRect.Right - 2; AMiddleButtonRect := APartRect; AMiddleButtonRect.Left := AMiddleButtonRect.Right - 1; case GetButtonGroupPosition of bgrpNone: begin ALeftBorderRect := cxEmptyRect; ARightBorderRect := cxEmptyRect; ASplitRect := cxEmptyRect; AMiddleButtonRect := cxEmptyRect; end; bgrpStart: begin ARightBorderRect := cxEmptyRect; APartRect.Left := APartRect.Left + 1; end; bgrpMember: begin ALeftBorderRect := cxEmptyRect; ARightBorderRect := cxEmptyRect; end; bgrpFinish: begin ALeftBorderRect := cxEmptyRect; AMiddleButtonRect := cxEmptyRect; APartRect.Right := APartRect.Right - 1; end; bgrpSingle: begin AMiddleButtonRect := cxEmptyRect; APartRect.Left := APartRect.Left + 1; APartRect.Right := APartRect.Right - 1; end; end; end; var APartState: Integer; APartRect, ALeftBorderRect, ARightBorderRect, AMiddleButtonRect, ASplitRect: TRect; begin with ADrawParams do begin APartState := GetButtonPartState(ADrawParams, AControlPart); APartRect := BarItemControl.FParts[AControlPart]; CalculateRects(APartRect, ALeftBorderRect, ARightBorderRect, AMiddleButtonRect, ASplitRect); Skin.DrawBackground(Canvas.Handle, APartRect, ASkinPart, APartState); Skin.DrawBackground(Canvas.Handle, ALeftBorderRect, DXBAR_BUTTONGROUPBORDERLEFT); Skin.DrawBackground(Canvas.Handle, ARightBorderRect, DXBAR_BUTTONGROUPBORDERRIGHT); if SplitDropDown and IsDropDown then begin if AControlPart = bcpDropButton then begin Skin.DrawBackground(Canvas.Handle, ASplitRect, DXBAR_BUTTONGROUPSPLITBUTTONSEPARATOR, APartState); Skin.DrawBackground(Canvas.Handle, AMiddleButtonRect, DXBAR_BUTTONGROUPBORDERMIDDLE, APartState); end; end else Skin.DrawBackground(Canvas.Handle, AMiddleButtonRect, DXBAR_BUTTONGROUPBORDERMIDDLE, APartState); end; end; var AButtonPart, AGlyphPart, ADropButtonPart: Integer; begin with ADrawParams do begin if ViewSize = cvsSmall then begin if ButtonGroup = bgrpNone then begin AButtonPart := DXBAR_SMALLBUTTON; AGlyphPart := DXBAR_SMALLBUTTON_GLYPH; ADropButtonPart := DXBAR_SMALLBUTTON_DROPBUTTON; end else begin AButtonPart := DXBAR_BUTTONGROUP; AGlyphPart := DXBAR_BUTTONGROUP; ADropButtonPart := DXBAR_BUTTONGROUP; end; end else begin AButtonPart := DXBAR_LARGEBUTTON; AGlyphPart := DXBAR_LARGEBUTTON_GLYPH; ADropButtonPart := DXBAR_LARGEBUTTON_DROPBUTTON; end; if SplitDropDown and IsDropDown then begin InternalDrawBackground(bcpButton, AGlyphPart); InternalDrawBackground(bcpDropButton, ADropButtonPart); end else InternalDrawBackground(bcpButton, AButtonPart); end; end; function TdxBarSkinnedPainter.GetArrowRect(const ADrawParams: TdxBarButtonLikeControlDrawParams; const ARect: TRect): TRect; var AArrowRectWidth: Integer; begin Result := ARect; AArrowRectWidth := ADrawParams.ArrowWidth; if ADrawParams.PaintType <> ptMenu then Result.Right := Result.Right - GetBorderSize; Result.Left := Result.Right - AArrowRectWidth; end; class function TdxBarSkinnedPainter.GetTextInsteadArrow(const ADrawParams: TdxBarItemControlDrawParams): string; begin Result := ''; if ADrawParams.IsDropDown then begin while GetDefaultArrowSignSize.cx > cxTextSize(ADrawParams.Canvas.Handle, Result).cx do Result := Result + '.'; Result := ' ' + Result; end; end; class function TdxBarSkinnedPainter.GetMaxLineCount: Integer; begin Result := 2; end; procedure TdxBarSkinnedPainter.InternalDrawBeginGroup(DC: HDC; const ABeginGroupRect: TRect; AHorz: Boolean; AColor1, AColor2: TColor); var R: TRect; begin { TODO: Skin.GetPartColor or Skin.DrawBackground - DXBAR_ITEMSEPARATOR } if AHorz then begin R := cxRectCenter(ABeginGroupRect, cxRectWidth(ABeginGroupRect), 1); FillRectByColor(DC, R, AColor2); FillRectByColor(DC, cxRectOffset(R, 0, 1), AColor1); end else begin R := cxRectCenter(ABeginGroupRect, 1, cxRectHeight(ABeginGroupRect)); FillRectByColor(DC, R, AColor1); FillRectByColor(DC, cxRectOffset(R, 1, 0), AColor2); end; end; procedure TdxBarSkinnedPainter.InternalDrawEditButton( const ADrawParams: TdxBarEditLikeControlDrawParams; APartIndex: Integer; ARect: TRect); var AContentRect: TRect; AState: Integer; begin AState := GetEditPartState(ADrawParams, APartIndex); EditButtonDrawBorder(ADrawParams, AState, ARect, AContentRect); EditButtonDrawBackground(ADrawParams, AState, ARect, 0); case APartIndex of ccpDropButton: DrawArrow(ADrawParams.Canvas.Handle, AContentRect, AState); clcpCustomColorButton: DrawDots(ADrawParams, AContentRect); end; end; { TRegItemRecord } constructor TRegItemRecord.Create(AItemClass: TdxBarItemClass; AItemControlClass: TdxBarItemControlClass; AVisible: Boolean); begin FItemClass := AItemClass; FItemControlClass := AItemControlClass; FVisible := AVisible; end; { TdxBarItemList } destructor TdxBarItemList.Destroy; var I: Integer; begin for I := Count - 1 downto 0 do Unregister(I); inherited Destroy; end; procedure TdxBarItemList.Register(AItemClass: TdxBarItemClass; AItemControlClass: TdxBarItemControlClass; AVisible: Boolean); var ARecord: TRegItemRecord; begin ARecord := TRegItemRecord.Create(AItemClass, AItemControlClass, AVisible); Add(ARecord); RegisterClass(ARecord.FItemClass); end; procedure TdxBarItemList.Unregister(AItemClass: TdxBarItemClass); var I: Integer; begin for I := 0 to Count - 1 do if ItemClass[I] = AItemClass then begin Unregister(I); Break; end; end; procedure TdxBarItemList.Unregister(Index: Integer); var ARecord: TRegItemRecord; begin ARecord := Items[Index]; UnregisterClass(ARecord.FItemClass); Delete(Index); ARecord.Free; end; function TdxBarItemList.GetItem(Index: Integer): TRegItemRecord; begin Result := TRegItemRecord(inherited Items[Index]); end; function TdxBarItemList.GetItemClass(Index: Integer): TdxBarItemClass; begin Result := Items[Index].FItemClass; end; function TdxBarItemList.GetVisibleItemCount: Integer; var I: Integer; begin Result := 0; for I := 0 to Count - 1 do if Items[I].FVisible then Inc(Result); end; function TdxBarItemList.GetVisibleItemClass(Index: Integer): TdxBarItemClass; var VisibleIndex, I: Integer; begin Result := nil; VisibleIndex := -1; for I := 0 to Count - 1 do begin if Items[I].FVisible then Inc(VisibleIndex); if VisibleIndex = Index then begin Result := ItemClass[I]; Exit; end; end; end; { TdxBarNavigationController } destructor TdxBarNavigationController.Destroy; begin FreeAndNil(FKeyTipsShowingState.KeyTipsData); EndKeyTipsWaiting(False); inherited Destroy; end; procedure TdxBarNavigationController.BeginKeyTipsWaiting( ARootObject: IdxBarAccessibilityHelper); begin if (ARootObject = nil) or IsKeyTipsWaiting and (ARootObject.GetHelper <> FKeyTipsWaitingRootObject.GetHelper) then raise Exception.Create(''); if not IsKeyTipsWaiting then begin FKeyTipsWaitingRootObject := ARootObject; FKeyTipsWaitingTimer := TcxTimer.Create(nil); FKeyTipsWaitingTimer.Interval := dxBarWaitForKeyTipsTime; FKeyTipsWaitingTimer.OnTimer := KeyTipsWaitingTimerHandler; end; end; procedure TdxBarNavigationController.ChangeSelectedObject( ASetFocus: Boolean; ANewSelectedObject: IdxBarAccessibilityHelper; APrevSelectedObject: IdxBarAccessibilityHelper = nil); begin if ANewSelectedObject = nil then Exit; if APrevSelectedObject = nil then APrevSelectedObject := SelectedObject; if ANewSelectedObject <> APrevSelectedObject then begin if APrevSelectedObject <> nil then APrevSelectedObject.Unselect(ANewSelectedObject); ANewSelectedObject.Select(ASetFocus); end; end; procedure TdxBarNavigationController.EndKeyTipsWaiting( AShowKeyTipWindows: Boolean); begin if FKeyTipsWaitingTimer <> nil then begin if AShowKeyTipWindows then begin FKeyTipsWaitingTimer.Enabled := False; SetKeyTipsShowingState(FKeyTipsWaitingRootObject, ''); end; DestroyKeyTipsWaitingTimer; end; end; procedure TdxBarNavigationController.HandleKey(AKey: Word; ASelectedObjectParent: IdxBarAccessibilityHelper = nil; ASelectedObject: IdxBarAccessibilityHelper = nil); function GetNavigationDirection: TcxAccessibilityNavigationDirection; begin Result := andLeft; case AKey of VK_LEFT: Result := andLeft; VK_RIGHT: Result := andRight; VK_UP: Result := andUp; VK_DOWN: Result := andDown; end; end; var AIsKeyAcceptable: Boolean; AKeyTargetObject, ANextSelectedObject: IdxBarAccessibilityHelper; AKeyTipData: TdxBarKeyTipData; begin if IsKeyTipsWaiting then begin if IsKeyTipsKey(AKey, AIsKeyAcceptable, AKeyTipData) then begin if not AIsKeyAcceptable then Exit; FKeyTipsWaitingTimer.Enabled := False; HandleKeyTipKey(AKey); EndKeyTipsWaiting(False); Exit; end; end; if KeyTipsHandlingMode and (AKey <> VK_ESCAPE) then if IsKeyTipsKey(AKey, AIsKeyAcceptable, AKeyTipData) then begin if AIsKeyAcceptable then HandleKeyTipKey(AKey); Exit; end else StopKeyTipsHandlingMode; if ASelectedObjectParent = nil then ASelectedObjectParent := SelectedObjectParent; if ASelectedObject = nil then ASelectedObject := SelectedObject; AKeyTargetObject := ASelectedObject; if AKeyTargetObject = nil then AKeyTargetObject := ASelectedObjectParent; if (AKey = VK_ESCAPE) and KeyTipsHandlingMode then KeyTipsEscapeHandler else if AKey in [VK_MENU, VK_F10, VK_ESCAPE] then begin if not ((AKey = VK_ESCAPE) and AKeyTargetObject.HandleNavigationKey(AKey)) then AKeyTargetObject.Unselect(nil); end else if not AKeyTargetObject.HandleNavigationKey(AKey) then begin if ASelectedObject = nil then ANextSelectedObject := ASelectedObjectParent.GetBarHelper.GetFirstSelectableObject else begin if AKey = VK_TAB then ANextSelectedObject := ASelectedObject.LogicalNavigationGetNextAccessibleObject(GetKeyState(VK_SHIFT) >= 0) else ANextSelectedObject := ASelectedObject.GetNextAccessibleObject(GetNavigationDirection); end; ChangeSelectedObject(AKey = VK_TAB, ANextSelectedObject, ASelectedObject); end; end; function TdxBarNavigationController.IsKeyTipsKey(AKey: Word): Boolean; var AIsKeyAcceptable: Boolean; AKeyTipData: TdxBarKeyTipData; begin Result := IsKeyTipsKey(AKey, AIsKeyAcceptable, AKeyTipData); end; function TdxBarNavigationController.IsKeyTipsWaiting: Boolean; begin Result := FKeyTipsWaitingTimer <> nil; end; function TdxBarNavigationController.IsNavigationKey(AKey: Word): Boolean; begin Result := (AKey in [VK_LEFT, VK_RIGHT, VK_UP, VK_DOWN]) or (AKey = VK_TAB) and (GetKeyState(VK_CONTROL) >= 0); end; function TdxBarNavigationController.NeedsKey(AKey: Word): Boolean; begin Result := IsNavigationControllerKey(AKey) and (SelectedObjectParent <> nil) and SelectedObjectParent.CanNavigateToChildren(AKey) or (IsKeyTipsWaiting or KeyTipsHandlingMode) and IsKeyTipsKey(AKey); end; procedure TdxBarNavigationController.SelectDefaultObject( ARootObject: IdxBarAccessibilityHelper); var ADefaultObject: IdxBarAccessibilityHelper; begin ADefaultObject := ARootObject.GetDefaultAccessibleObject; if ADefaultObject <> nil then begin FNavigationMode := True; ADefaultObject.Select(False); end; end; procedure TdxBarNavigationController.SetKeyTipsShowingState( AActiveKeyTipContainer: IdxBarAccessibilityHelper; const AKeyTipsTypingString: string); function GetHelperInstance( AHelper: IdxBarAccessibilityHelper): TObject; begin Result := nil; if AHelper <> nil then Result := AHelper.GetBarHelper; end; procedure SynchronizeKeyTipWindows; var AKeyTipData: TdxBarKeyTipData; AKeyTipWindowsManager: IdxBarKeyTipWindowsManager; I: Integer; begin FKeyTipsShowingState.ActiveContainer.AreKeyTipsSupported(AKeyTipWindowsManager); for I := 0 to FKeyTipsShowingState.KeyTipsData.Count - 1 do begin AKeyTipData := TdxBarKeyTipData(FKeyTipsShowingState.KeyTipsData[I]); if not AKeyTipData.Visible then Continue; if (FKeyTipsShowingState.TypingString = '') or (Pos(FKeyTipsShowingState.TypingString, AKeyTipData.NormalizedKeyTip) = 1) then AKeyTipData.ShowKeyTipWindow(AKeyTipWindowsManager) else AKeyTipData.HideKeyTipWindow(AKeyTipWindowsManager); end; AKeyTipWindowsManager.Show; end; var AKeyTipWindowsManager: IdxBarKeyTipWindowsManager; ANewContainer, APrevContainer: TObject; I: Integer; begin APrevContainer := GetHelperInstance(FKeyTipsShowingState.ActiveContainer); ANewContainer := GetHelperInstance(AActiveKeyTipContainer); if ANewContainer <> APrevContainer then begin if FKeyTipsShowingState.ActiveContainer <> nil then begin FKeyTipsShowingState.ActiveContainer.AreKeyTipsSupported(AKeyTipWindowsManager); for I := 0 to FKeyTipsShowingState.KeyTipsData.Count - 1 do TdxBarKeyTipData(FKeyTipsShowingState.KeyTipsData[I]).HideKeyTipWindow(AKeyTipWindowsManager); FreeAndNil(FKeyTipsShowingState.KeyTipsData); end; FKeyTipsShowingState.ActiveContainer := AActiveKeyTipContainer; FKeyTipsShowingState.TypingString := ''; if FKeyTipsShowingState.ActiveContainer <> nil then begin FKeyTipsShowingState.ActiveContainer.AreKeyTipsSupported(AKeyTipWindowsManager); FKeyTipsShowingState.TypingString := AnsiUpperCase(AKeyTipsTypingString); FKeyTipsShowingState.KeyTipsData := TdxObjectList.Create; FKeyTipsShowingState.ActiveContainer.GetBarHelper.GetKeyTipsData(FKeyTipsShowingState.KeyTipsData); SynchronizeKeyTipWindows; end; end else if not AnsiSameText(FKeyTipsShowingState.TypingString, AKeyTipsTypingString) then begin FKeyTipsShowingState.TypingString := AnsiUpperCase(AKeyTipsTypingString); SynchronizeKeyTipWindows; end; end; procedure TdxBarNavigationController.StopKeyboardHandling; begin UnselectAssignedSelectedObject; if SelectedObject <> nil then SelectedObject.Unselect(nil); StopKeyTipsHandlingMode; end; procedure TdxBarNavigationController.UnassignObject( AObject: IdxBarAccessibilityHelper); begin if (FSelectedObject <> nil) and (AObject.GetHelper = FSelectedObject.GetHelper) then FSelectedObject := nil; if (FSelectedObjectParent <> nil) and (AObject.GetHelper = FSelectedObjectParent.GetHelper) then begin FSelectedObject := nil; FSelectedObjectParent := nil; end; if (FKeyTipsShowingState.ActiveContainer <> nil) and (FKeyTipsShowingState.ActiveContainer.GetHelper = AObject.GetHelper) then SetKeyTipsShowingState(nil, ''); end; procedure TdxBarNavigationController.UnselectAssignedSelectedObject; begin if BarNavigationController.AssignedSelectedObject <> nil then BarNavigationController.AssignedSelectedObject.Unselect(nil); end; procedure TdxBarNavigationController.ResetNavigationMode; begin FNavigationMode := False; end; procedure TdxBarNavigationController.DestroyKeyTipsWaitingTimer; begin FreeAndNil(FKeyTipsWaitingTimer); end; function TdxBarNavigationController.GetActiveBarControl: TCustomdxBarControl; begin if ActiveBarControl = nil then Result := BarDesignController.QuickControl else if IsActiveBarControlAccessible and not ActiveBarControl.IsCustomizing then Result := ActiveBarControl else Result := nil; end; function TdxBarNavigationController.GetKeyTipsHandlingMode: Boolean; begin Result := FKeyTipsShowingState.ActiveContainer <> nil; end; function TdxBarNavigationController.GetSelectedObject: IdxBarAccessibilityHelper; var AActiveBarControl: TCustomdxBarControl; begin AActiveBarControl := GetActiveBarControl; if AActiveBarControl <> nil then begin if AActiveBarControl.SelectedControl <> nil then Result := AActiveBarControl.SelectedControl.IAccessibilityHelper else Result := FSelectedObject; end else Result := FSelectedObject; end; function TdxBarNavigationController.GetSelectedObjectParent: IdxBarAccessibilityHelper; begin if GetActiveBarControl <> nil then Result := GetActiveBarControl.IAccessibilityHelper else Result := FSelectedObjectParent; end; procedure TdxBarNavigationController.HandleKeyTipKey(AKey: Word); var AIsKeyAcceptable: Boolean; AKeyTipData: TdxBarKeyTipData; AKeyTipContainer: IdxBarAccessibilityHelper; begin IsKeyTipsKey(AKey, AIsKeyAcceptable, AKeyTipData); if AKeyTipData <> nil then begin if AKeyTipData.Enabled and Assigned(AKeyTipData.OnExecute) then AKeyTipData.OnExecute(nil); end else begin AKeyTipContainer := FKeyTipsShowingState.ActiveContainer; if AKeyTipContainer = nil then AKeyTipContainer := FKeyTipsWaitingRootObject; SetKeyTipsShowingState(AKeyTipContainer, FKeyTipsShowingState.TypingString + Char(AKey)); end; end; function TdxBarNavigationController.IsKeyTipsKey(AKey: Word; out AIsKeyAcceptable: Boolean; out AKeyTipData: TdxBarKeyTipData): Boolean; var AKeyTipsData: TdxObjectList; AKeyTipsTypingString: string; I: Integer; begin Result := KeyTipsHandlingMode and (AKey = VK_ESCAPE); if Result then Exit; Result := IsTextCharKeyDown(AKey); if not Result then Exit; AIsKeyAcceptable := False; AKeyTipData := nil; AKeyTipsData := nil; try if FKeyTipsShowingState.ActiveContainer = nil then begin AKeyTipsData := TdxObjectList.Create; FKeyTipsWaitingRootObject.GetBarHelper.GetKeyTipsData(AKeyTipsData); AKeyTipsTypingString := ''; end else begin AKeyTipsData := FKeyTipsShowingState.KeyTipsData; AKeyTipsTypingString := FKeyTipsShowingState.TypingString; end; AKeyTipsTypingString := AKeyTipsTypingString + AnsiUpperCase(Char(AKey)); for I := 0 to AKeyTipsData.Count - 1 do if AnsiPos(AKeyTipsTypingString, TdxBarKeyTipData(AKeyTipsData[I]).NormalizedKeyTip) = 1 then begin AIsKeyAcceptable := True; if AnsiSameStr(AKeyTipsTypingString, TdxBarKeyTipData(AKeyTipsData[I]).NormalizedKeyTip) then AKeyTipData := TdxBarKeyTipData(AKeyTipsData[I]); Break; end; finally if FKeyTipsShowingState.ActiveContainer = nil then FreeAndNil(AKeyTipsData); end; end; function TdxBarNavigationController.IsNavigationControllerKey(AKey: Word): Boolean; begin Result := IsNavigationKey(AKey) or (AKey = VK_MENU) or (AKey = VK_F10) and (SelectedObjectParent <> nil) and SelectedObjectParent.GetBarManager.UseF10ForMenu; if SelectedObject <> nil then Result := Result or SelectedObject.IsNavigationKey(AKey); end; procedure TdxBarNavigationController.KeyTipsEscapeHandler; begin HandleKeyTipsEscape(FKeyTipsShowingState.ActiveContainer); end; procedure TdxBarNavigationController.KeyTipsWaitingTimerHandler(Sender: TObject); begin EndKeyTipsWaiting(True); end; procedure TdxBarNavigationController.StopKeyTipsHandlingMode; begin EndKeyTipsWaiting(False); SetKeyTipsShowingState(nil, ''); end; procedure RetrieveWindowsVersion; var Info: TOSVersionInfo; begin Info.dwOSVersionInfoSize := SizeOf(Info); GetVersionEx(Info); IsWin95Or98 := Info.dwPlatformId = VER_PLATFORM_WIN32_WINDOWS; IsWin95 := IsWin95Or98 and (Info.dwMinorVersion = 0); IsWin98Or2000 := (Info.dwPlatformId = VER_PLATFORM_WIN32_WINDOWS) and (Info.dwMinorVersion <> 0) or (Info.dwPlatformId = VER_PLATFORM_WIN32_NT) and (Info.dwMajorVersion = 5); end; initialization RegisterClasses([TdxBar, TdxBarGroup, TdxBarScreenTip, TdxBarScreenTipBand, TdxBarScreenTipCollection, TdxBarApplicationMenuButtons, TdxBarApplicationMenuButton]); RetrieveWindowsVersion; FUser32DLL := LoadLibrary('USER32'); if FUser32DLL > 32 then begin @UpdateLayeredWindow := GetProcAddress(FUser32DLL, 'UpdateLayeredWindow'); @AnimateWindowProc := GetProcAddress(FUser32DLL, 'AnimateWindow'); @SetLayeredWindowAttributes := GetProcAddress(FUser32DLL, 'SetLayeredWindowAttributes'); end; GetMem(AClassName, 256); dxBarManagerList := TdxBarManagerList.Create; RefreshDeviceConsts; CreatePatternBrush; FBarControls := TList.Create; FBarNavigationController := TdxBarNavigationController.Create; dxBarRegisterItem(TdxBarButton, TdxBarButtonControl, True); dxBarRegisterItem(TdxBarEdit, TdxBarEditControl, True); dxBarRegisterItem(TCustomdxBarCombo, TCustomdxBarComboControl, True); dxBarRegisterItem(TdxBarCombo, TdxBarComboControl, True); dxBarRegisterItem(TdxBarSubItem, TdxBarSubItemControl, True); dxBarRegisterItem(TdxBarListItem, TdxBarContainerItemControl, True); dxBarRegisterItem(TdxBarContainerItem, TdxBarContainerItemControl, True); dxBarRegisterItem(TdxBarExtraPaneListItem, TdxBarContainerItemControl, False); dxBarRegisterItem(TdxBarLabel, TdxBarCustomStaticControl, False); dxBarRegisterItem(TdxBarSeparator, TdxBarSeparatorControl, True); dxBarRegisterItem(TdxBarApplicationMenuButtonItem, TdxBarApplicationMenuButtonControl, False); dxBarRegisterItem(TdxBarQuickCustExtButton, TdxBarQuickCustExtButtonControl, False); dxBarRegisterItem(TdxBarQuickCustItem, TdxBarQuickCustItemControl, False); dxBarRegisterItem(TdxBarQuickAccessItem, TdxBarSubItemControl, False); dxBarRegisterItem(TSystemMenuSubItem, TSystemMenuSubItemControl, False); BarDesignController.RegisterBarControlEditor(TdxAddSubItemEditor); BarDesignController.RegisterBarControlEditor(TdxAddButtonEditor); BarDesignController.RegisterBarControlEditor(TdxItemsEditorEx); BarDesignController.RegisterBarControlDesignHelper(TdxBarControl, TdxBarControlDesignHelper); BarDesignController.RegisterBarControlDesignHelper(TdxBarSubMenuControl, TdxBarSubMenuControlDesignHelper); BarDesignController.RegisterBarControlDesignHelper(TdxBarApplicationMenuControl, TdxBarApplicationMenuControlDesignHelper); Screen.Cursors[crdxBarDrag] := LoadCursor(HInstance, 'DXBARDRAGCURSOR'); Screen.Cursors[crdxBarDragCopy] := LoadCursor(HInstance, 'DXBARDRAGCOPYCURSOR'); Screen.Cursors[crdxBarDragNoDrop] := LoadCursor(HInstance, 'DXBARDRAGNODROPCURSOR'); Screen.Cursors[crdxBarEditSizing] := LoadCursor(HInstance, 'DXBAREDITSIZINGCURSOR'); if not IsLibrary then begin FPrevInitProc := InitProc; InitProc := @dxBarInitProc; end; finalization FdxBarIsFinalized := True; FreeAndNil(FBarNavigationController); FBarControls.Free; FreeAndNil(FRegdxItemList); FreeAndNil(FBarDesignController); FreeAndNil(FBarCanvas); DeleteObject(PatternBrush); dxFreeAndNil(dxBarManagerList); FreeMem(AClassName, 256); if FUser32DLL > 32 then FreeLibrary(FUser32DLL); end.