{
* This Source Code Form is subject to the terms of the Mozilla Public License,
* v. 2.0. If a copy of the MPL was not distributed with this file, You can
* obtain one at http://mozilla.org/MPL/2.0/
*
* Copyright (C) 2005-2012, Peter Johnson (www.delphidabbler.com).
*
* $Rev$
* $Date$
*
* Implements a title frame that displays, and manages user interaction with,
* the detail pane tabset.
}
unit FrDetail;
interface
uses
// Delphi
Forms, ComCtrls, ExtCtrls, Controls, StdCtrls, Classes, ActiveX, ActnList,
ImgList, Generics.Collections,
// Project
Compilers.UGlobals, FrTitled, FrBrowserBase, FrDetailView, IntfFrameMgrs,
IntfNotifier, UCommandBars, UView, Menus;
type
{
TDetailFrame:
Title frame that displays and manages user interaction with the detail
pane tabs. The frame implements display manager interfaces and notifies
application of user-initiated events via a notifier object.
}
TDetailFrame = class(TTitledFrame,
ITabbedDisplayMgr,
IPaneInfo,
IDetailPaneDisplayMgr,
IWBCustomiser,
ISetNotifier,
ICommandBarConfig,
ISelectionMgr,
IClipboardMgr
)
frmDetailView: TDetailViewFrame;
mnuTabs: TPopupMenu;
tcViews: TTabControl;
procedure tcViewsChange(Sender: TObject);
procedure tcViewsMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
strict private
var
/// <summary>Notification object used to notify other parts of program
/// about changes in this frame.</summary>
fNotifier: INotifier;
/// <summary>List of views associated with tabs.</summary>
/// <remarks>Index of a view in this list is same as index of its tab
/// in tab set.</remarks>
fViews: TList<IView>;
/// <summary>Command bar that wraps tab set's context menu.</summary>
fTabSetCmdBar: TPopupMenuWrapper;
/// <summary>Returns number of tabs currently displayed.</summary>
function TabCount: Integer;
/// <summary>Selects tab at given index and displays its associated view.
/// </summary>
procedure InternalSelectTab(TabIdx: Integer);
/// <summary>Displays given view in deatil view pane. If ForceReload is
/// True then view is totally reloaded, otherwise it is displayed normally.
/// </summary>
procedure InternalDisplay(View: IView; ForceReload: Boolean);
/// <summary>Deletes a tab at given index along with its associated view.
/// </summary>
procedure InternalDeleteTab(TabIdx: Integer);
/// <summary>Sends notification via notifier object that selected tab has
/// changed.</summary>
procedure NotifyTabChange;
public
/// <summary>Constructs frame and its owned objects.</summary>
constructor Create(AOwner: TComponent); override;
/// <summary>Destroys frame and its owned objects.</summary>
destructor Destroy; override;
/// <summary>Selects tab with given index and displays associated view.
/// </summary>
/// <remarks>Method of ITabbedDisplayMgr and IDetailPaneDisplayMgr.
/// </remarks>
procedure SelectTab(const TabIdx: Integer);
procedure ITabbedDisplayMgr.SelectTab = SelectTab;
procedure IDetailPaneDisplayMgr.SelectTab = SelectTab;
/// <summary>Gets index of currently selected tab.</summary>
/// <remarks>Method of ITabbedDisplayMgr.</remarks>
function SelectedTab: Integer;
/// <summary>Switches to next tab in sequence or goes to first tab if
/// current tab is last.</summary>
/// <remarks>Method of ITabbedDisplayMgr.</remarks>
procedure NextTab;
/// <summary>Switches to previous tab in sequence or goes to last tab if
/// current tab is first.</summary>
/// <remarks>Method of ITabbedDisplayMgr.</remarks>
procedure PreviousTab;
/// <summary>Checks if the frame, or one of its child controls, is
/// currently interactive with the user.</summary>
/// <remarks>Method of IPaneInfo.</remarks>
function IsInteractive: Boolean;
/// <summary>Returns view associated with currently selected tab.</summary>
/// <remarks>
/// <para>If tab set is empty, a null view is returned.</para>
/// <para>Method of IDetailPaneDisplayMgr.</para>
/// </remarks>
function SelectedView: IView;
/// <summary>Finds index of tab displaying given view or -1 if no such tab.
/// </summary>
/// <remarks>Method of IDetailPaneDisplayMgr.</remarks>
function FindTab(ViewKey: IViewKey): Integer;
/// <summary>Associates given view with tab at given index.</summary>
/// <remarks>
/// <para>If specified tab is currently selected the view is displayed.
/// </para>
/// <para>Method of IDetailPaneDisplayMgr.</para>
/// </remarks>
procedure Display(View: IView; const TabIdx: Integer);
/// <summary>Reloads the currently displayed view.</summary>
/// <remarks>
/// <para>If tab set is empty, null view is reloaded.</para>
/// <para>Method of IDetailPaneDisplayMgr.</para>
/// </remarks>
procedure Reload;
/// <summary>Closes all tabs and deletes all views.</summary>
/// <remarks>Method of IDetailPaneDisplayMgr.</remarks>
procedure Clear;
/// <summary>Creates a new tab displaying given view and returns its index.
/// </summary>
/// <remarks>Method of IDetailPaneDisplayMgr.</remarks>
function CreateTab(View: IView): Integer;
/// <summary>Checks if tab set is empty, i.e. there are no tabs displayed.
/// </summary>
/// <remarks>Method of IDetailPaneDisplayMgr.</remarks>
function IsEmptyTabSet: Boolean;
/// <summary>Closes tab at given index.</summary>
/// <remarks>
/// <para>If closed tab was selected, another tab is selected and its view
/// displayed, otherwise currently selected tab remains unchanged.</para>
/// <para>Method of IDetailPaneDisplayMgr.</para>
/// </remarks>
procedure CloseTab(const TabIdx: Integer);
/// <summary>Closes all tabs, or all except selected tabs, depending on
/// whether KeepSelected is False or True, respectively.</summary>
/// <remarks>Method of IDetailPaneDisplayMgr.</remarks>
procedure CloseMultipleTabs(const KeepSelected: Boolean);
/// <summary>Uses the given object to extend the browser control's
/// 'external object'.</summary>
/// <remarks>Method of IWBCustomiser.</remarks>
procedure SetExternalObj(Obj: IDispatch);
/// <summary>Uses the given object to handle drag-drop operations for the
/// browser control.</summary>
/// <remarks>Method of IWBCustomiser.</remarks>
procedure SetDragDropHandler(Obj: IDropTarget);
/// <summary>Sets the notifier object to be called in reponse to user
/// input.</summary>
/// <remarks>Method of ISetNotifier.</remarks>
procedure SetNotifier(const Notifier: INotifier);
/// <summary>Adds given action to command bar with given ID.</summary>
/// <remarks>Method of ICommandBarConfig.</remarks>
procedure AddAction(const Action: TCustomAction; const ID: TCommandBarID);
overload;
/// <summary>Adds given action to command bars with given IDs.</summary>
/// <remarks>Method of ICommandBarConfig.</remarks>
procedure AddAction(const Action: TCustomAction; const IDs: TCommandBarIDs);
overload;
/// <summary>Adds a spacer to command bar with given ID.</summary>
/// <remarks>Method of ICommandBarConfig.</remarks>
procedure AddSpacer(const ID: TCommandBarID); overload;
/// <summary>Adds a spacer to command bars with given IDs.</summary>
/// <remarks>Method of ICommandBarConfig.</remarks>
procedure AddSpacer(const IDs: TCommandBarIDs); overload;
/// <summary>Specifies image list to be used by all hostes command bars.
/// </summary>
/// <remarks>Method of ICommandBarConfig.</remarks>
procedure SetImages(const Images: TCustomImageList);
/// <summary>Checks whether any text can be selected in any selected view.
/// </summary>
/// <remarks>Method of ISelectionMgr.</remarks>
function CanSelectAll: Boolean;
/// <summary>Selects all text in any current view.</summary>
/// <remarks>Method of ISelectionMgr.</remarks>
procedure SelectAll;
/// <summary>Checks whether anything can currently be copied to the
/// clipboard.</summary>
/// <remarks>Method of IClipboardMgr.</remarks>
function CanCopy: Boolean;
/// <summary>Copies any selected text in current view to clipboard.
/// </summary>
/// <remarks>Method of IClipboardMgr.</remarks>
procedure CopyToClipboard;
end;
implementation
uses
// Delphi
SysUtils, Generics.Defaults,
// Project
UExceptions;
{$R *.dfm}
{ TDetailFrame }
procedure TDetailFrame.AddAction(const Action: TCustomAction;
const ID: TCommandBarID);
begin
if ID = cDetailTabSetPopupMenu then
fTabSetCmdBar.AddAction(Action)
else
(frmDetailView as ICommandBarConfig).AddAction(Action, ID);
end;
procedure TDetailFrame.AddAction(const Action: TCustomAction;
const IDs: TCommandBarIDs);
var
ID: TCommandBarID;
begin
for ID in IDs do
AddAction(Action, ID);
end;
procedure TDetailFrame.AddSpacer(const IDs: TCommandBarIDs);
var
ID: TCommandBarID;
begin
for ID in IDs do
AddSpacer(ID);
end;
procedure TDetailFrame.AddSpacer(const ID: TCommandBarID);
begin
if ID = cDetailTabSetPopupMenu then
fTabSetCmdBar.AddSpacer
else
(frmDetailView as ICommandBarConfig).AddSpacer(ID);
end;
function TDetailFrame.CanCopy: Boolean;
begin
Result := not IsEmptyTabSet and (frmDetailView as IClipboardMgr).CanCopy;
end;
function TDetailFrame.CanSelectAll: Boolean;
begin
Result := not IsEmptyTabSet and (frmDetailView as ISelectionMgr).CanSelectAll;
end;
procedure TDetailFrame.Clear;
begin
InternalDisplay(TViewFactory.CreateNulView, False);
end;
procedure TDetailFrame.CloseMultipleTabs(const KeepSelected: Boolean);
var
Idx: Integer;
SelectedIdx: Integer;
begin
if IsEmptyTabSet then
Exit;
SelectedIdx := SelectedTab;
for Idx := Pred(TabCount) downto 0 do
begin
if (Idx = SelectedIdx) and KeepSelected then
Continue;
InternalDeleteTab(Idx);
end;
if KeepSelected then
tcViews.TabIndex := 0 // only selected tab remains: new index
else
tcViews.TabIndex := -1;
end;
procedure TDetailFrame.CloseTab(const TabIdx: Integer);
var
SelectedIdx: Integer;
ClosingSelectedIdx: Boolean;
begin
if IsEmptyTabSet then
Exit;
ClosingSelectedIdx := SelectedTab = TabIdx;
SelectedIdx := SelectedTab;
InternalDeleteTab(TabIdx);
if ClosingSelectedIdx then
begin
if SelectedIdx = TabCount then
Dec(SelectedIdx);
tcViews.TabIndex := SelectedIdx;
end
else
begin
if TabIdx < SelectedIdx then
// keeps existing selected tab displayed
tcViews.TabIndex := Pred(SelectedIdx);
end;
end;
procedure TDetailFrame.CopyToClipboard;
begin
if IsEmptyTabSet then
Exit;
(frmDetailView as IClipboardMgr).CopyToClipboard;
end;
constructor TDetailFrame.Create(AOwner: TComponent);
begin
inherited;
fViews := TList<IView>.Create;
fTabSetCmdBar := TPopupMenuWrapper.Create(mnuTabs);
end;
function TDetailFrame.CreateTab(View: IView): Integer;
begin
Result := tcViews.Tabs.Add(View.Description);
fViews.Add(View);
InternalDisplay(View, False); // stores View in fViews again
end;
destructor TDetailFrame.Destroy;
begin
fTabSetCmdBar.Free;
fViews.Free;
inherited;
end;
procedure TDetailFrame.Display(View: IView; const TabIdx: Integer);
begin
Assert(Assigned(View), ClassName + '.Display: View is nil');
fViews[TabIdx] := TViewFactory.Clone(View);
tcViews.Tabs[TabIdx] := View.Description;
if TabIdx = SelectedTab then
InternalDisplay(fViews[TabIdx], False);
end;
function TDetailFrame.FindTab(ViewKey: IViewKey): Integer;
var
Idx: Integer;
begin
for Idx := 0 to Pred(fViews.Count) do
if ViewKey.IsEqual(fViews[Idx].GetKey) then
Exit(Idx);
Result := -1;
end;
procedure TDetailFrame.InternalDeleteTab(TabIdx: Integer);
begin
tcViews.Tabs.Delete(TabIdx);
fViews.Delete(TabIdx);
end;
procedure TDetailFrame.InternalDisplay(View: IView; ForceReload: Boolean);
begin
(frmDetailView as IViewItemDisplayMgr).Display(View, ForceReload);
end;
procedure TDetailFrame.InternalSelectTab(TabIdx: Integer);
begin
tcViews.TabIndex := TabIdx;
InternalDisplay(SelectedView, False); // SelectedView allows for TabIdx = -1
end;
function TDetailFrame.IsEmptyTabSet: Boolean;
begin
Result := TabCount = 0;
end;
function TDetailFrame.IsInteractive: Boolean;
var
Idx: Integer;
begin
if IsEmptyTabSet then
Exit(False);
if (frmDetailView as IPaneInfo).IsInteractive then
Exit(True);
for Idx := 0 to Pred(ComponentCount) do
if (Components[Idx] is TWinControl)
and (Components[Idx] as TWinControl).Focused then
Exit(True);
Result := False;
end;
procedure TDetailFrame.NextTab;
begin
if IsEmptyTabSet then
Exit;
if SelectedTab = Pred(TabCount) then
InternalSelectTab(0)
else
InternalSelectTab(Succ(SelectedTab));
end;
procedure TDetailFrame.NotifyTabChange;
begin
if Assigned(fNotifier) then
fNotifier.ChangeDetailPane(tcViews.TabIndex);
end;
procedure TDetailFrame.PreviousTab;
begin
if IsEmptyTabSet then
Exit;
if SelectedTab = 0 then
InternalSelectTab(Pred(TabCount))
else
InternalSelectTab(Pred(SelectedTab));
end;
procedure TDetailFrame.Reload;
begin
InternalDisplay(SelectedView, True); // SelectedView allows for TabIdx = -1
end;
procedure TDetailFrame.SelectAll;
begin
if IsEmptyTabSet then
Exit;
(frmDetailView as ISelectionMgr).SelectAll;
end;
function TDetailFrame.SelectedTab: Integer;
begin
if IsEmptyTabSet then
Exit(-1);
Result := tcViews.TabIndex;
end;
function TDetailFrame.SelectedView: IView;
begin
if IsEmptyTabSet then
Result := TViewFactory.CreateNulView
else
Result := fViews[SelectedTab];
end;
procedure TDetailFrame.SelectTab(const TabIdx: Integer);
begin
InternalSelectTab(TabIdx);
end;
procedure TDetailFrame.SetDragDropHandler(Obj: IDropTarget);
begin
(frmDetailView as IWBCustomiser).SetDragDropHandler(Obj);
end;
procedure TDetailFrame.SetExternalObj(Obj: IDispatch);
begin
(frmDetailView as IWBCustomiser).SetExternalObj(Obj);
end;
procedure TDetailFrame.SetImages(const Images: TCustomImageList);
begin
fTabSetCmdBar.SetImages(Images);
(frmDetailView as ICommandBarConfig).SetImages(Images);
end;
procedure TDetailFrame.SetNotifier(const Notifier: INotifier);
begin
fNotifier := Notifier;
end;
function TDetailFrame.TabCount: Integer;
begin
Result := tcViews.Tabs.Count;
Assert(Result = fViews.Count,
ClassName + '.TabCount: Tabs.Count differs from fViews.Count');
end;
procedure TDetailFrame.tcViewsChange(Sender: TObject);
begin
// User changed tab
// notify program via notifier: this will result in instruction back to select
// the tab - this allows for other controls to change the tab
Assert(tcViews.TabIndex >= 0, ClassName + '.tcViewsChange: tab index < 0');
NotifyTabChange;
end;
procedure TDetailFrame.tcViewsMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
var
TabIdx: Integer;
begin
if htOnItem in tcViews.GetHitTestInfoAt(X, Y) then
begin
// ensure tab set has focus when a tab is clicked
tcViews.SetFocus;
if Button = mbRight then
begin
// select tab when right clicked
TabIdx := tcViews.IndexOfTabAt(X, Y);
if (TabIdx >= 0) and (TabIdx < tcViews.Tabs.Count) then
begin
tcViews.TabIndex := TabIdx;
NotifyTabChange;
end;
end;
end;
end;
end.
