david
3b29f73ece
git-svn-id: https://192.168.0.254/svn/Componentes.Terceros.DevExpressVCL@8 05c56307-c608-d34a-929d-697000501d7a
2394 lines
66 KiB
ObjectPascal
2394 lines
66 KiB
ObjectPascal
{*******************************************************************}
|
|
{ }
|
|
{ Developer Express Visual Component Library }
|
|
{ ExpressNavBar }
|
|
{ }
|
|
{ Copyright (c) 2002-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 EXPRESSNAVBAR AND ALL ACCOMPANYING }
|
|
{ VCL CONTROLS AS PART OF AN EXECUTABLE PROGRAM ONLY. }
|
|
{ }
|
|
{ THE SOURCE CODE CONTAINED WITHIN THIS FILE AND ALL RELATED }
|
|
{ FILES OR ANY PORTION OF ITS CONTENTS SHALL AT NO TIME BE }
|
|
{ COPIED, TRANSFERRED, SOLD, DISTRIBUTED, OR OTHERWISE MADE }
|
|
{ AVAILABLE TO OTHER INDIVIDUALS WITHOUT EXPRESS WRITTEN CONSENT }
|
|
{ AND PERMISSION FROM DEVELOPER EXPRESS INC. }
|
|
{ }
|
|
{ CONSULT THE END USER LICENSE AGREEMENT FOR INFORMATION ON }
|
|
{ ADDITIONAL RESTRICTIONS. }
|
|
{ }
|
|
{*******************************************************************}
|
|
|
|
unit dxfmNavBarDsgnEditor;
|
|
|
|
{$I cxVer.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
Dialogs, Classes, Controls, Messages, Forms, StdCtrls, ExtCtrls, Menus, ImgList, ComCtrls,
|
|
{$IFDEF DELPHI6}
|
|
{$IFDEF CLR}
|
|
Borland.Vcl.Design.DesignWindows, Borland.Vcl.Design.DesignIntf, Borland.Vcl.Design.DesignEditors,
|
|
{$ELSE}
|
|
DesignWindows, DesignIntf, DesignEditors,
|
|
{$ENDIF}
|
|
{$ELSE}
|
|
DsgnIntf, DsgnWnds, LibIntf,
|
|
{$ENDIF}
|
|
|
|
dxNavBar, dxNavBarBase, dxNavBarCollns, dxNavBarStyles, dxNavBarDsgnUtils,
|
|
cxClasses;
|
|
|
|
type
|
|
TdxfmNavBarDesignWindow = class;
|
|
|
|
TdxNavBarDsgnWindowPageHandler = class
|
|
private
|
|
FDsgnWindow: TdxfmNavBarDesignWindow;
|
|
function GetNavBar: TdxCustomNavBar;
|
|
protected
|
|
class function DesignerCaptionPostfix: string; virtual;
|
|
|
|
function CanAdd: Boolean; virtual;
|
|
function CanCopy: Boolean; virtual;
|
|
function CanCut: Boolean; virtual;
|
|
function CanDelete: Boolean; virtual;
|
|
function CanSelectAll: Boolean; virtual;
|
|
function CanMoveUp: Boolean; virtual;
|
|
function CanMoveDown: Boolean; virtual;
|
|
function CanPaste: Boolean; virtual;
|
|
public
|
|
constructor Create(ADsgnWindow: TdxfmNavBarDesignWindow);
|
|
destructor Destroy; override;
|
|
|
|
procedure Activate;
|
|
procedure Add; virtual;
|
|
procedure Copy; virtual;
|
|
procedure Cut; virtual;
|
|
procedure Delete; virtual;
|
|
procedure DeleteItem(AItem: TComponent); virtual;
|
|
procedure GetSelections(const ASelections: IDesignerSelections); virtual;
|
|
procedure MoveSelection(ADelta: Integer); virtual;
|
|
procedure Paste; virtual;
|
|
procedure SelectAll; virtual;
|
|
procedure UpdateButtonsPanel; virtual;
|
|
procedure UpdateButtonsState;
|
|
procedure UpdateContent; virtual;
|
|
procedure UpdateItem(AItem: TComponent); virtual;
|
|
procedure UpdateScrollBar; virtual;
|
|
procedure UpdateSelections(const ASelections: IDesignerSelections); virtual;
|
|
|
|
property DsgnWindow: TdxfmNavBarDesignWindow read FDsgnWindow;
|
|
property NavBar: TdxCustomNavBar read GetNavBar;
|
|
end;
|
|
|
|
TdxfmNavBarDesignWindow = class(TDesignWindow)
|
|
pcMain: TPageControl;
|
|
tsGroups: TTabSheet;
|
|
tsItems: TTabSheet;
|
|
tsLinks: TTabSheet;
|
|
tsCustomStyles: TTabSheet;
|
|
lbxGroups: TListBox;
|
|
Panel2: TPanel;
|
|
Panel3: TPanel;
|
|
Label1: TLabel;
|
|
Splitter1: TSplitter;
|
|
Panel4: TPanel;
|
|
tvLinkDesignerGroups: TTreeView;
|
|
Panel5: TPanel;
|
|
Label2: TLabel;
|
|
lbxItems: TListBox;
|
|
pnButtons: TPanel;
|
|
lbxCustomStyles: TListBox;
|
|
ilLinkDesigner: TImageList;
|
|
ilPopup: TImageList;
|
|
pmMain: TPopupMenu;
|
|
miAdd: TMenuItem;
|
|
N2: TMenuItem;
|
|
miEdit: TMenuItem;
|
|
miCut: TMenuItem;
|
|
miCopy: TMenuItem;
|
|
miPaste: TMenuItem;
|
|
miDelete: TMenuItem;
|
|
N3: TMenuItem;
|
|
miSelectAll: TMenuItem;
|
|
N4: TMenuItem;
|
|
miMoveUp: TMenuItem;
|
|
miMoveDown: TMenuItem;
|
|
lbxLinkDesignerItems: TListView;
|
|
nbMain: TdxNavBar;
|
|
bgMain: TdxNavBarGroup;
|
|
bgStyles: TdxNavBarGroup;
|
|
biGroups: TdxNavBarItem;
|
|
biItems: TdxNavBarItem;
|
|
biLinks: TdxNavBarItem;
|
|
biViews: TdxNavBarItem;
|
|
biDefaultStyles: TdxNavBarItem;
|
|
biCustomStyles: TdxNavBarItem;
|
|
ilNavBarLarge: TImageList;
|
|
ilNavBarSmall: TImageList;
|
|
tsViews: TTabSheet;
|
|
tsDefaultStyles: TTabSheet;
|
|
lbxDefaultStyles: TListBox;
|
|
pnBtnAddDelete: TPanel;
|
|
btAdd: TButton;
|
|
btDelete: TButton;
|
|
nbPreview: TdxNavBar;
|
|
Label3: TLabel;
|
|
Label4: TLabel;
|
|
cbViewStyles: TComboBox;
|
|
ilPreviewLarge: TImageList;
|
|
ilPreviewSmall: TImageList;
|
|
bgLocal: TdxNavBarGroup;
|
|
bgNews: TdxNavBarGroup;
|
|
biInbox: TdxNavBarItem;
|
|
biOutbox: TdxNavBarItem;
|
|
biSentItems: TdxNavBarItem;
|
|
biDeletedItems: TdxNavBarItem;
|
|
biDrafts: TdxNavBarItem;
|
|
biNews: TdxNavBarItem;
|
|
Panel1: TPanel;
|
|
pnBtnSelect: TPanel;
|
|
btSelectAll: TButton;
|
|
Panel6: TPanel;
|
|
pnBtnMove: TPanel;
|
|
btMoveUp: TButton;
|
|
btMoveDown: TButton;
|
|
Panel7: TPanel;
|
|
pnBtnDefaultSettings: TPanel;
|
|
btnDefaultSettings: TButton;
|
|
pnBtnApply: TPanel;
|
|
btnApply: TButton;
|
|
procedure ListBoxClick(Sender: TObject);
|
|
procedure AddClick(Sender: TObject);
|
|
procedure ActionClick(Sender: TObject);
|
|
procedure MoveUpClick(Sender: TObject);
|
|
procedure MoveDownClick(Sender: TObject);
|
|
procedure tvLinkDesignerGroupsDragDrop(Sender, Source: TObject; X, Y: Integer);
|
|
procedure tvLinkDesignerGroupsDragOver(Sender, Source: TObject; X, Y: Integer; State: TDragState; var Accept: Boolean);
|
|
procedure tvLinkDesignerGroupsStartDrag(Sender: TObject; var DragObject: TDragObject);
|
|
procedure lbxLinkDesignerItemsDragOver(Sender, Source: TObject; X, Y: Integer; State: TDragState; var Accept: Boolean);
|
|
procedure lbxLinkDesignerItemsDragDrop(Sender, Source: TObject; X, Y: Integer);
|
|
procedure lbxLinkDesignerItemsStartDrag(Sender: TObject; var DragObject: TDragObject);
|
|
procedure tvLinkDesignerGroupsExit(Sender: TObject);
|
|
procedure pmMainPopup(Sender: TObject);
|
|
procedure tvLinkDesignerGroupsClick(Sender: TObject);
|
|
procedure lbxLinkDesignerItemsClick(Sender: TObject);
|
|
procedure tvLinkDesignerGroupsEndDrag(Sender, Target: TObject; X,
|
|
Y: Integer);
|
|
procedure lbxLinkDesignerItemsEndDrag(Sender, Target: TObject; X,
|
|
Y: Integer);
|
|
procedure nbMainLinkClick(Sender: TObject; ALink: TdxNavBarItemLink);
|
|
procedure DefaultSettingsClick(Sender: TObject);
|
|
procedure cbViewStylesChange(Sender: TObject);
|
|
procedure btnApplyClick(Sender: TObject);
|
|
private
|
|
FNavBar: TdxCustomNavBar;
|
|
FHandlers: TList;
|
|
FCurrentHandler: TdxNavBarDsgnWindowPageHandler;
|
|
FSaveCursor: TCursor;
|
|
|
|
function GetNavBarDesigner: TAbstractcxNavBarDesigner;
|
|
procedure SetNavBar(Value: TdxCustomNavBar);
|
|
|
|
function CanAdd: Boolean;
|
|
function CanCopy: Boolean;
|
|
function CanCut: Boolean;
|
|
function CanDelete: Boolean;
|
|
function CanMoveDown: Boolean;
|
|
function CanMoveUp: Boolean;
|
|
function CanPaste: Boolean;
|
|
function CanSelectAll: Boolean;
|
|
procedure Copy;
|
|
procedure Cut;
|
|
procedure Delete;
|
|
procedure HandleException;
|
|
function GetRegistryPath: string;
|
|
procedure Paste;
|
|
procedure RestoreLayout;
|
|
procedure Select(AComponent: TComponent; AddToSelection: Boolean);
|
|
procedure SelectAll;
|
|
procedure SelectNavBar;
|
|
procedure StartWait;
|
|
procedure StopWait;
|
|
procedure StoreLayout;
|
|
procedure UpdateButtonsState;
|
|
procedure UpdateCaption;
|
|
procedure UpdateItem(AItem: TComponent);
|
|
procedure UpdateMenuState;
|
|
procedure UpdateSelections(const ASelections: IDesignerSelections);
|
|
|
|
function GetHandler(Index: Integer): TdxNavBarDsgnWindowPageHandler;
|
|
function GetHandlerCount: Integer;
|
|
protected
|
|
procedure Activated; override;
|
|
{$IFDEF DELPHI9}
|
|
procedure CreateParams(var Params: TCreateParams); override;
|
|
{$ENDIF}
|
|
function UniqueName(Component: TComponent): string; override;
|
|
|
|
procedure ActiveDesignerPageChanged;
|
|
procedure InitializeHandlers;
|
|
procedure InitializeViewStyles;
|
|
procedure FinalizeHandlers;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
destructor Destroy; override;
|
|
|
|
function ClipboardComponents: Boolean;
|
|
|
|
{$IFDEF DELPHI6}
|
|
function EditAction(Action: TEditAction): Boolean; override;
|
|
{$ELSE}
|
|
procedure EditAction(Action: TEditAction); override;
|
|
{$ENDIF}
|
|
function GetEditState: TEditState; override;
|
|
|
|
{$IFDEF DELPHI6}
|
|
procedure ItemDeleted(const ADesigner: IDesigner; Item: TPersistent); override;
|
|
procedure ItemsModified(const Designer: IDesigner); override;
|
|
procedure SelectionChanged(const ADesigner: IDesigner; const ASelection: IDesignerSelections); override;
|
|
{$ELSE}
|
|
procedure ComponentDeleted(Component: IPersistent); override;
|
|
procedure FormModified; override;
|
|
procedure SelectionChanged(ASelection: TDesignerSelectionList); override;
|
|
{$ENDIF}
|
|
|
|
property CurrentHandler: TdxNavBarDsgnWindowPageHandler read FCurrentHandler write FCurrentHandler;
|
|
property HandlerCount: Integer read GetHandlerCount;
|
|
property Handlers[Index: Integer]: TdxNavBarDsgnWindowPageHandler read GetHandler;
|
|
property NavBar: TdxCustomNavBar read FNavBar write SetNavBar;
|
|
property NavBarDesigner: TAbstractcxNavBarDesigner read GetNavBarDesigner;
|
|
end;
|
|
|
|
procedure dxShowNavBarDesigner(ANavBar: TdxCustomNavBar;
|
|
ADelphiDesigner: IDelphiDesigner);
|
|
|
|
|
|
implementation
|
|
|
|
{$R *.DFM}
|
|
|
|
uses
|
|
Windows, SysUtils, TypInfo, {$IFDEF DELPHI6}Variants,{$ENDIF} Registry
|
|
{$IFNDEF CLR}, ToolsAPI {$ENDIF}, dxNavBarViewsFact, dxNavBarDsgnConsts;
|
|
|
|
type
|
|
TdxNavBarDesigner = class(TAbstractcxNavBarDesigner)
|
|
private
|
|
FDelphiDesigner: IDelphiDesigner;
|
|
FDesignWindow: TdxfmNavBarDesignWindow;
|
|
FUpdateCount: Integer;
|
|
FIsBeingModified: Boolean;
|
|
|
|
function GetDesignWindow: TdxfmNavBarDesignWindow;
|
|
procedure Activate;
|
|
protected
|
|
procedure Modified; override;
|
|
procedure Update(AItem: TComponent); override;
|
|
public
|
|
constructor Create(ANavBar: TdxCustomNavBar; ADelphiDesigner: IDelphiDesigner);
|
|
destructor Destroy; override;
|
|
|
|
procedure BeginUpdate; override;
|
|
procedure CancelUpdate; override;
|
|
procedure EndUpdate; override;
|
|
|
|
property DelphiDesigner: IDelphiDesigner read FDelphiDesigner;
|
|
property DesignWindow: TdxfmNavBarDesignWindow read GetDesignWindow;
|
|
end;
|
|
|
|
|
|
procedure dxShowNavBarDesigner(ANavBar: TdxCustomNavBar; ADelphiDesigner: IDelphiDesigner);
|
|
begin
|
|
if ANavBar.Designer = nil then
|
|
TdxNavBarDesigner.Create(ANavBar, ADelphiDesigner);
|
|
TdxNavBarDesigner(ANavBar.Designer).Activate;
|
|
end;
|
|
|
|
{ TdxWebStyleControllerDesigner }
|
|
|
|
constructor TdxNavBarDesigner.Create(ANavBar: TdxCustomNavBar;
|
|
ADelphiDesigner: IDelphiDesigner);
|
|
begin
|
|
inherited Create(ANavBar);
|
|
FDelphiDesigner := ADelphiDesigner;
|
|
end;
|
|
|
|
destructor TdxNavBarDesigner.Destroy;
|
|
begin
|
|
if FDesignWindow <> nil then
|
|
begin
|
|
FDesignWindow.Designer := nil;
|
|
FDesignWindow.Free;
|
|
end;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TdxNavBarDesigner.BeginUpdate;
|
|
begin
|
|
Inc(FUpdateCount);
|
|
end;
|
|
|
|
procedure TdxNavBarDesigner.CancelUpdate;
|
|
begin
|
|
if FUpdateCount <> 0 then Dec(FUpdateCount);
|
|
end;
|
|
|
|
procedure TdxNavBarDesigner.EndUpdate;
|
|
begin
|
|
if FUpdateCount <> 0 then
|
|
begin
|
|
Dec(FUpdateCount);
|
|
if FUpdateCount = 0 then Update(nil);
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarDesigner.GetDesignWindow: TdxfmNavBarDesignWindow;
|
|
begin
|
|
if FDesignWindow = nil then
|
|
begin
|
|
FDesignWindow := TdxfmNavBarDesignWindow.Create(nil);
|
|
FDesignWindow.Designer := DelphiDesigner;
|
|
FDesignWindow.NavBar := NavBar;
|
|
end;
|
|
Result := FDesignWindow;
|
|
end;
|
|
|
|
procedure TdxNavBarDesigner.Activate;
|
|
begin
|
|
DesignWindow.Show;
|
|
end;
|
|
|
|
procedure TdxNavBarDesigner.Modified;
|
|
begin
|
|
if not FIsBeingModified and (DelphiDesigner <> nil) then
|
|
begin
|
|
FIsBeingModified := True;
|
|
try
|
|
DelphiDesigner.Modified;
|
|
finally
|
|
FIsBeingModified := False
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarDesigner.Update(AItem: TComponent);
|
|
begin
|
|
if (FUpdateCount = 0) and (FDesignWindow <> nil) then
|
|
DesignWindow.UpdateItem(AItem);
|
|
end;
|
|
|
|
type
|
|
TdxNavBarDsgnWindowComponentCollectionPageHandler = class(TdxNavBarDsgnWindowPageHandler)
|
|
private
|
|
function GetItem(Index: Integer): TdxNavBarComponentCollectionItem;
|
|
function GetItemCount: Integer;
|
|
function GetSelected(Index: Integer): Boolean;
|
|
function GetSelectedCount: Integer;
|
|
procedure SetSelected(Index: Integer; const Value: Boolean);
|
|
protected
|
|
function MainList: TListBox; virtual;
|
|
class function ItemNamePrefix: string; virtual;
|
|
class function ItemClass: TComponentClass; virtual;
|
|
|
|
function CanAdd: Boolean; override;
|
|
function CanCopy: Boolean; override;
|
|
function CanCut: Boolean; override;
|
|
function CanDelete: Boolean; override;
|
|
function CanSelectAll: Boolean; override;
|
|
function CanMoveUp: Boolean; override;
|
|
function CanMoveDown: Boolean; override;
|
|
function CanPaste: Boolean; override;
|
|
public
|
|
procedure Add; override;
|
|
procedure Copy; override;
|
|
procedure Cut; override;
|
|
procedure Delete; override;
|
|
procedure DeleteItem(AItem: TComponent); override;
|
|
function IndexOf(AItem: TComponent): Integer;
|
|
procedure GetSelections(const ASelections: IDesignerSelections); override;
|
|
procedure MoveSelection(ADelta: Integer); override;
|
|
procedure Paste; override;
|
|
procedure RefreshListValues; virtual;
|
|
procedure SelectAll; override;
|
|
procedure UpdateButtonsPanel; override;
|
|
procedure UpdateContent; override;
|
|
procedure UpdateItem(AItem: TComponent); override;
|
|
procedure UpdateScrollBar; override;
|
|
procedure UpdateSelections(const ASelections: IDesignerSelections); override;
|
|
|
|
property Selected[Index: Integer]: Boolean read GetSelected write SetSelected;
|
|
property SelectedCount: Integer read GetSelectedCount;
|
|
property Items[Index: Integer]: TdxNavBarComponentCollectionItem read GetItem;
|
|
property ItemCount: Integer read GetItemCount;
|
|
|
|
property DsgnWindow: TdxfmNavBarDesignWindow read FDsgnWindow;
|
|
property NavBar: TdxCustomNavBar read GetNavBar;
|
|
end;
|
|
|
|
{ TdxNavBarDsgnWindowComponentCollectionPageHandler }
|
|
|
|
procedure TdxNavBarDsgnWindowComponentCollectionPageHandler.Add;
|
|
begin
|
|
inherited;
|
|
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowComponentCollectionPageHandler.CanAdd: Boolean;
|
|
begin
|
|
Result := (NavBar <> nil) and (NavBar.Owner <> nil);
|
|
if Result then
|
|
Result := not (csInline in NavBar.Owner.ComponentState);
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowComponentCollectionPageHandler.CanCopy: Boolean;
|
|
begin
|
|
Result := SelectedCount <> 0;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowComponentCollectionPageHandler.CanCut: Boolean;
|
|
begin
|
|
Result := CanCopy and CanDelete;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowComponentCollectionPageHandler.CanDelete: Boolean;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := SelectedCount <> 0;
|
|
if Result then
|
|
for I := 0 to ItemCount - 1 do
|
|
if Selected[I] and (csAncestor in Items[I].ComponentState) then
|
|
begin
|
|
Result := False;
|
|
Exit;
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowComponentCollectionPageHandler.CanMoveDown: Boolean;
|
|
var
|
|
I, Counter: Integer;
|
|
begin
|
|
Counter := 0;
|
|
for I := ItemCount - 1 downto 0 do
|
|
begin
|
|
if not Selected[I] then
|
|
begin
|
|
Result := Counter < SelectedCount;
|
|
Exit;
|
|
end;
|
|
Inc(Counter);
|
|
end;
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowComponentCollectionPageHandler.CanMoveUp: Boolean;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to ItemCount - 1 do
|
|
if not Selected[I] then
|
|
begin
|
|
Result := I < SelectedCount;
|
|
Exit;
|
|
end;
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowComponentCollectionPageHandler.CanPaste: Boolean;
|
|
begin
|
|
Result := CanAdd and DsgnWindow.ClipboardComponents and DsgnWindow.Designer.CanPaste;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowComponentCollectionPageHandler.CanSelectAll: Boolean;
|
|
begin
|
|
Result := ItemCount <> SelectedCount;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowComponentCollectionPageHandler.Copy;
|
|
var
|
|
Components: {$IFDEF DELPHI6}IDesignerSelections{$ELSE}TDesignerSelectionList{$ENDIF};
|
|
begin
|
|
{$IFDEF DELPHI6}
|
|
Components := CreateSelectionList;
|
|
{$ELSE}
|
|
Components := TDesignerSelectionList.Create;
|
|
try
|
|
{$ENDIF}
|
|
GetSelections(Components);
|
|
DsgnWindow.CopyComponents(NavBar.Owner, Components);
|
|
{$IFNDEF DELPHI6}
|
|
finally
|
|
Components.Free;
|
|
end;
|
|
{$ENDIF}
|
|
UpdateScrollBar;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowComponentCollectionPageHandler.Cut;
|
|
begin
|
|
Copy;
|
|
Delete;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowComponentCollectionPageHandler.Delete;
|
|
var
|
|
Selections: IDesignerSelections;
|
|
I: Integer;
|
|
begin
|
|
DsgnWindow.StartWait;
|
|
try
|
|
Selections := CreateSelectionList;
|
|
GetSelections(Selections);
|
|
for I := 0 to Selections.Count - 1 do
|
|
dxNavBarDsgnUtils.TryExtractPersistent(Selections[I]).Free;
|
|
NavBar.DesignerModified;
|
|
finally
|
|
DsgnWindow.StopWait;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowComponentCollectionPageHandler.DeleteItem(
|
|
AItem: TComponent);
|
|
var
|
|
Index, ItemIndex: Integer;
|
|
begin
|
|
if (AItem = nil) or (AItem.ClassType <> ItemClass) then exit;
|
|
|
|
Index := IndexOf(AItem);
|
|
if Index <> -1 then
|
|
begin
|
|
ItemIndex := MainList.ItemIndex;
|
|
MainList.Items.Delete(Index);
|
|
|
|
if ItemIndex > ItemCount - 1 then
|
|
ItemIndex := ItemCount - 1;
|
|
if ItemIndex <> -1 then
|
|
DsgnWindow.Select(Items[ItemIndex], False)
|
|
else DsgnWindow.SelectNavBar;
|
|
UpdateScrollBar;
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowComponentCollectionPageHandler.GetItem(
|
|
Index: Integer): TdxNavBarComponentCollectionItem;
|
|
begin
|
|
if MainList <> nil then
|
|
Result := TdxNavBarComponentCollectionItem(MainList.Items.Objects[Index])
|
|
else Result := nil;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowComponentCollectionPageHandler.GetItemCount: Integer;
|
|
begin
|
|
if MainList <> nil then
|
|
Result := MainList.Items.Count
|
|
else Result := 0;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowComponentCollectionPageHandler.GetSelected(
|
|
Index: Integer): Boolean;
|
|
begin
|
|
if MainList <> nil then
|
|
Result := MainList.Selected[Index]
|
|
else Result := False;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowComponentCollectionPageHandler.GetSelectedCount: Integer;
|
|
begin
|
|
if MainList <> nil then
|
|
Result := MainList.SelCount
|
|
else Result := 0;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowComponentCollectionPageHandler.GetSelections(
|
|
const ASelections: IDesignerSelections);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to ItemCount - 1 do
|
|
if Selected[I] then
|
|
ASelections.Add(dxNavBarDsgnUtils.MakeIComponent(Items[I]));
|
|
if ASelections.Count = 0 then
|
|
ASelections.Add(dxNavBarDsgnUtils.MakeIComponent(NavBar));
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowComponentCollectionPageHandler.IndexOf(
|
|
AItem: TComponent): Integer;
|
|
begin
|
|
Result := MainList.Items.IndexOfObject(AItem);
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowComponentCollectionPageHandler.MainList: TListBox;
|
|
begin
|
|
Result := nil;
|
|
end;
|
|
|
|
class function TdxNavBarDsgnWindowComponentCollectionPageHandler.ItemClass: TComponentClass;
|
|
begin
|
|
Result := nil;
|
|
end;
|
|
|
|
class function TdxNavBarDsgnWindowComponentCollectionPageHandler.ItemNamePrefix: string;
|
|
begin
|
|
Result := '';
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowComponentCollectionPageHandler.MoveSelection(
|
|
ADelta: Integer);
|
|
|
|
procedure MoveDown(ADelta: Integer);
|
|
var
|
|
I, Index: Integer;
|
|
begin
|
|
// for I := ItemCount - 1 downto 0 do
|
|
for I := 0 to ItemCount - 1 do
|
|
if Selected[I] then
|
|
begin
|
|
Index := Items[I].Index;
|
|
Inc(Index, ADelta);
|
|
if Index > ItemCount - 1 then
|
|
Index := ItemCount - 1;
|
|
while (Index < ItemCount) and Selected[Index] do
|
|
Inc(Index);
|
|
Items[I].Index := Index;
|
|
end;
|
|
end;
|
|
|
|
procedure MoveUp(ADelta: Integer);
|
|
var
|
|
I, Index: Integer;
|
|
begin
|
|
// for I := 0 to ItemCount - 1 do
|
|
for I := ItemCount - 1 downto 0 do
|
|
if Selected[I] then
|
|
begin
|
|
Index := Items[I].Index;
|
|
Inc(Index, ADelta);
|
|
if Index < 0 then
|
|
Index := 0;
|
|
while (Index > -1) and Selected[Index] do
|
|
Dec(Index);
|
|
Items[I].Index := Index;
|
|
end;
|
|
end;
|
|
|
|
begin
|
|
DsgnWindow.NavBarDesigner.BeginUpdate;
|
|
try
|
|
if ADelta > 0 then MoveDown(ADelta)
|
|
else MoveUp(ADelta);
|
|
finally
|
|
DsgnWindow.NavBarDesigner.EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowComponentCollectionPageHandler.Paste;
|
|
var
|
|
Components: {$IFDEF DELPHI6}IDesignerSelections{$ELSE}TDesignerSelectionList{$ENDIF};
|
|
I: Integer;
|
|
begin
|
|
{$IFDEF DELPHI6}
|
|
Components := CreateSelectionList;
|
|
{$ELSE}
|
|
Components := TDesignerSelectionList.Create;
|
|
try
|
|
{$ENDIF}
|
|
DsgnWindow.StartWait;
|
|
try
|
|
MainList.Items.BeginUpdate;
|
|
try
|
|
DsgnWindow.NavBarDesigner.BeginUpdate;
|
|
try
|
|
DsgnWindow.PasteComponents(NavBar.Owner, NavBar, Components);
|
|
finally
|
|
DsgnWindow.NavBarDesigner.EndUpdate;
|
|
end;
|
|
for I := ItemCount - 1 downto ItemCount - Components.Count do
|
|
Selected[I] := True;
|
|
DsgnWindow.Designer.SetSelections(Components);
|
|
finally
|
|
MainList.Items.EndUpdate;
|
|
end;
|
|
finally
|
|
DsgnWindow.StopWait;
|
|
end;
|
|
{$IFNDEF DELPHI6}
|
|
finally
|
|
Components.Free;
|
|
end;
|
|
{$ENDIF}
|
|
UpdateScrollBar;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowComponentCollectionPageHandler.UpdateContent;
|
|
var
|
|
Selections: IDesignerSelections;
|
|
I, Index: Integer;
|
|
Component: TComponent;
|
|
begin
|
|
MainList.Items.BeginUpdate;
|
|
try
|
|
Selections := CreateSelectionList;
|
|
GetSelections(Selections);
|
|
|
|
MainList.Items.Clear;
|
|
if NavBar = nil then Exit;
|
|
RefreshListValues;
|
|
|
|
for I := 0 to Selections.Count - 1 do
|
|
begin
|
|
Component := dxNavBarDsgnUtils.TryExtractComponent(Selections[I]);
|
|
if Component is ItemClass then
|
|
begin
|
|
Index := IndexOf(Component);
|
|
if Index <> -1 then Selected[Index] := True;
|
|
end;
|
|
end;
|
|
finally
|
|
MainList.Items.EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowComponentCollectionPageHandler.RefreshListValues;
|
|
begin
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowComponentCollectionPageHandler.SelectAll;
|
|
var
|
|
Selections: IDesignerSelections;
|
|
I: Integer;
|
|
begin
|
|
Selections := CreateSelectionList;
|
|
for I := 0 to ItemCount - 1 do
|
|
Selections.Add(dxNavBarDsgnUtils.MakeIComponent(Items[I]));
|
|
DsgnWindow.Designer.SetSelections(Selections);
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowComponentCollectionPageHandler.SetSelected(
|
|
Index: Integer; const Value: Boolean);
|
|
begin
|
|
if MainList <> nil then
|
|
MainList.Selected[Index] := Value;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowComponentCollectionPageHandler.UpdateButtonsPanel;
|
|
begin
|
|
DsgnWindow.pnBtnAddDelete.Visible := True;
|
|
DsgnWindow.pnBtnSelect.Visible := True;
|
|
DsgnWindow.pnBtnMove.Visible := True;
|
|
DsgnWindow.pnBtnDefaultSettings.Visible := False;
|
|
DsgnWindow.pnBtnApply.Visible := False;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowComponentCollectionPageHandler.UpdateItem(AItem: TComponent);
|
|
var
|
|
Index: Integer;
|
|
begin
|
|
if AItem <> nil then
|
|
begin
|
|
Index := IndexOf(AItem);
|
|
if Index <> -1 then
|
|
begin
|
|
MainList.Items[Index] := AItem.Name;
|
|
UpdateScrollBar;
|
|
end
|
|
end
|
|
else UpdateContent;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowComponentCollectionPageHandler.UpdateScrollBar;
|
|
var
|
|
I, NewWidth, CurrentWidth: Integer;
|
|
begin
|
|
NewWidth := 0;
|
|
with MainList do
|
|
begin
|
|
for I := 0 to Items.Count - 1 do
|
|
begin
|
|
CurrentWidth := 2 + Canvas.TextWidth(Items[I]) + 1;
|
|
if CurrentWidth > NewWidth then NewWidth := CurrentWidth;
|
|
end;
|
|
SendMessage(Handle, LB_SETHORIZONTALEXTENT, NewWidth, 0);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowComponentCollectionPageHandler.UpdateSelections(const ASelections: IDesignerSelections);
|
|
|
|
function InSelection(AItem: TComponent): Boolean;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := False;
|
|
for I := 0 to ASelections.Count - 1 do
|
|
if AItem = dxNavBarDsgnUtils.TryExtractComponent(ASelections[I]) then
|
|
begin
|
|
Result := True;
|
|
break;
|
|
end;
|
|
end;
|
|
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to ItemCount - 1 do
|
|
if Selected[I] xor InSelection(Items[I]) then
|
|
Selected[I] := not Selected[I];
|
|
end;
|
|
|
|
type
|
|
TdxNavBarDsgnWindowGroupsHandler = class(TdxNavBarDsgnWindowComponentCollectionPageHandler)
|
|
protected
|
|
function MainList: TListBox; override;
|
|
class function DesignerCaptionPostfix: string; override;
|
|
class function ItemNamePrefix: string; override;
|
|
class function ItemClass: TComponentClass; override;
|
|
public
|
|
procedure Add; override;
|
|
procedure RefreshListValues; override;
|
|
end;
|
|
|
|
{ TdxNavBarDsgnWindowGroupsHandler }
|
|
|
|
procedure TdxNavBarDsgnWindowGroupsHandler.Add;
|
|
var
|
|
Group: TdxNavBarGroup;
|
|
begin
|
|
Group := NavBar.Groups.Add;
|
|
DsgnWindow.NavBarDesigner.BeginUpdate;
|
|
try
|
|
Group.Name := DsgnWindow.UniqueName(Group);
|
|
finally
|
|
DsgnWindow.NavBarDesigner.CancelUpdate;
|
|
end;
|
|
MainList.Items.AddObject(Group.Name, Group);
|
|
DsgnWindow.Select(Group, False);
|
|
UpdateScrollBar;
|
|
MainList.Update;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowGroupsHandler.MainList: TListBox;
|
|
begin
|
|
Result := DsgnWindow.lbxGroups;
|
|
end;
|
|
|
|
class function TdxNavBarDsgnWindowGroupsHandler.DesignerCaptionPostfix: string;
|
|
begin
|
|
Result := sdxGroupsDesigner;
|
|
end;
|
|
|
|
class function TdxNavBarDsgnWindowGroupsHandler.ItemNamePrefix: string;
|
|
begin
|
|
Result := sdxGroup;
|
|
end;
|
|
|
|
class function TdxNavBarDsgnWindowGroupsHandler.ItemClass: TComponentClass;
|
|
begin
|
|
Result := TdxNavBarGroup;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowGroupsHandler.RefreshListValues;
|
|
var
|
|
I: Integer;
|
|
Group: TdxNavBarGroup;
|
|
begin
|
|
for I := 0 to NavBar.Groups.Count - 1 do
|
|
begin
|
|
Group := NavBar.Groups[I];
|
|
if Group.Owner = NavBar.Owner then
|
|
MainList.Items.AddObject(Group.Name, Group);
|
|
end;
|
|
end;
|
|
|
|
type
|
|
TdxNavBarDsgnWindowItemsHandler = class(TdxNavBarDsgnWindowComponentCollectionPageHandler)
|
|
protected
|
|
function MainList: TListBox; override;
|
|
class function DesignerCaptionPostfix: string; override;
|
|
class function ItemNamePrefix: string; override;
|
|
class function ItemClass: TComponentClass; override;
|
|
public
|
|
procedure Add; override;
|
|
procedure RefreshListValues; override;
|
|
end;
|
|
|
|
{ TdxNavBarDsgnWindowItemsHandler }
|
|
|
|
procedure TdxNavBarDsgnWindowItemsHandler.Add;
|
|
var
|
|
Item: TdxNavBarItem;
|
|
begin
|
|
Item := NavBar.Items.Add;
|
|
DsgnWindow.NavBarDesigner.BeginUpdate;
|
|
try
|
|
Item.Name := DsgnWindow.UniqueName(Item);
|
|
finally
|
|
DsgnWindow.NavBarDesigner.CancelUpdate;
|
|
end;
|
|
MainList.Items.AddObject(Item.Name, Item);
|
|
DsgnWindow.Select(Item, False);
|
|
UpdateScrollBar;
|
|
MainList.Update;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowItemsHandler.MainList: TListBox;
|
|
begin
|
|
Result := DsgnWindow.lbxItems;
|
|
end;
|
|
|
|
class function TdxNavBarDsgnWindowItemsHandler.DesignerCaptionPostfix: string;
|
|
begin
|
|
Result := sdxItemsDesigner;
|
|
end;
|
|
|
|
class function TdxNavBarDsgnWindowItemsHandler.ItemNamePrefix: string;
|
|
begin
|
|
Result := sdxItem;
|
|
end;
|
|
|
|
class function TdxNavBarDsgnWindowItemsHandler.ItemClass: TComponentClass;
|
|
begin
|
|
Result := TdxNavBarItem;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowItemsHandler.RefreshListValues;
|
|
var
|
|
I: Integer;
|
|
Item: TdxNavBarItem;
|
|
begin
|
|
for I := 0 to NavBar.Items.Count - 1 do
|
|
begin
|
|
Item := NavBar.Items[I];
|
|
if Item.Owner = NavBar.Owner then
|
|
MainList.Items.AddObject(Item.Name, Item);
|
|
end;
|
|
end;
|
|
|
|
type
|
|
TdxNavBarDsgnWindowCustomStylesHandler = class(TdxNavBarDsgnWindowComponentCollectionPageHandler)
|
|
protected
|
|
function MainList: TListBox; override;
|
|
class function DesignerCaptionPostfix: string; override;
|
|
class function ItemNamePrefix: string; override;
|
|
class function ItemClass: TComponentClass; override;
|
|
public
|
|
procedure Add; override;
|
|
procedure RefreshListValues; override;
|
|
end;
|
|
|
|
{ TdxNavBarDsgnWindowSlylesHandler }
|
|
|
|
procedure TdxNavBarDsgnWindowCustomStylesHandler.Add;
|
|
var
|
|
Style: TdxNavBarStyleItem;
|
|
begin
|
|
Style := NavBar.Styles.Add;
|
|
DsgnWindow.NavBarDesigner.BeginUpdate;
|
|
try
|
|
Style.Name := DsgnWindow.UniqueName(Style);
|
|
finally
|
|
DsgnWindow.NavBarDesigner.CancelUpdate;
|
|
end;
|
|
MainList.Items.AddObject(Style.Name, Style);
|
|
DsgnWindow.Select(Style, False);
|
|
UpdateScrollBar;
|
|
MainList.Update;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowCustomStylesHandler.MainList: TListBox;
|
|
begin
|
|
Result := DsgnWindow.lbxCustomStyles;
|
|
end;
|
|
|
|
class function TdxNavBarDsgnWindowCustomStylesHandler.DesignerCaptionPostfix: string;
|
|
begin
|
|
Result := sdxCustomStylesDesigner;
|
|
end;
|
|
|
|
class function TdxNavBarDsgnWindowCustomStylesHandler.ItemNamePrefix: string;
|
|
begin
|
|
Result := sdxStyleItem;
|
|
end;
|
|
|
|
class function TdxNavBarDsgnWindowCustomStylesHandler.ItemClass: TComponentClass;
|
|
begin
|
|
Result := TdxNavBarStyleItem;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowCustomStylesHandler.RefreshListValues;
|
|
var
|
|
I: Integer;
|
|
Style: TdxNavBarStyleItem;
|
|
begin
|
|
for I := 0 to NavBar.Styles.Count - 1 do
|
|
begin
|
|
Style := NavBar.Styles[I];
|
|
if Style.Owner = NavBar.Owner then
|
|
MainList.Items.AddObject(Style.Name, Style);
|
|
end;
|
|
end;
|
|
|
|
type
|
|
TdxNavBarDsgnWindowLinksHandler = class(TdxNavBarDsgnWindowPageHandler)
|
|
private
|
|
FSourceItem: TdxNavBarItem;
|
|
FSourceLink: TdxNavBarItemLink;
|
|
FTargetGroup: TdxNavBarGroup;
|
|
FTargetLink: TdxNavBarItemLink;
|
|
|
|
function GetSelectedGroup: TdxNavBarGroup;
|
|
function GetSelectedItem: TdxNavBarItem;
|
|
function GetSelectedLink: TdxNavBarItemLink;
|
|
protected
|
|
function CanAdd: Boolean; override;
|
|
function CanDelete: Boolean; override;
|
|
function CanSelectAll: Boolean; override;
|
|
function CanMoveUp: Boolean; override;
|
|
function CanMoveDown: Boolean; override;
|
|
class function DesignerCaptionPostfix: string; override;
|
|
|
|
function ItemsLV: TListView;
|
|
function LinksTV: TTreeView;
|
|
procedure RefreshGroupTreeView;
|
|
procedure RefreshItemList;
|
|
function GetGroupByNode(ANode: TTreeNode): TdxNavBarGroup;
|
|
function GetLinkByNode(ANode: TTreeNode): TdxNavBarItemLink;
|
|
function GetItemByNode(ANode: TListItem): TdxNavBarItem;
|
|
function GetNodeByGroup(AGroup: TdxNavBarGroup): TTreeNode;
|
|
function GetNodeByLink(ALink: TdxNavBarItemLink): TTreeNode;
|
|
procedure CreateNodeByLink(ALink: TdxNavBarItemLink);
|
|
procedure RemoveNodeByLink(ALink: TdxNavBarItemLink);
|
|
|
|
function GetGroupNodeCation(AGroup: TdxNavBarGroup): string;
|
|
function GetItemNodeCation(AItem: TdxNavBarItem): string;
|
|
procedure SetTargetGroupNodeImage(AImageIndex: Integer);
|
|
procedure SetTargetLinkNodeImage(AImageIndex: Integer);
|
|
procedure UpdateTargets(ANode: TTreeNode);
|
|
procedure ClearTargets;
|
|
|
|
procedure CreateLink(AItem: TdxNavBarItem; AGroup: TdxNavBarGroup; AIndex: Integer);
|
|
procedure MoveLink(ALink: TdxNavBarItemLink; AGroup: TdxNavBarGroup; AIndex: Integer);
|
|
procedure RemoveLink(ALink: TdxNavBarItemLink);
|
|
public
|
|
procedure Add; override;
|
|
procedure Delete; override;
|
|
procedure MoveSelection(ADelta: Integer); override;
|
|
procedure UpdateButtonsPanel; override;
|
|
procedure UpdateContent; override;
|
|
procedure UpdateItem(AItem: TComponent); override;
|
|
|
|
property SelectedGroup: TdxNavBarGroup read GetSelectedGroup;
|
|
property SelectedItem: TdxNavBarItem read GetSelectedItem;
|
|
property SelectedLink: TdxNavBarItemLink read GetSelectedLink;
|
|
property SourceItem: TdxNavBarItem read FSourceItem write FSourceItem;
|
|
property SourceLink: TdxNavBarItemLink read FSourceLink write FSourceLink;
|
|
property TargetGroup: TdxNavBarGroup read FTargetGroup;
|
|
property TargetLink: TdxNavBarItemLink read FTargetLink;
|
|
end;
|
|
|
|
{ TdxNavBarDsgnWindowLinksHandler }
|
|
|
|
function TdxNavBarDsgnWindowLinksHandler.CanAdd: Boolean;
|
|
begin
|
|
Result := (SelectedItem <> nil) and (SelectedGroup <> nil);
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowLinksHandler.CanDelete: Boolean;
|
|
begin
|
|
Result := SelectedLink <> nil;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowLinksHandler.CanSelectAll: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowLinksHandler.CanMoveUp: Boolean;
|
|
begin
|
|
Result := (SelectedLink <> nil) and (SelectedLink.Index > 0);
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowLinksHandler.CanMoveDown: Boolean;
|
|
begin
|
|
Result := (SelectedLink <> nil) and (SelectedLink.Index < SelectedLink.Group.LinkCount - 1);
|
|
end;
|
|
|
|
class function TdxNavBarDsgnWindowLinksHandler.DesignerCaptionPostfix: string;
|
|
begin
|
|
Result := sdxLinksDesigner;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowLinksHandler.GetGroupByNode(ANode: TTreeNode): TdxNavBarGroup;
|
|
begin
|
|
if TObject(ANode.Data) is TdxNavBarGroup then
|
|
Result := TdxNavBarGroup(ANode.Data)
|
|
else Result := nil;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowLinksHandler.GetLinkByNode(ANode: TTreeNode): TdxNavBarItemLink;
|
|
begin
|
|
if TObject(ANode.Data) is TdxNavBarItemLink then
|
|
Result := TdxNavBarItemLink(ANode.Data)
|
|
else Result := nil;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowLinksHandler.GetItemByNode(ANode: TListItem): TdxNavBarItem;
|
|
begin
|
|
if TObject(ANode.Data) is TdxNavBarItem then
|
|
Result := TdxNavBarItem(ANode.Data)
|
|
else Result := nil;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowLinksHandler.GetNodeByGroup(AGroup: TdxNavBarGroup): TTreeNode;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := nil;
|
|
for I := 0 to DsgnWindow.tvLinkDesignerGroups.Items.Count - 1 do
|
|
if TObject(DsgnWindow.tvLinkDesignerGroups.Items[I].Data) = AGroup then
|
|
begin
|
|
Result := DsgnWindow.tvLinkDesignerGroups.Items[I];
|
|
break;
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowLinksHandler.GetNodeByLink(ALink: TdxNavBarItemLink): TTreeNode;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := nil;
|
|
for I := 0 to DsgnWindow.tvLinkDesignerGroups.Items.Count - 1 do
|
|
if TObject(DsgnWindow.tvLinkDesignerGroups.Items[I].Data) = ALink then
|
|
begin
|
|
Result := DsgnWindow.tvLinkDesignerGroups.Items[I];
|
|
break;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowLinksHandler.CreateNodeByLink(ALink: TdxNavBarItemLink);
|
|
var
|
|
ANode: TTreeNode;
|
|
begin
|
|
ANode := GetNodeByGroup(ALink.Group);
|
|
if ANode <> nil then
|
|
begin
|
|
if ALink.Index = ALink.Group.LinkCount - 1 then
|
|
ANode := LinksTV.Items.AddChildObject(ANode, GetItemNodeCation(ALink.Item), ALink)
|
|
else
|
|
begin
|
|
ANode := GetNodeByLink(ALink.Group.Links[ALink.Index + 1]);
|
|
ANode := LinksTV.Items.InsertObject(ANode, GetItemNodeCation(ALink.Item), ALink);
|
|
end;
|
|
with ANode do
|
|
begin
|
|
ImageIndex := 2;
|
|
SelectedIndex := 2;
|
|
end;
|
|
LinksTV.Selected := ANode;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowLinksHandler.RemoveNodeByLink(ALink: TdxNavBarItemLink);
|
|
var
|
|
ANode: TTreeNode;
|
|
begin
|
|
ANode := GetNodeByLink(ALink);
|
|
if ANode <> nil then
|
|
LinksTV.Items.Delete(ANode);
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowLinksHandler.GetGroupNodeCation(AGroup: TdxNavBarGroup): string;
|
|
begin
|
|
Result := AGroup.Caption + ' [' + AGroup.Name + ']';
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowLinksHandler.GetItemNodeCation(AItem: TdxNavBarItem): string;
|
|
begin
|
|
Result := AItem.Caption + ' [' + AItem.Name + ']';
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowLinksHandler.SetTargetGroupNodeImage(AImageIndex: Integer);
|
|
var
|
|
ANode: TTreeNode;
|
|
begin
|
|
if TargetGroup <> nil then
|
|
begin
|
|
ANode := GetNodeByGroup(TargetGroup);
|
|
if ANode <> nil then
|
|
with ANode do
|
|
begin
|
|
ImageIndex := AImageIndex;
|
|
SelectedIndex := AImageIndex;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowLinksHandler.SetTargetLinkNodeImage(AImageIndex: Integer);
|
|
var
|
|
ANode: TTreeNode;
|
|
begin
|
|
if TargetLink <> nil then
|
|
begin
|
|
ANode := GetNodeByLink(TargetLink);
|
|
if ANode <> nil then
|
|
with ANode do
|
|
begin
|
|
ImageIndex := AImageIndex;
|
|
SelectedIndex := AImageIndex;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowLinksHandler.UpdateTargets(ANode: TTreeNode);
|
|
var
|
|
AGroup: TdxNavBarGroup;
|
|
ALink: TdxNavBarItemLink;
|
|
begin
|
|
if ANode <> nil then
|
|
begin
|
|
ALink := GetLinkByNode(ANode);
|
|
AGroup := GetGroupByNode(ANode);
|
|
end
|
|
else
|
|
begin
|
|
AGroup := nil;
|
|
ALink := nil;
|
|
end;
|
|
if FTargetGroup <> AGroup then
|
|
begin
|
|
SetTargetGroupNodeImage(1);
|
|
FTargetGroup := AGroup;
|
|
SetTargetGroupNodeImage(3);
|
|
end;
|
|
if FTargetLink <> ALink then
|
|
begin
|
|
SetTargetLinkNodeImage(2);
|
|
FTargetLink := ALink;
|
|
SetTargetLinkNodeImage(4);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowLinksHandler.ClearTargets;
|
|
begin
|
|
SetTargetGroupNodeImage(1);
|
|
SetTargetLinkNodeImage(2);
|
|
FTargetGroup := nil;
|
|
FTargetLink := nil;;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowLinksHandler.Add;
|
|
begin
|
|
CreateLink(SelectedItem, SelectedGroup, -1);
|
|
UpdateButtonsState;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowLinksHandler.Delete;
|
|
begin
|
|
RemoveLink(SelectedLink);
|
|
UpdateButtonsState;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowLinksHandler.MoveSelection(ADelta: Integer);
|
|
begin
|
|
MoveLink(SelectedLink, SelectedGroup, SelectedLink.Index + ADelta);
|
|
UpdateButtonsState;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowLinksHandler.UpdateContent;
|
|
begin
|
|
RefreshItemList;
|
|
RefreshGroupTreeView;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowLinksHandler.UpdateItem(AItem: TComponent);
|
|
begin
|
|
UpdateContent;// TODO
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowLinksHandler.UpdateButtonsPanel;
|
|
begin
|
|
DsgnWindow.pnBtnAddDelete.Visible := True;
|
|
DsgnWindow.pnBtnSelect.Visible := False;
|
|
DsgnWindow.pnBtnMove.Visible := True;
|
|
DsgnWindow.pnBtnDefaultSettings.Visible := False;
|
|
DsgnWindow.pnBtnApply.Visible := False;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowLinksHandler.ItemsLV: TListView;
|
|
begin
|
|
Result := DsgnWindow.lbxLinkDesignerItems;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowLinksHandler.LinksTV: TTreeView;
|
|
begin
|
|
Result := DsgnWindow.tvLinkDesignerGroups;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowLinksHandler.CreateLink(AItem: TdxNavBarItem; AGroup: TdxNavBarGroup; AIndex: Integer);
|
|
var
|
|
ALink: TdxNavBarItemLink;
|
|
begin
|
|
DsgnWindow.tvLinkDesignerGroups.Items.BeginUpdate;
|
|
try
|
|
ALink := AGroup.CreateLink(AItem);
|
|
if (AIndex >= 0) and (AIndex < AGroup.LinkCount) then
|
|
ALink.Index := AIndex;
|
|
CreateNodeByLink(ALink);
|
|
finally
|
|
DsgnWindow.tvLinkDesignerGroups.FullExpand;
|
|
DsgnWindow.tvLinkDesignerGroups.Items.EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowLinksHandler.MoveLink(ALink: TdxNavBarItemLink; AGroup: TdxNavBarGroup; AIndex: Integer);
|
|
var
|
|
AItem: TdxNavBarItem;
|
|
begin
|
|
AItem := ALink.Item;
|
|
RemoveLink(ALink);
|
|
CreateLink(AItem, AGroup, AIndex);
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowLinksHandler.RemoveLink(ALink: TdxNavBarItemLink);
|
|
begin
|
|
RemoveNodeByLink(ALink);
|
|
ALink.Group.RemoveLink(ALink.Index);
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowLinksHandler.RefreshGroupTreeView;
|
|
var
|
|
I, J: Integer;
|
|
Group: TdxNavBarGroup;
|
|
Node: TTreeNode;
|
|
begin
|
|
LinksTV.Items.BeginUpdate;
|
|
try
|
|
LinksTV.Items.Clear;
|
|
if NavBar = nil then Exit;
|
|
|
|
for I := 0 to NavBar.Groups.Count - 1 do
|
|
begin
|
|
Group := NavBar.Groups[I];
|
|
if Group.Owner = NavBar.Owner then
|
|
begin
|
|
Node := LinksTV.Items.AddObject(nil, GetGroupNodeCation(Group), Group);
|
|
Node.ImageIndex := 1;
|
|
Node.SelectedIndex := 1;
|
|
for J := 0 to Group.LinkCount - 1 do
|
|
begin
|
|
with LinksTV.Items.AddChildObject(Node, GetItemNodeCation(Group.Links[J].Item), Group.Links[J]) do
|
|
begin
|
|
ImageIndex := 2;
|
|
SelectedIndex := 2;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
LinksTV.FullExpand;
|
|
finally
|
|
LinksTV.Items.EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowLinksHandler.RefreshItemList;
|
|
var
|
|
I: Integer;
|
|
Item: TdxNavBarItem;
|
|
begin
|
|
ItemsLV.Items.BeginUpdate;
|
|
try
|
|
ItemsLV.Items.Clear;
|
|
if NavBar = nil then Exit;
|
|
|
|
for I := 0 to NavBar.Items.Count - 1 do
|
|
begin
|
|
Item := NavBar.Items[I];
|
|
if Item.Owner = NavBar.Owner then
|
|
with ItemsLV.Items.Add do
|
|
begin
|
|
Caption := GetItemNodeCation(Item);
|
|
Data := Item;
|
|
ImageIndex := 2;
|
|
end;
|
|
end;
|
|
finally
|
|
ItemsLV.Items.EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowLinksHandler.GetSelectedGroup: TdxNavBarGroup;
|
|
var
|
|
ALink: TdxNavBarItemLink;
|
|
begin
|
|
if LinksTV.Selected <> nil then
|
|
begin
|
|
Result := GetGroupByNode(LinksTV.Selected);
|
|
if Result = nil then
|
|
begin
|
|
ALink := GetLinkByNode(LinksTV.Selected);
|
|
if ALink <> nil then Result := ALink.Group;
|
|
end;
|
|
end
|
|
else Result := nil;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowLinksHandler.GetSelectedItem: TdxNavBarItem;
|
|
begin
|
|
if ItemsLV.Selected <> nil then
|
|
Result := GetItemByNode(ItemsLV.Selected)
|
|
else Result := nil;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowLinksHandler.GetSelectedLink: TdxNavBarItemLink;
|
|
begin
|
|
if LinksTV.Selected <> nil then
|
|
Result := GetLinkByNode(LinksTV.Selected)
|
|
else Result := nil;
|
|
end;
|
|
|
|
type
|
|
TdxNavBarDsgnWindowViewsHandler = class(TdxNavBarDsgnWindowPageHandler)
|
|
protected
|
|
class function DesignerCaptionPostfix: string; override;
|
|
public
|
|
procedure UpdateButtonsPanel; override;
|
|
procedure UpdateContent; override;
|
|
procedure UpdateItem(AItem: TComponent); override;
|
|
end;
|
|
|
|
{ TdxNavBarDsgnWindowViewsHandler }
|
|
|
|
class function TdxNavBarDsgnWindowViewsHandler.DesignerCaptionPostfix: string;
|
|
begin
|
|
Result := sdxViewsDesigner;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowViewsHandler.UpdateContent;
|
|
begin
|
|
DsgnWindow.cbViewStyles.ItemIndex := NavBar.View;
|
|
DsgnWindow.nbPreview.View := NavBar.View;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowViewsHandler.UpdateButtonsPanel;
|
|
begin
|
|
DsgnWindow.pnBtnAddDelete.Visible := False;
|
|
DsgnWindow.pnBtnSelect.Visible := False;
|
|
DsgnWindow.pnBtnMove.Visible := False;
|
|
DsgnWindow.pnBtnDefaultSettings.Visible := False;
|
|
DsgnWindow.pnBtnApply.Visible := True;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowViewsHandler.UpdateItem(AItem: TComponent);
|
|
begin
|
|
if AItem = nil then UpdateContent;
|
|
end;
|
|
|
|
type
|
|
TdxNavBarDsgnWindowDefaultStylesHandler = class(TdxNavBarDsgnWindowPageHandler)
|
|
private
|
|
function GetItem(Index: Integer): TdxNavBarDefaultStyle;
|
|
function GetItemCount: Integer;
|
|
function GetSelected(Index: Integer): Boolean;
|
|
procedure SetSelected(Index: Integer; const Value: Boolean);
|
|
protected
|
|
class function DesignerCaptionPostfix: string; override;
|
|
function MainList: TListBox;
|
|
public
|
|
procedure GetSelections(const ASelections: IDesignerSelections); override;
|
|
procedure UpdateButtonsPanel; override;
|
|
procedure UpdateContent; override;
|
|
procedure UpdateSelections(const ASelections: IDesignerSelections); override;
|
|
|
|
property Selected[Index: Integer]: Boolean read GetSelected write SetSelected;
|
|
property Items[Index: Integer]: TdxNavBarDefaultStyle read GetItem;
|
|
property ItemCount: Integer read GetItemCount;
|
|
end;
|
|
|
|
{ TdxNavBarDsgnWindowDefaultStylesHandler }
|
|
|
|
class function TdxNavBarDsgnWindowDefaultStylesHandler.DesignerCaptionPostfix: string;
|
|
begin
|
|
Result := sdxDefaultStylesDesigner;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowDefaultStylesHandler.GetItem(
|
|
Index: Integer): TdxNavBarDefaultStyle;
|
|
begin
|
|
if MainList <> nil then
|
|
Result := TdxNavBarDefaultStyle(MainList.Items.Objects[Index])
|
|
else Result := nil;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowDefaultStylesHandler.GetItemCount: Integer;
|
|
begin
|
|
if MainList <> nil then
|
|
Result := MainList.Items.Count
|
|
else Result := 0;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowDefaultStylesHandler.GetSelected(
|
|
Index: Integer): Boolean;
|
|
begin
|
|
if MainList <> nil then
|
|
Result := MainList.Selected[Index]
|
|
else Result := False;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowDefaultStylesHandler.GetSelections(
|
|
const ASelections: IDesignerSelections);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to ItemCount - 1 do
|
|
if Selected[I] then
|
|
ASelections.Add(dxNavBarDsgnUtils.MakeIPersistent(Items[I]));
|
|
if ASelections.Count = 0 then
|
|
ASelections.Add(dxNavBarDsgnUtils.MakeIComponent(NavBar));
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowDefaultStylesHandler.MainList: TListBox;
|
|
begin
|
|
Result := DsgnWindow.lbxDefaultStyles;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowDefaultStylesHandler.UpdateContent;
|
|
var
|
|
PropList: TPropList;
|
|
V: Variant;
|
|
I: Integer;
|
|
AStyle: TdxNavBarDefaultStyle;
|
|
{$IFNDEF CLR}
|
|
ACount: Integer;
|
|
{$ENDIF}
|
|
begin
|
|
if MainList.Items.Count > 0 then exit;
|
|
{$IFNDEF CLR}
|
|
ACount := GetPropList(TypeInfo(TdxNavBarDefaultStyles), [tkClass], @PropList);
|
|
{$ELSE}
|
|
PropList := GetPropList(TypeInfo(TdxNavBarDefaultStyles), [tkClass]);
|
|
{$ENDIF}
|
|
{$IFNDEF CLR}
|
|
for I := 0 to ACount - 1 do
|
|
{$ELSE}
|
|
for I := Low(PropList) to High(PropList) do
|
|
{$ENDIF}
|
|
begin
|
|
if TdxNavBarDefaultStyle.ClassName = PropList[I].PropType{$IFNDEF CLR}^{$ENDIF}.Name then
|
|
begin
|
|
V := GetPropValue(NavBar.DefaultStyles, PropList[I].Name);
|
|
{$IFNDEF CLR} //TODO !!!!
|
|
AStyle := TdxNavBarDefaultStyle(TVarData(V).VPointer);
|
|
MainList.Items.AddObject(PropList[I].Name, AStyle);
|
|
{$ENDIF}
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowDefaultStylesHandler.UpdateButtonsPanel;
|
|
begin
|
|
DsgnWindow.pnBtnAddDelete.Visible := False;
|
|
DsgnWindow.pnBtnSelect.Visible := False;
|
|
DsgnWindow.pnBtnMove.Visible := False;
|
|
DsgnWindow.pnBtnDefaultSettings.Visible := True;
|
|
DsgnWindow.pnBtnApply.Visible := False;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowDefaultStylesHandler.SetSelected(
|
|
Index: Integer; const Value: Boolean);
|
|
begin
|
|
if MainList <> nil then
|
|
MainList.Selected[Index] := Value;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowDefaultStylesHandler.UpdateSelections(
|
|
const ASelections: IDesignerSelections);
|
|
|
|
function InSelection(AItem: TPersistent): Boolean;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := False;
|
|
for I := 0 to ASelections.Count - 1 do
|
|
if AItem = dxNavBarDsgnUtils.TryExtractPersistent(ASelections[I]) then
|
|
begin
|
|
Result := True;
|
|
break;
|
|
end;
|
|
end;
|
|
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to ItemCount - 1 do
|
|
if Selected[I] xor InSelection(Items[I]) then
|
|
Selected[I] := not Selected[I];
|
|
end;
|
|
|
|
{ TdxNavBarDsgnWindowPageHandler }
|
|
|
|
constructor TdxNavBarDsgnWindowPageHandler.Create(ADsgnWindow: TdxfmNavBarDesignWindow);
|
|
begin
|
|
inherited Create;
|
|
FDsgnWindow := ADsgnWindow;
|
|
end;
|
|
|
|
destructor TdxNavBarDsgnWindowPageHandler.Destroy;
|
|
begin
|
|
inherited;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowPageHandler.Activate;
|
|
begin
|
|
UpdateContent;
|
|
UpdateButtonsPanel;
|
|
UpdateButtonsState;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowPageHandler.Add;
|
|
begin
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowPageHandler.Copy;
|
|
begin
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowPageHandler.Cut;
|
|
begin
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowPageHandler.Delete;
|
|
begin
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowPageHandler.DeleteItem(AItem: TComponent);
|
|
begin
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowPageHandler.GetSelections(const ASelections: IDesignerSelections);
|
|
begin
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowPageHandler.MoveSelection(ADelta: Integer);
|
|
begin
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowPageHandler.Paste;
|
|
begin
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowPageHandler.UpdateContent;
|
|
begin
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowPageHandler.SelectAll;
|
|
begin
|
|
end;
|
|
|
|
class function TdxNavBarDsgnWindowPageHandler.DesignerCaptionPostfix: string;
|
|
begin
|
|
Result := sdxNavBarDesigner;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowPageHandler.CanAdd: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowPageHandler.CanCopy: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowPageHandler.CanCut: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowPageHandler.CanDelete: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowPageHandler.CanSelectAll: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowPageHandler.CanMoveUp: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowPageHandler.CanMoveDown: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowPageHandler.CanPaste: Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowPageHandler.UpdateButtonsPanel;
|
|
begin
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowPageHandler.UpdateButtonsState;
|
|
begin
|
|
DsgnWindow.UpdateButtonsState;
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowPageHandler.UpdateItem(AItem: TComponent);
|
|
begin
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowPageHandler.UpdateScrollBar;
|
|
begin
|
|
end;
|
|
|
|
procedure TdxNavBarDsgnWindowPageHandler.UpdateSelections(const ASelections: IDesignerSelections);
|
|
begin
|
|
end;
|
|
|
|
function TdxNavBarDsgnWindowPageHandler.GetNavBar: TdxCustomNavBar;
|
|
begin
|
|
if DsgnWindow <> nil then
|
|
Result := DsgnWindow.NavBar
|
|
else Result := nil;
|
|
end;
|
|
|
|
{ TdxfmNavBarDesignWindow }
|
|
|
|
constructor TdxfmNavBarDesignWindow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
FHandlers := TList.Create;
|
|
InitializeHandlers;
|
|
InitializeViewStyles;
|
|
|
|
btDelete.Tag := Integer(eaDelete);
|
|
btSelectAll.Tag := Integer(eaSelectAll);
|
|
miCut.Tag := Integer(eaCut);
|
|
miCopy.Tag := Integer(eaCopy);
|
|
miPaste.Tag := Integer(eaPaste);
|
|
miDelete.Tag := Integer(eaDelete);
|
|
miSelectAll.Tag := Integer(eaSelectAll);
|
|
|
|
pcMain.ActivePage := pcMain.Pages[0];
|
|
ActiveDesignerPageChanged;
|
|
RestoreLayout;
|
|
end;
|
|
|
|
destructor TdxfmNavBarDesignWindow.Destroy;
|
|
begin
|
|
FinalizeHandlers;
|
|
FHandlers.Free;
|
|
StoreLayout;
|
|
if NavBarDesigner <> nil then
|
|
TdxNavBarDesigner(NavBarDesigner).FDesignWindow := nil;
|
|
inherited;
|
|
end;
|
|
|
|
function TdxfmNavBarDesignWindow.ClipboardComponents: Boolean;
|
|
begin
|
|
Result := inherited ClipboardComponents;
|
|
end;
|
|
|
|
{$IFDEF DELPHI6}
|
|
function TdxfmNavBarDesignWindow.EditAction(Action: TEditAction): Boolean;
|
|
{$ELSE}
|
|
procedure TdxfmNavBarDesignWindow.EditAction(Action: TEditAction);
|
|
{$ENDIF}
|
|
begin
|
|
{$IFDEF DELPHI6}
|
|
Result := True;
|
|
{$ENDIF}
|
|
case Action of
|
|
eaCut: Cut;
|
|
eaCopy: Copy;
|
|
eaPaste: Paste;
|
|
eaDelete: Delete;
|
|
eaSelectAll: SelectAll;
|
|
end;
|
|
end;
|
|
|
|
function TdxfmNavBarDesignWindow.GetEditState: TEditState;
|
|
begin
|
|
Result := [];
|
|
if CanDelete then
|
|
Result := Result + [esCanDelete];
|
|
if CanSelectAll then
|
|
Result := Result + [esCanSelectAll];
|
|
if CanCut then
|
|
Result := Result + [esCanCut];
|
|
if CanCopy then
|
|
Result := Result + [esCanCopy];
|
|
if CanPaste then
|
|
Result := Result + [esCanPaste];
|
|
end;
|
|
|
|
{$IFDEF DELPHI6}
|
|
procedure TdxfmNavBarDesignWindow.ItemDeleted(const ADesigner: IDesigner;
|
|
Item: TPersistent);
|
|
{$ELSE}
|
|
procedure TdxfmNavBarDesignWindow.ComponentDeleted(Component: IPersistent);
|
|
{$ENDIF}
|
|
var
|
|
AComponent: TComponent;
|
|
begin
|
|
inherited;
|
|
{$IFDEF DELPHI6}
|
|
if Item is TComponent then
|
|
{$ENDIF}
|
|
begin
|
|
AComponent := dxNavBarDsgnUtils.TryExtractComponent({$IFDEF DELPHI6}Item{$ELSE}Component{$ENDIF});
|
|
if (NavBar <> nil) and not (csDestroying in NavBar.ComponentState) and
|
|
(CurrentHandler <> nil) then
|
|
CurrentHandler.DeleteItem(AComponent);
|
|
end;
|
|
end;
|
|
|
|
{$IFDEF DELPHI6}
|
|
procedure TdxfmNavBarDesignWindow.ItemsModified(const Designer: IDesigner);
|
|
{$ELSE}
|
|
procedure TdxfmNavBarDesignWindow.FormModified;
|
|
{$ENDIF}
|
|
begin
|
|
inherited;
|
|
UpdateCaption;
|
|
end;
|
|
|
|
{$IFDEF DELPHI6}
|
|
procedure TdxfmNavBarDesignWindow.SelectionChanged(const ADesigner: IDesigner;
|
|
const ASelection: IDesignerSelections);
|
|
{$ELSE}
|
|
procedure TdxfmNavBarDesignWindow.SelectionChanged(ASelection: TDesignerSelectionList);
|
|
{$ENDIF}
|
|
begin
|
|
inherited;
|
|
{$IFDEF DELPHI6}
|
|
if ADesigner = Designer then
|
|
{$ENDIF}
|
|
UpdateSelections(ASelection);
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.Activated;
|
|
var
|
|
Selections: IDesignerSelections;
|
|
begin
|
|
inherited;
|
|
if CurrentHandler <> nil then
|
|
CurrentHandler.Activate;
|
|
Selections := CreateSelectionList;
|
|
Designer.GetSelections(Selections);
|
|
UpdateSelections(Selections);
|
|
end;
|
|
|
|
{$IFDEF DELPHI9}
|
|
procedure TdxfmNavBarDesignWindow.CreateParams(var Params: TCreateParams);
|
|
begin
|
|
inherited;
|
|
Params.WndParent := Application.MainForm.Handle;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function TdxfmNavBarDesignWindow.UniqueName(Component: TComponent): string;
|
|
begin
|
|
if CurrentHandler is TdxNavBarDsgnWindowComponentCollectionPageHandler then
|
|
Result := NavBar.Name + (CurrentHandler as TdxNavBarDsgnWindowComponentCollectionPageHandler).ItemNamePrefix
|
|
else
|
|
Result := NavBar.Name;
|
|
Result := Designer.UniqueName(Result);
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.ActiveDesignerPageChanged;
|
|
begin
|
|
SelectNavBar;
|
|
if pcMain.ActivePage.PageIndex < HandlerCount then
|
|
begin
|
|
CurrentHandler := Handlers[pcMain.ActivePage.PageIndex];
|
|
if CurrentHandler <> nil then
|
|
CurrentHandler.Activate;
|
|
UpdateCaption;
|
|
end;
|
|
end;
|
|
|
|
function TdxfmNavBarDesignWindow.GetNavBarDesigner: TAbstractcxNavBarDesigner;
|
|
begin
|
|
if NavBar <> nil then
|
|
Result := NavBar.Designer
|
|
else Result := nil;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.SetNavBar(Value: TdxCustomNavBar);
|
|
begin
|
|
if FNavBar <> Value then
|
|
begin
|
|
FNavBar := Value;
|
|
if CurrentHandler <> nil then
|
|
CurrentHandler.UpdateContent;
|
|
UpdateCaption;
|
|
UpdateButtonsState;
|
|
end;
|
|
end;
|
|
|
|
function TdxfmNavBarDesignWindow.CanAdd: Boolean;
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
Result := CurrentHandler.CanAdd
|
|
else Result := False;
|
|
end;
|
|
|
|
function TdxfmNavBarDesignWindow.CanCopy: Boolean;
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
Result := CurrentHandler.CanCopy
|
|
else Result := False;
|
|
end;
|
|
|
|
function TdxfmNavBarDesignWindow.CanCut: Boolean;
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
Result := CurrentHandler.CanCut
|
|
else Result := False;
|
|
end;
|
|
|
|
function TdxfmNavBarDesignWindow.CanDelete: Boolean;
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
Result := CurrentHandler.CanDelete
|
|
else Result := False;
|
|
end;
|
|
|
|
function TdxfmNavBarDesignWindow.CanMoveDown: Boolean;
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
Result := CurrentHandler.CanMoveDown
|
|
else Result := False;
|
|
end;
|
|
|
|
function TdxfmNavBarDesignWindow.CanMoveUp: Boolean;
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
Result := CurrentHandler.CanMoveUp
|
|
else Result := False;
|
|
end;
|
|
|
|
function TdxfmNavBarDesignWindow.CanPaste: Boolean;
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
Result := CurrentHandler.CanPaste
|
|
else Result := False;
|
|
end;
|
|
|
|
function TdxfmNavBarDesignWindow.CanSelectAll: Boolean;
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
Result := CurrentHandler.CanSelectAll
|
|
else Result := False;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.Copy;
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
CurrentHandler.Copy;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.Cut;
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
CurrentHandler.Cut;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.Delete;
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
CurrentHandler.Delete;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.HandleException;
|
|
begin
|
|
Abort;
|
|
end;
|
|
|
|
function TdxfmNavBarDesignWindow.GetRegistryPath: string;
|
|
begin
|
|
{$IFNDEF CLR}
|
|
Result := (BorlandIDEServices as IOTAServices).GetBaseRegistryKey + '\' +
|
|
sdxExpressNavBarDesignerLayoutRegPath;
|
|
{$ELSE}
|
|
Result := sdxExpressNavBarDesignerLayoutRegPath;
|
|
{$ENDIF}
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.Paste;
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
CurrentHandler.Paste;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.RestoreLayout;
|
|
begin
|
|
with TRegistry.Create do
|
|
try
|
|
try
|
|
if OpenKey(GetRegistryPath, False) then
|
|
begin
|
|
if ValueExists(sdxWidth) then
|
|
Width := ReadInteger(sdxWidth);
|
|
if ValueExists(sdxHeight) then
|
|
Height := ReadInteger(sdxHeight);
|
|
end;
|
|
except
|
|
HandleException;
|
|
end;
|
|
finally
|
|
Free;
|
|
end;
|
|
if CurrentHandler <> nil then
|
|
CurrentHandler.UpdateScrollBar;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.Select(AComponent: TComponent; AddToSelection: Boolean);
|
|
var
|
|
Selections: IDesignerSelections;
|
|
begin
|
|
Selections := CreateSelectionList;
|
|
if AddToSelection then
|
|
Designer.GetSelections(Selections);
|
|
Selections.Add(dxNavBarDsgnUtils.MakeIComponent(AComponent));
|
|
Designer.SetSelections(Selections);
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.SelectAll;
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
CurrentHandler.SelectAll;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.SelectNavBar;
|
|
begin
|
|
if NavBar <> nil then
|
|
Select(NavBar, False);
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.StartWait;
|
|
begin
|
|
FSaveCursor := Screen.Cursor;
|
|
Screen.Cursor := crHourGlass;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.StopWait;
|
|
begin
|
|
Screen.Cursor := FSaveCursor;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.StoreLayout;
|
|
begin
|
|
with TRegistry.Create do
|
|
try
|
|
try
|
|
if OpenKey(GetRegistryPath, True) then
|
|
begin
|
|
WriteInteger(sdxWidth, Width);
|
|
WriteInteger(sdxHeight, Height);
|
|
end;
|
|
except
|
|
HandleException;
|
|
end;
|
|
finally
|
|
Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.UpdateButtonsState;
|
|
begin
|
|
btAdd.Enabled := CanAdd;
|
|
btDelete.Enabled := CanDelete;
|
|
btSelectAll.Enabled := CanSelectAll;
|
|
btMoveUp.Enabled := CanMoveUp;
|
|
btMoveDown.Enabled := CanMoveDown;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.UpdateCaption;
|
|
var
|
|
APostfix: string;
|
|
begin
|
|
if (NavBar <> nil) and (NavBar.Owner <> nil) then
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
APostfix := CurrentHandler.DesignerCaptionPostfix
|
|
else APostfix := sdxNavBarDesigner;
|
|
Caption := Format(sdxDesignerCaption, [NavBar.Owner.Name, NavBar.Name, APostfix]);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.UpdateItem(AItem: TComponent);
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
CurrentHandler.UpdateItem(AItem);
|
|
UpdateButtonsState;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.UpdateMenuState;
|
|
begin
|
|
miAdd.Enabled := CanAdd;
|
|
miCut.Enabled := CanCut;
|
|
miCopy.Enabled := CanCopy;
|
|
miPaste.Enabled := CanPaste;
|
|
miDelete.Enabled := CanDelete;
|
|
miSelectAll.Enabled := CanSelectAll;
|
|
miMoveUp.Enabled := CanMoveUp;
|
|
miMoveDown.Enabled := CanMoveDown;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.UpdateSelections(const ASelections: IDesignerSelections);
|
|
begin
|
|
if (NavBar = nil) or (csDestroying in NavBar.ComponentState) or (ASelections = nil) then exit;
|
|
if CurrentHandler <> nil then
|
|
CurrentHandler.UpdateSelections(ASelections);
|
|
UpdateButtonsState;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.ListBoxClick(Sender: TObject);
|
|
var
|
|
Selections: IDesignerSelections;
|
|
begin
|
|
Selections := CreateSelectionList;
|
|
if CurrentHandler <> nil then
|
|
CurrentHandler.GetSelections(Selections);
|
|
Designer.SetSelections(Selections);
|
|
end;
|
|
|
|
function TdxfmNavBarDesignWindow.GetHandler(Index: Integer): TdxNavBarDsgnWindowPageHandler;
|
|
begin
|
|
Result := TdxNavBarDsgnWindowPageHandler(FHandlers.Items[Index]);
|
|
end;
|
|
|
|
function TdxfmNavBarDesignWindow.GetHandlerCount: Integer;
|
|
begin
|
|
Result := FHandlers.Count;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.InitializeHandlers;
|
|
begin
|
|
FHandlers.Add(TdxNavBarDsgnWindowGroupsHandler.Create(Self));
|
|
FHandlers.Add(TdxNavBarDsgnWindowItemsHandler.Create(Self));
|
|
FHandlers.Add(TdxNavBarDsgnWindowLinksHandler.Create(Self));
|
|
FHandlers.Add(TdxNavBarDsgnWindowViewsHandler.Create(Self));
|
|
FHandlers.Add(TdxNavBarDsgnWindowDefaultStylesHandler.Create(Self));
|
|
FHandlers.Add(TdxNavBarDsgnWindowCustomStylesHandler.Create(Self));
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.InitializeViewStyles;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to dxNavBarViewsFactory.Count - 1 do
|
|
cbViewStyles.Items.Add(dxNavBarViewsFactory.Names[I]);
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.FinalizeHandlers;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to FHandlers.Count - 1 do
|
|
TdxNavBarDsgnWindowPageHandler(FHandlers.Items[I]).Free;
|
|
FHandlers.Clear;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.AddClick(Sender: TObject);
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
CurrentHandler.Add;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.ActionClick(Sender: TObject);
|
|
begin
|
|
EditAction(TEditAction(TComponent(Sender).Tag));
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.MoveUpClick(Sender: TObject);
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
CurrentHandler.MoveSelection(-1);
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.MoveDownClick(Sender: TObject);
|
|
begin
|
|
if CurrentHandler <> nil then
|
|
CurrentHandler.MoveSelection(1);
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.tvLinkDesignerGroupsDragDrop(Sender,
|
|
Source: TObject; X, Y: Integer);
|
|
var
|
|
AGroup: TdxNavBarGroup;
|
|
AIndex: Integer;
|
|
begin
|
|
if CurrentHandler is TdxNavBarDsgnWindowLinksHandler then
|
|
with (CurrentHandler as TdxNavBarDsgnWindowLinksHandler) do
|
|
begin
|
|
SetTargetGroupNodeImage(1);
|
|
SetTargetLinkNodeImage(2);
|
|
if TargetLink <> nil then
|
|
begin
|
|
AIndex := TargetLink.Index;
|
|
AGroup := TargetLink.Group;
|
|
end
|
|
else
|
|
begin
|
|
AIndex := -1;
|
|
AGroup := TargetGroup;
|
|
end;
|
|
if AGroup <> nil then
|
|
begin
|
|
if SourceItem <> nil then
|
|
CreateLink(SourceItem, AGroup, AIndex)
|
|
else if SourceLink <> nil then
|
|
MoveLink(SourceLink, AGroup, AIndex);
|
|
end;
|
|
SourceItem := nil;
|
|
SourceLink := nil;
|
|
ClearTargets;
|
|
end;
|
|
UpdateButtonsState;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.tvLinkDesignerGroupsDragOver(Sender,
|
|
Source: TObject; X, Y: Integer; State: TDragState; var Accept: Boolean);
|
|
begin
|
|
if CurrentHandler is TdxNavBarDsgnWindowLinksHandler then
|
|
with (CurrentHandler as TdxNavBarDsgnWindowLinksHandler) do
|
|
begin
|
|
Accept := (SourceLink <> nil) or (SourceItem <> nil);
|
|
if Accept then
|
|
UpdateTargets(tvLinkDesignerGroups.GetNodeAt(X, Y));
|
|
Accept := Accept and ((TargetGroup <> nil) or (TargetLink <> nil));
|
|
end
|
|
else Accept := False;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.lbxLinkDesignerItemsDragOver(Sender,
|
|
Source: TObject; X, Y: Integer; State: TDragState; var Accept: Boolean);
|
|
begin
|
|
if CurrentHandler is TdxNavBarDsgnWindowLinksHandler then
|
|
with (CurrentHandler as TdxNavBarDsgnWindowLinksHandler) do
|
|
Accept := (SourceLink <> nil)
|
|
else Accept := False
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.lbxLinkDesignerItemsDragDrop(Sender,
|
|
Source: TObject; X, Y: Integer);
|
|
begin
|
|
if CurrentHandler is TdxNavBarDsgnWindowLinksHandler then
|
|
with (CurrentHandler as TdxNavBarDsgnWindowLinksHandler) do
|
|
begin
|
|
RemoveLink(SourceLink);
|
|
SourceLink := nil;
|
|
end;
|
|
UpdateButtonsState;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.lbxLinkDesignerItemsStartDrag(
|
|
Sender: TObject; var DragObject: TDragObject);
|
|
begin
|
|
if CurrentHandler is TdxNavBarDsgnWindowLinksHandler then
|
|
with (CurrentHandler as TdxNavBarDsgnWindowLinksHandler) do
|
|
begin
|
|
SourceItem := GetItemByNode(lbxLinkDesignerItems.Selected);
|
|
if SourceItem = nil then CancelDrag;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.tvLinkDesignerGroupsStartDrag(
|
|
Sender: TObject; var DragObject: TDragObject);
|
|
begin
|
|
if CurrentHandler is TdxNavBarDsgnWindowLinksHandler then
|
|
with (CurrentHandler as TdxNavBarDsgnWindowLinksHandler) do
|
|
begin
|
|
SourceLink := GetLinkByNode(tvLinkDesignerGroups.Selected);
|
|
if SourceLink = nil then CancelDrag;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.tvLinkDesignerGroupsExit(
|
|
Sender: TObject);
|
|
begin
|
|
if CurrentHandler is TdxNavBarDsgnWindowLinksHandler then
|
|
with (CurrentHandler as TdxNavBarDsgnWindowLinksHandler) do ClearTargets;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.pmMainPopup(Sender: TObject);
|
|
begin
|
|
UpdateMenuState;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.tvLinkDesignerGroupsClick(
|
|
Sender: TObject);
|
|
begin
|
|
UpdateButtonsState;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.lbxLinkDesignerItemsClick(
|
|
Sender: TObject);
|
|
begin
|
|
UpdateButtonsState;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.tvLinkDesignerGroupsEndDrag(Sender,
|
|
Target: TObject; X, Y: Integer);
|
|
begin
|
|
if CurrentHandler is TdxNavBarDsgnWindowLinksHandler then
|
|
with (CurrentHandler as TdxNavBarDsgnWindowLinksHandler) do ClearTargets;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.lbxLinkDesignerItemsEndDrag(Sender,
|
|
Target: TObject; X, Y: Integer);
|
|
begin
|
|
if CurrentHandler is TdxNavBarDsgnWindowLinksHandler then
|
|
with (CurrentHandler as TdxNavBarDsgnWindowLinksHandler) do ClearTargets;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.nbMainLinkClick(Sender: TObject;
|
|
ALink: TdxNavBarItemLink);
|
|
begin
|
|
if ALink.Item.Index < pcMain.PageCount then
|
|
pcMain.ActivePage := pcMain.Pages[ALink.Item.Index];
|
|
ActiveDesignerPageChanged;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.DefaultSettingsClick(Sender: TObject);
|
|
begin
|
|
NavBar.AssignDefaultStyles;
|
|
Designer.Modified;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.cbViewStylesChange(Sender: TObject);
|
|
begin
|
|
nbPreview.View := (Sender as TComboBox).ItemIndex;
|
|
end;
|
|
|
|
procedure TdxfmNavBarDesignWindow.btnApplyClick(Sender: TObject);
|
|
begin
|
|
NavBar.View := nbPreview.View;
|
|
Designer.Modified;
|
|
end;
|
|
|
|
end.
|
|
|