david
47aaf11578
git-svn-id: https://192.168.0.254/svn/Componentes.Terceros.DevExpressVCL@38 05c56307-c608-d34a-929d-697000501d7a
562 lines
18 KiB
ObjectPascal
562 lines
18 KiB
ObjectPascal
|
|
{*******************************************************************}
|
|
{ }
|
|
{ Developer Express Visual Component Library }
|
|
{ ExpressBars DB Navigator }
|
|
{ }
|
|
{ Copyright (c) 1998-2009 Developer Express Inc. }
|
|
{ ALL RIGHTS RESERVED }
|
|
{ }
|
|
{ The entire contents of this file is protected by U.S. and }
|
|
{ International Copyright Laws. Unauthorized reproduction, }
|
|
{ reverse-engineering, and distribution of all or any portion of }
|
|
{ the code contained in this file is strictly prohibited and may }
|
|
{ result in severe civil and criminal penalties and will be }
|
|
{ prosecuted to the maximum extent possible under the law. }
|
|
{ }
|
|
{ RESTRICTIONS }
|
|
{ }
|
|
{ THIS SOURCE CODE AND ALL RESULTING INTERMEDIATE FILES }
|
|
{ (DCU, OBJ, DLL, ETC.) ARE CONFIDENTIAL AND PROPRIETARY TRADE }
|
|
{ SECRETS OF DEVELOPER EXPRESS INC. THE REGISTERED DEVELOPER IS }
|
|
{ LICENSED TO DISTRIBUTE THE 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 dxBarDBNav;
|
|
|
|
interface
|
|
|
|
{$I cxVer.inc}
|
|
|
|
uses
|
|
Classes, Messages, DB, dxBar;
|
|
|
|
type
|
|
TdxBarDBNavigator = class;
|
|
TdxBarDBNavButton = class;
|
|
|
|
TdxBarDBNavDataLink = class(TDataLink)
|
|
private
|
|
FNavigator: TdxBarDBNavigator;
|
|
protected
|
|
procedure ActiveChanged; override;
|
|
procedure DataSetChanged; override;
|
|
procedure EditingChanged; override;
|
|
end;
|
|
|
|
TdxBarDBEnableType = (dxdbtCanModify, dxdbtNotEOF, dxdbtNotBOF,
|
|
dxdbtHasRecords, dxdbtIsModified, dxdbtIsNotModified);
|
|
TdxBarDBEnableTypes = set of TdxBarDBEnableType;
|
|
|
|
TdxBarDBCheckLink = class(TCollectionItem)
|
|
private
|
|
FItem: TdxBarItem;
|
|
FEnableTypes: TdxBarDBEnableTypes;
|
|
function GetDBNavigator: TdxBarDBNavigator;
|
|
procedure SetEnableTypes(Value: TdxBarDBEnableTypes);
|
|
public
|
|
procedure Assign(Value: TPersistent); override;
|
|
property DBNavigator: TdxBarDBNavigator read GetDBNavigator;
|
|
published
|
|
property Item: TdxBarItem read FItem write FItem;
|
|
property EnableTypes: TdxBarDBEnableTypes read FEnableTypes write SetEnableTypes;
|
|
end;
|
|
|
|
TdxBarDBCheckLinks = class(TCollection)
|
|
private
|
|
FDBNavigator: TdxBarDBNavigator;
|
|
function GetItem(Index: Integer): TdxBarDBCheckLink;
|
|
protected
|
|
function GetOwner: TPersistent; override;
|
|
procedure RemoveItem(Item: TdxBarItem);
|
|
public
|
|
function Add: TdxBarDBCheckLink;
|
|
property Items[Index: Integer]: TdxBarDBCheckLink read GetItem; default;
|
|
end;
|
|
|
|
TdxBarDBNavButtonType = (dxbnFirst, dxbnPrior, dxbnNext, dxbnLast,
|
|
dxbnInsert, dxbnDelete, dxbnEdit, dxbnPost, dxbnCancel, dxbnRefresh);
|
|
TdxBarDBNavButtonTypes = set of TdxBarDBNavButtonType;
|
|
|
|
TdxBarDBNavButton = class(TdxBarButton)
|
|
private
|
|
FBarDBNavigator: TdxBarDBNavigator;
|
|
FNavButton: TdxBarDBNavButtonType;
|
|
procedure SetNavButton(Value: TdxBarDBNavButtonType);
|
|
protected
|
|
procedure Loaded; override;
|
|
public
|
|
destructor Destroy; override;
|
|
procedure DoClick; override;
|
|
published
|
|
property BarDBNavigator: TdxBarDBNavigator read FBarDBNavigator write FBarDBNavigator;
|
|
property NavButton: TdxBarDBNavButtonType read FNavButton write SetNavButton;
|
|
end;
|
|
|
|
TdxBarDBNavigator = class(TComponent)
|
|
private
|
|
FBarManager: TdxBarManager;
|
|
FCategoryName: string;
|
|
FConfirmDelete: Boolean;
|
|
FDataLink: TdxBarDBNavDataLink;
|
|
FDBCheckLinks: TdxBarDBCheckLinks;
|
|
FSetVisFlag: Boolean;
|
|
FVisibleButtons: TdxBarDBNavButtonTypes;
|
|
|
|
function GetDataSource: TDataSource;
|
|
procedure SetBarManager(Value: TdxBarManager);
|
|
procedure SetCategoryName(Value: string);
|
|
procedure SetDataSource(Value: TDataSource);
|
|
procedure SetDBNavItems(Value: TdxBarDBCheckLinks);
|
|
procedure SetVisibleButtons(Value: TdxBarDBNavButtonTypes);
|
|
|
|
procedure AddButton(AButton: TdxBarDBNavButton);
|
|
procedure RemoveButton(AButton: TdxBarDBNavButton);
|
|
procedure CheckItemsEnable;
|
|
protected
|
|
Buttons: array[TdxBarDBNavButtonType] of TdxBarDBNavButton;
|
|
procedure ActiveChanged;
|
|
procedure DataChanged;
|
|
procedure EditingChanged;
|
|
procedure Notification(AComponent: TComponent; Operation: TOperation); override;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
destructor Destroy; override;
|
|
published
|
|
property BarManager: TdxBarManager read FBarManager write SetBarManager;
|
|
property CategoryName: string read FCategoryName write SetCategoryName;
|
|
property ConfirmDelete: Boolean read FConfirmDelete write FConfirmDelete;
|
|
property DataSource: TDataSource read GetDataSource write SetDataSource;
|
|
property DBCheckLinks: TdxBarDBCheckLinks read FDBCheckLinks write SetDBNavItems;
|
|
property VisibleButtons: TdxBarDBNavButtonTypes read FVisibleButtons
|
|
write SetVisibleButtons default [];
|
|
end;
|
|
|
|
implementation
|
|
|
|
{$R dxBarDBNav.res}
|
|
|
|
uses
|
|
Windows, SysUtils, Forms, dxBarDBNavStrs, cxClasses;
|
|
|
|
const
|
|
BtnResStr = 'DXBARDBNAVBTN_';
|
|
dxBarDBNavBtnName = 'dxBarDBNav';
|
|
|
|
{ TdxBarDBNavDataLink }
|
|
|
|
procedure TdxBarDBNavDataLink.ActiveChanged;
|
|
begin
|
|
if FNavigator <> nil then FNavigator.ActiveChanged;
|
|
end;
|
|
|
|
procedure TdxBarDBNavDataLink.DataSetChanged;
|
|
begin
|
|
if FNavigator <> nil then FNavigator.DataChanged;
|
|
end;
|
|
|
|
procedure TdxBarDBNavDataLink.EditingChanged;
|
|
begin
|
|
if FNavigator <> nil then FNavigator.EditingChanged;
|
|
end;
|
|
|
|
{ TdxBarDBCheckLink }
|
|
|
|
function TdxBarDBCheckLink.GetDBNavigator: TdxBarDBNavigator;
|
|
begin
|
|
Result := TdxBarDBCheckLinks(Collection).FDBNavigator;
|
|
end;
|
|
|
|
procedure TdxBarDBCheckLink.SetEnableTypes(Value: TdxBarDBEnableTypes);
|
|
begin
|
|
if FEnableTypes <> Value then
|
|
begin
|
|
FEnableTypes := Value;
|
|
TdxBarDBCheckLinks(Collection).FDBNavigator.DataChanged;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxBarDBCheckLink.Assign(Value: TPersistent);
|
|
var
|
|
ADBNavItem: TdxBarDBCheckLink;
|
|
begin
|
|
if Value is TdxBarDBCheckLink then
|
|
begin
|
|
ADBNavItem := TdxBarDBCheckLink(Value);
|
|
if (ADBNavItem.Item <> nil) and (DBNavigator <> nil) and
|
|
(csUpdating in DBNavigator.ComponentState) and (DBNavigator.BarManager <> nil) then
|
|
FItem := DBNavigator.BarManager.GetItemByName(ADBNavItem.FItem.Name)
|
|
else
|
|
FItem := ADBNavItem.FItem;
|
|
FEnableTypes := ADBNavItem.FEnableTypes;
|
|
end
|
|
else
|
|
inherited Assign(Value);
|
|
end;
|
|
|
|
{ TdxBarDBCheckLinks }
|
|
|
|
function TdxBarDBCheckLinks.GetItem(Index: Integer): TdxBarDBCheckLink;
|
|
begin
|
|
if (Index > -1) and (Index < Count) then
|
|
Result := TdxBarDBCheckLink(inherited Items[Index])
|
|
else Result := nil;
|
|
end;
|
|
|
|
function TdxBarDBCheckLinks.GetOwner: TPersistent;
|
|
begin
|
|
Result := FDBNavigator;
|
|
end;
|
|
|
|
procedure TdxBarDBCheckLinks.RemoveItem(Item: TdxBarItem);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := Count - 1 downto 0 do
|
|
if Items[I].Item = Item then Items[I].Free;
|
|
end;
|
|
|
|
function TdxBarDBCheckLinks.Add: TdxBarDBCheckLink;
|
|
begin
|
|
Result := TdxBarDBCheckLink(inherited Add);
|
|
end;
|
|
|
|
{ dxBarDBNavButton }
|
|
|
|
destructor TdxBarDBNavButton.Destroy;
|
|
begin
|
|
if BarDBNavigator <> nil then
|
|
BarDBNavigator.RemoveButton(Self);
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TdxBarDBNavButton.SetNavButton(Value: TdxBarDBNavButtonType);
|
|
const
|
|
dxBarNames: array[TdxBarDBNavButtonType] of string =
|
|
('First', 'Prev', 'Next', 'Last',
|
|
'Insert', 'Delete', 'Edit', 'Post', 'Cancel', 'Refresh');
|
|
PResStrs: array[TdxBarDBNavButtonType] of Pointer = (@dxSBAR_BTNCAPTION_FIRST,
|
|
@dxSBAR_BTNCAPTION_PRIOR, @dxSBAR_BTNCAPTION_NEXT, @dxSBAR_BTNCAPTION_LAST,
|
|
@dxSBAR_BTNCAPTION_INSERT, @dxSBAR_BTNCAPTION_DELETE, @dxSBAR_BTNCAPTION_EDIT,
|
|
@dxSBAR_BTNCAPTION_POST, @dxSBAR_BTNCAPTION_CANCEL, @dxSBAR_BTNCAPTION_REFRESH);
|
|
begin
|
|
if (FNavButton <> Value) or (Name = '') then
|
|
if csLoading in ComponentState then
|
|
FNavButton := Value
|
|
else
|
|
begin
|
|
if (BarDBNavigator <> nil) and not BarDBNavigator.FSetVisFlag and
|
|
(BarDBNavigator.Buttons[Value] <> nil) then
|
|
raise Exception.Create(cxGetResourceString(@dxSBAR_DBNAVERROR1));
|
|
if (BarDBNavigator <> nil) and not BarDBNavigator.FSetVisFlag then
|
|
BarDBNavigator.RemoveButton(Self);
|
|
FNavButton := Value;
|
|
if BarDBNavigator <> nil then
|
|
begin
|
|
BarDBNavigator.AddButton(Self);
|
|
Glyph.LoadFromResourceName(HInstance,
|
|
PChar(BtnResStr + IntToStr(Integer(FNavButton) + 1)));
|
|
end;
|
|
try
|
|
if BarManager.Designing then
|
|
Name := dxBarDesigner.UniqueName(BarManager, dxBarDBNavBtnName + dxBarNames[FNavButton]);
|
|
Caption := cxGetResourceString(PResStrs[FNavButton]);
|
|
Hint := Caption;
|
|
except
|
|
raise;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxBarDBNavButton.Loaded;
|
|
begin
|
|
inherited Loaded;
|
|
if BarDBNavigator <> nil then
|
|
begin
|
|
BarDBNavigator.AddButton(Self);
|
|
BarDBNavigator.ActiveChanged;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxBarDBNavButton.DoClick;
|
|
begin
|
|
inherited;
|
|
if Assigned(OnClick) then Exit;
|
|
if BarDBNavigator <> nil then
|
|
with BarDBNavigator.FDataLink.DataSet do
|
|
case FNavButton of
|
|
dxbnFirst: First;
|
|
dxbnPrior: Prior;
|
|
dxbnNext: Next;
|
|
dxbnLast: Last;
|
|
dxbnInsert: Insert;
|
|
dxbnDelete:
|
|
if not BarDBNavigator.ConfirmDelete or
|
|
(Application.MessageBox(PChar(cxGetResourceString(@dxSBAR_DELETERECORD)),
|
|
PChar(Application.Title), MB_ICONQUESTION or MB_YESNO) = ID_YES) then
|
|
Delete;
|
|
dxbnEdit: Edit;
|
|
dxbnPost: Post;
|
|
dxbnCancel: Cancel;
|
|
dxbnRefresh: Refresh;
|
|
end;
|
|
end;
|
|
|
|
{ TdxBarDBNavigator }
|
|
|
|
constructor TdxBarDBNavigator.Create(AOwner: TComponent);
|
|
var
|
|
ABarManager: TdxBarManager;
|
|
begin
|
|
ABarManager := nil;
|
|
if AOwner is TCustomForm then
|
|
ABarManager := GetBarManagerByForm(TCustomForm(AOwner));
|
|
{if (ABarManager = nil) and (dxBarManagerList.Count <> 0) then
|
|
ABarManager := dxBarManagerList[0];}
|
|
inherited Create(AOwner);
|
|
FBarManager := ABarManager;
|
|
FDataLink := TdxBarDBNavDataLink.Create;
|
|
FDataLink.FNavigator := Self;
|
|
FCategoryName := cxGetResourceString(@dxSBAR_CATEGORYNAME);
|
|
FDBCheckLinks := TdxBarDBCheckLinks.Create(TdxBarDBCheckLink);
|
|
FDBCheckLinks.FDBNavigator := Self;
|
|
end;
|
|
|
|
destructor TdxBarDBNavigator.Destroy;
|
|
begin
|
|
VisibleButtons := [];
|
|
FDBCheckLinks.Free;
|
|
FDataLink.FNavigator := nil;
|
|
FDataLink.Free;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TdxBarDBNavigator.Notification(AComponent: TComponent; Operation: TOperation);
|
|
begin
|
|
inherited Notification(AComponent, Operation);
|
|
if Operation = opRemove then
|
|
begin
|
|
if AComponent = BarManager then BarManager := nil;
|
|
if AComponent = DataSource then DataSource := nil;
|
|
if AComponent is TdxBarItem then
|
|
FDBCheckLinks.RemoveItem(TdxBarItem(AComponent));
|
|
end;
|
|
end;
|
|
|
|
procedure TdxBarDBNavigator.CheckItemsEnable;
|
|
var
|
|
I: Integer;
|
|
Flag: Boolean;
|
|
begin
|
|
for I := 0 to FDBCheckLinks.Count - 1 do
|
|
with FDBCheckLinks[I] do
|
|
if Item <> nil then
|
|
begin
|
|
Flag := FDataLink.Active;
|
|
if dxdbtCanModify in EnableTypes then
|
|
Flag := Flag and FDataLink.DataSet.CanModify;
|
|
if dxdbtNotEOF in EnableTypes then
|
|
Flag := Flag and not FDataLink.DataSet.EOF;
|
|
if dxdbtNotBOF in EnableTypes then
|
|
Flag := Flag and not FDataLink.DataSet.BOF;
|
|
if dxdbtHasRecords in EnableTypes then
|
|
Flag := Flag and not (FDataLink.DataSet.BOF and FDataLink.DataSet.EOF);
|
|
if dxdbtIsModified in EnableTypes then
|
|
Flag := Flag and FDataLink.Editing;
|
|
if dxdbtIsNotModified in EnableTypes then
|
|
Flag := Flag and not FDataLink.Editing;
|
|
Item.Enabled := Flag;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxBarDBNavigator.DataChanged;
|
|
var
|
|
UpEnable, DnEnable: Boolean;
|
|
begin
|
|
UpEnable := FDataLink.Active and not FDataLink.DataSet.BOF;
|
|
DnEnable := FDataLink.Active and not FDataLink.DataSet.EOF;
|
|
if Buttons[dxbnFirst] <> nil then
|
|
Buttons[dxbnFirst].Enabled := UpEnable;
|
|
if Buttons[dxbnPrior] <> nil then
|
|
Buttons[dxbnPrior].Enabled := UpEnable;
|
|
if Buttons[dxbnNext] <> nil then
|
|
Buttons[dxbnNext].Enabled := DnEnable;
|
|
if Buttons[dxbnLast] <> nil then
|
|
Buttons[dxbnLast].Enabled := DnEnable;
|
|
if Buttons[dxbnDelete] <> nil then
|
|
Buttons[dxbnDelete].Enabled := FDataLink.Active and FDataLink.DataSet.CanModify and
|
|
not (FDataLink.DataSet.BOF and FDataLink.DataSet.EOF);
|
|
if Buttons[dxbnRefresh] <> nil then
|
|
Buttons[dxbnRefresh].Enabled := FDataLink.Active;
|
|
CheckItemsEnable;
|
|
end;
|
|
|
|
procedure TdxBarDBNavigator.EditingChanged;
|
|
var
|
|
CanModify: Boolean;
|
|
begin
|
|
CanModify := FDataLink.Active and FDataLink.DataSet.CanModify;
|
|
if Buttons[dxbnInsert] <> nil then
|
|
Buttons[dxbnInsert].Enabled := CanModify;
|
|
if Buttons[dxbnEdit] <> nil then
|
|
Buttons[dxbnEdit].Enabled := CanModify and not FDataLink.Editing;
|
|
if Buttons[dxbnPost] <> nil then
|
|
Buttons[dxbnPost].Enabled := CanModify and FDataLink.Editing;
|
|
if Buttons[dxbnCancel] <> nil then
|
|
Buttons[dxbnCancel].Enabled := CanModify and FDataLink.Editing;
|
|
CheckItemsEnable;
|
|
end;
|
|
|
|
procedure TdxBarDBNavigator.ActiveChanged;
|
|
var
|
|
I: TdxBarDBNavButtonType;
|
|
J: Integer;
|
|
begin
|
|
if not FDataLink.Active then
|
|
begin
|
|
for I := Low(Buttons) to High(Buttons) do
|
|
if Buttons[I] <> nil then
|
|
Buttons[I].Enabled := False;
|
|
for J := 0 to FDBCheckLinks.Count - 1 do
|
|
if FDBCheckLinks[J].Item <> nil then
|
|
FDBCheckLinks[J].Item.Enabled := False;
|
|
end
|
|
else
|
|
begin
|
|
DataChanged;
|
|
EditingChanged;
|
|
end;
|
|
end;
|
|
|
|
function TdxBarDBNavigator.GetDataSource: TDataSource;
|
|
begin
|
|
Result := FDataLink.DataSource;
|
|
end;
|
|
|
|
procedure TdxBarDBNavigator.SetBarManager(Value: TdxBarManager);
|
|
var
|
|
SaveVisButtons: TdxBarDBNavButtonTypes;
|
|
begin
|
|
if FBarManager <> Value then
|
|
begin
|
|
SaveVisButtons := FVisibleButtons;
|
|
VisibleButtons := [];
|
|
FBarManager := Value;
|
|
VisibleButtons := SaveVisButtons;
|
|
end;
|
|
end;
|
|
|
|
procedure TdxBarDBNavigator.SetCategoryName(Value: string);
|
|
var
|
|
Index1, Index2: Integer;
|
|
I: TdxBarDBNavButtonType;
|
|
begin
|
|
if FCategoryName <> Value then
|
|
if csLoading in ComponentState then
|
|
FCategoryName := Value
|
|
else
|
|
if BarManager <> nil then
|
|
begin
|
|
Index1 := BarManager.Categories.IndexOf(FCategoryName);
|
|
FCategoryName := Value;
|
|
Index2 := BarManager.Categories.IndexOf(FCategoryName);
|
|
if Index2 = -1 then
|
|
begin
|
|
BarManager.Categories.Add(FCategoryName);
|
|
Index2 := BarManager.Categories.IndexOf(FCategoryName);
|
|
end;
|
|
for I := Low(Buttons) to High(Buttons) do
|
|
if Buttons[I] <> nil then Buttons[I].Category := Index2;
|
|
if (Index1 > -1) and (BarManager.GetCountByCategory(Index1) = 0) then
|
|
BarManager.Categories.Delete(Index1);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxBarDBNavigator.SetDataSource(Value: TDataSource);
|
|
begin
|
|
FDataLink.DataSource := Value;
|
|
if not (csLoading in ComponentState) then ActiveChanged;
|
|
if Value <> nil then Value.FreeNotification(Self);
|
|
end;
|
|
|
|
procedure TdxBarDBNavigator.SetDBNavItems(Value: TdxBarDBCheckLinks);
|
|
begin
|
|
FDBCheckLinks.Assign(Value);
|
|
DataChanged;
|
|
end;
|
|
|
|
procedure TdxBarDBNavigator.SetVisibleButtons(Value: TdxBarDBNavButtonTypes);
|
|
var
|
|
I: TdxBarDBNavButtonType;
|
|
AIndex: Integer;
|
|
begin
|
|
if FVisibleButtons <> Value then
|
|
begin
|
|
FVisibleButtons := Value;
|
|
FSetVisFlag := True;
|
|
if not (csLoading in ComponentState) and (BarManager <> nil) then
|
|
for I := Low(Buttons) to High(Buttons) do
|
|
begin
|
|
if (Buttons[I] <> nil) and //not (csDestroying in Buttons[I].ComponentState) and
|
|
not (I in Value) then
|
|
begin
|
|
Buttons[I].Free;
|
|
Buttons[I] := nil;
|
|
end;
|
|
if (Buttons[I] = nil) and (I in Value) then
|
|
begin
|
|
Buttons[I] := TdxBarDBNavButton.Create(Owner);
|
|
with Buttons[I] do
|
|
begin
|
|
BarDBNavigator := Self;
|
|
AIndex := BarManager.Categories.IndexOf(FCategoryName);
|
|
if AIndex = -1 then
|
|
begin
|
|
BarManager.Categories.Add(FCategoryName);
|
|
AIndex := BarManager.Categories.IndexOf(FCategoryName);
|
|
end;
|
|
Category := AIndex;
|
|
NavButton := I;
|
|
end;
|
|
end;
|
|
end;
|
|
ActiveChanged;
|
|
FSetVisFlag := False;
|
|
end;
|
|
if (FVisibleButtons = []) and (BarManager <> nil) and
|
|
not (csDestroying in BarManager.ComponentState) then
|
|
begin
|
|
AIndex := BarManager.Categories.IndexOf(FCategoryName);
|
|
if (AIndex > -1) and (BarManager.GetCountByCategory(AIndex) = 0) then
|
|
BarManager.Categories.Delete(AIndex);
|
|
end;
|
|
end;
|
|
|
|
procedure TdxBarDBNavigator.AddButton(AButton: TdxBarDBNavButton);
|
|
begin
|
|
Buttons[AButton.NavButton] := AButton;
|
|
FVisibleButtons := FVisibleButtons + [AButton.NavButton];
|
|
end;
|
|
|
|
procedure TdxBarDBNavigator.RemoveButton(AButton: TdxBarDBNavButton);
|
|
begin
|
|
Buttons[AButton.NavButton] := nil;
|
|
FVisibleButtons := FVisibleButtons - [AButton.NavButton];
|
|
end;
|
|
|
|
initialization
|
|
dxBarRegisterItem(TdxBarDBNavButton, TdxBarButtonControl, False);
|
|
|
|
end.
|