CodeSnip Old Code (SVN)

{
 * UHistoryMenus.pas
 *
 * Custom popup menu components that display menu items for recent view items in
 * the history. Separate menu classes deal with "forward" and "back" menus.
 *
 * $Rev$
 * $Date$
 *
 * ***** BEGIN LICENSE BLOCK *****
 *
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with the
 * License. You may obtain a copy of the License at http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
 * the specific language governing rights and limitations under the License.
 *
 * The Original Code is UHistoryMenus.pas
 *
 * The Initial Developer of the Original Code is Peter Johnson
 * (http://www.delphidabbler.com/).
 *
 * Portions created by the Initial Developer are Copyright (C) 2005-2011 Peter
 * Johnson. All Rights Reserved.
 *
 * Contributor(s)
 *   NONE
 *
 * ***** END LICENSE BLOCK *****
}


unit UHistoryMenus;


interface


uses
  // Delphi
  Classes, Menus,
  // Project
  UHistory, UView, UViewItemAction;


type
  ///  <summary>
  ///  Abstract base class for popup menu components that display menu items for
  ///  recent view items in the history.
  ///  </summary>
  THistoryMenu = class abstract(TPopupMenu)
  strict private
    var
      ///  <summary>Reference to menu's history list.</summary>
      fHistory: THistory;
      ///  <summary>Action triggered when menu items clicked.</summary>
      fAction: TViewItemAction;
    const
      ///  <summary>Max items displayed in a history menu.</summary>
      cMaxHistoryMenuItems = 10;
  strict protected
    ///  <summary>Builds menu with a menu item for each view item in history.
    ///  </summary>
    procedure PopulateMenu;
    ///  <summary>Handles OnClick events for all menu items in menu by
    ///  executing action for view item associated with menu item.</summary>
    procedure MenuItemClick(Sender: TObject);
    ///  <summary>Builds list of views to be displayed in menu.</summary>
    ///  <param name="List">TViewItemList [in] List that receives views.
    ///  </param>
    procedure GetViewItemList(const List: TViewList); virtual; abstract;
    ///  <summary>Populates menu with required items just before it is
    ///  displayed.</summary>
    procedure DoPopup(Sender: TObject); override;
    ///  <summary>Reference to history list associated with menu.</summary>
    property History: THistory read fHistory;
  public
    ///  <summary>Object constructor. Sets up menu for a history list.</summary>
    ///  <param name="AOwner">TComponent [in] Component that owns this one, or
    ///  nil if not owned.</param>
    ///  <param name="History">THistory [in] Reference to history list
    ///  containing view items displayed in this menu.</param>
    ///  <param name="Action">TViewItemAction [in] Action to be triggered when a
    ///  menu item is selected.</param>
    constructor Create(AOwner: TComponent; const History: THistory;
      const Action: TViewItemAction); reintroduce;
  end;

type
  ///  <summary>
  ///  Popup menu component that displays menu items for recent view items in
  ///  the "back" history - i.e. view items that preceed the currently selected
  ///  history item.
  ///  </summary>
  TBackHistoryMenu = class sealed(THistoryMenu)
  strict protected
    ///  <summary>Builds list of views in "back" history.</summary>
    ///  <param name="List">TViewItemList [in] List that receives views.</param>
    procedure GetViewItemList(const List: TViewList); override;
  end;

type
  ///  <summary>
  ///  Popup menu component that displays menu items for recent view items in
  ///  the "forward" history - i.e. view items that follow the currently
  ///  selected history item.
  ///  </summary>
  TForwardHistoryMenu = class sealed(THistoryMenu)
  strict protected
    ///  <summary>Builds list of views in "forward" history.</summary>
    ///  <param name="List">TViewItemList [in] List that receives views.</param>
    procedure GetViewItemList(const List: TViewList); override;
  end;


implementation


uses
  // Delphi
  SysUtils,
  // Project
  UExceptions;


type
  ///  <summary>
  ///  Extension of TMenuItem that adds a property that references a TViewItem
  ///  object.
  ///  </summary>
  THistoryMenuItem = class sealed(TMenuItem)
  strict private
    var
      ///  <summary>View item associated with menu item.</summary>
      fViewItem: IView;
    ///  <summary>Write accessor for ViewItem property.</summary>
    procedure SetViewItem(Value: IView);
  public
    ///  <summary>View item associated with this menu item.</summary>
    ///  <remarks>Setting this property also stores a description in menu item
    ///  Caption.</remarks>
    property ViewItem: IView read fViewItem write SetViewItem;
  end;


{ THistoryMenu }

constructor THistoryMenu.Create(AOwner: TComponent;
  const History: THistory; const Action: TViewItemAction);
begin
  Assert(Assigned(History), ClassName + '.Create: History is nil');
  Assert(Assigned(Action), ClassName + '.Create: Action is nil');
  inherited Create(AOwner);
  // Record history list and action
  fHistory := History;
  fAction := Action;
end;

procedure THistoryMenu.DoPopup(Sender: TObject);
begin
  PopulateMenu;
  inherited;  // triggers menu's OnPopup event
end;

procedure THistoryMenu.MenuItemClick(Sender: TObject);
begin
  fAction.ViewItem := (Sender as THistoryMenuItem).ViewItem;
  fAction.Execute;
end;

procedure THistoryMenu.PopulateMenu;
var
  ViewList: TViewList;      // list of views in required section of history
  MI: THistoryMenuItem;     // a menu item instance
  Idx: Integer;             // loops thru ViewList
begin
  // Remove any existing menu items (this frees them)
  Items.Clear;
  // Get a list of view items to be displayed in menu
  ViewList := TViewList.Create;
  try
    GetViewItemList(ViewList);
    // Loop thru views, up to maximum that can be displayed
    for Idx := 0 to Pred(ViewList.Count) do
    begin
      if Idx = cMaxHistoryMenuItems then
        Break;
      // Create menu item
      MI := THistoryMenuItem.Create(Self);         // use custom menu item class
      MI.ViewItem := ViewList[Idx];           // record view (also sets Caption)
      MI.OnClick := MenuItemClick;       // every item uses same OnClick handler
      MI.Default := (Idx = 0);                     // first menu item is default
      // Add item to menu
      Items.Add(MI);
    end;
  finally
    ViewList.Free;
  end;
end;

{ TBackHistoryMenu }

procedure TBackHistoryMenu.GetViewItemList(const List: TViewList);
begin
  History.BackList(List);
end;

{ TForwardHistoryMenu }

procedure TForwardHistoryMenu.GetViewItemList(const List: TViewList);
begin
  History.ForwardList(List);
end;

{ THistoryMenuItem }

procedure THistoryMenuItem.SetViewItem(Value: IView);
resourcestring
  // Menu caption templates
  sSnippetDesc = 'Snippet: %s';
  sCategoryDesc = 'Category: %s';
  sSnipKindDesc = 'Snippets type: %s';
  sAlphabetDesc = 'Alphabetic section: %s';
const
  cBadViewItem = '%s.SetViewItem: unknown or unsupported view item';
begin
  // Record view item
  fViewItem := Value;
  // Set menu item caption to describe view item
  if Supports(fViewItem, IStartPageView) then
    Caption := ViewItem.Description
  else if Supports(fViewItem, ISnippetView) then
    Caption := Format(sSnippetDesc, [ViewItem.Description])
  else if Supports(fViewItem, ICategoryView) then
    Caption := Format(sCategoryDesc, [ViewItem.Description])
  else if Supports(fViewItem, ISnippetKindView) then
    Caption := Format(sSnipKindDesc, [ViewItem.Description])
  else if Supports(fViewItem, IInitialLetterView) then
    Caption := Format(sAlphabetDesc, [ViewItem.Description])
  else
    raise EBug.CreateFmt(cBadViewItem, [ClassName]);
end;

end.