CodeSnip Old Code (SVN)

{
 * FmCompilersDlg.UCompilerListMgr.pas
 *
 * Implements a class that manages display of compiler names and glyphs in an
 * owner draw list box. This is a helper class for TCompilersDlg.
 *
 * $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 FmCompilersDlg.UCompilerListMgr.pas
 *
 * The Initial Developer of the Original Code is Peter Johnson
 * (http://www.delphidabbler.com/).
 *
 * Portions created by the Initial Developer are Copyright (C) 2011 Peter
 * Johnson. All Rights Reserved.
 *
 * Contributor(s)
 *   NONE
 *
 * ***** END LICENSE BLOCK *****
}


unit FmCompilersDlg.UCompilerListMgr;


interface


uses
  // Delphi
  Classes, Controls, StdCtrls, Windows,
  // Project
  Compilers.UGlobals;


type
  ///  <summary>
  ///  Manages display of compiler names and glyphs in an owner draw list box.
  ///  </summary>
  ///  <remarks>
  ///  This is a helper class for TCompilersDlg.
  ///  </remarks>
  TCompilerListMgr = class(TObject)
  strict private
    ///  <summary>Reference to managed list box.</summary>
    ///  <remarks>Must be owenr draw.</remarks>
    fLB: TListBox;
    ///  <summary>List of compilers to be displayed in list box.</summary>
    fCompilers: ICompilers;
    ///  <summary>Reference to OnSelect event handler.</summary>
    fOnSelect: TNotifyEvent;
    ///  <summary>OnClick event handler for list box. Triggers OnSelect event.
    ///  </summary>
    procedure LBClickHandler(Sender: TObject);
    ///  <summary>OnDrawItem event handler for list box. Performs custom
    ///  drawing.</summary>
    procedure LBDrawItemHandler(Control: TWinControl; Index: Integer;
      Rect: TRect; State: TOwnerDrawState);
    ///  <summary>Triggers OnSelect event.</summary>
    procedure DoSelect;
    ///  <summary>Read accessor for Selected property. Gets compiler associated
    ///  with selected list item.</summary>
    function GetSelected: ICompiler;
  public
    ///  <summary>Object constructor. Sets up object for given list box control
    ///  and list of compilers.</summary>
    constructor Create(const LB: TListBox; const Compilers: ICompilers);
    ///  <summary>Initialises list box to display required compilers.</summary>
    ///  <remarks>This initialisation has to be performed when host for is
    ///  shown and not before.</remarks>
    procedure Initialise;
    ///  <summary>Refreshes display of entire list.</summary>
    procedure Refresh; overload;
    ///  <summary>Refreshes display of list item associated with given compiler.
    ///  </summary>
    procedure Refresh(Compiler: ICompiler); overload;
    ///  <summary>Event triggered when selected item in list changes.</summary>
    ///  <remarks>Read Selected property to get newly selected compiler.
    ///  </remarks>
    property OnSelect: TNotifyEvent read fOnSelect write fOnSelect;
    ///  <summary>Reference to compiler associated with currently selected list
    ///  item.</summary>
    property Selected: ICompiler read GetSelected;
  end;


implementation


uses
  // Delphi
  Graphics, GraphUtil,
  // Project
  UStructs, UThemesEx;


{ TCompilerListMgr }

constructor TCompilerListMgr.Create(const LB: TListBox;
  const Compilers: ICompilers);
begin
  inherited Create;
  fLB := LB;
  fLB.OnClick := LBClickHandler;
  fLB.OnDrawItem := LBDrawItemHandler;
  fCompilers := Compilers;
end;

procedure TCompilerListMgr.DoSelect;
begin
  if Assigned(fOnSelect) then
    fOnSelect(Self);
end;

function TCompilerListMgr.GetSelected: ICompiler;
begin
  Result := fCompilers[TCompilerID(fLB.ItemIndex)];
end;

procedure TCompilerListMgr.Initialise;
var
  CompID: TCompilerID;  // loops thru supported compilers
begin
  inherited;
  // Add empty list items: one per supported compiler
  // (note we don't need item text since we handle drawing of list items
  // ourselves and get display details from compiler objects
  for CompID := Low(TCompilerID) to High(TCompilerID) do
    fLB.Items.Add('');
  // Select first compiler in list and trigger selection event for it
  fLB.ItemIndex := 0;
  DoSelect;
end;

procedure TCompilerListMgr.LBClickHandler(Sender: TObject);
begin
  DoSelect;
end;

procedure TCompilerListMgr.LBDrawItemHandler(Control: TWinControl;
  Index: Integer; Rect: TRect; State: TOwnerDrawState);
var
  LB: TListBox;         // list box being drawn
  TxtExtent: TSize;     // extent of text to be displayed
  ItemRect: TRectEx;    // rectangle bounding the item being drawn
  ImgRect: TRectEx;     // bounding rectangle of any glyph
  TxtRect: TRectEx;     // bounding rectangle of text to be drawn
  Bmp: TBitmap;         // reference to bitmap to be displayed (or nil if none)
  DrawHeight: Integer;  // total height of drawing (text below bitmap)
  Compiler: ICompiler;  // reference to compiler associated with list item
begin
  // Copy item rectangle as extended rect
  ItemRect := Rect;

  // Get reference to list box control
  LB := Control as TListBox;

  // Get reference to compiler object associated with list item and its bitmap
  Compiler := fCompilers[TCompilerID(Index)];
  Bmp := Compiler.GetGlyph;

  // Set font style: bold if compiler available
  if Compiler.IsAvailable then
    LB.Canvas.Font.Style := [fsBold]
  else
    LB.Canvas.Font.Style := [];

  // Calculate display rectangles for text and any bitmap
  TxtExtent := LB.Canvas.TextExtent(Compiler.GetName);
  if Assigned(Bmp) then
  begin
    // Bitmap included: bitmap drawn above text and bounding box or both centred
    // horizontally and vertically
    DrawHeight := TxtExtent.cy + 2 + Bmp.Height;
    ImgRect := TRectEx.CreateBounds(
      (ItemRect.Left + ItemRect.Right - Bmp.Width) div 2,
      (ItemRect.Top + ItemRect.Bottom - DrawHeight) div 2,
      Bmp.Width,
      Bmp.Height
    );
    TxtRect := TRectEx.CreateBounds(
      (ItemRect.Left + ItemRect.Right - TxtExtent.cx) div 2,
      ImgRect.Bottom + 2,
      TxtExtent
    );
  end
  else
  begin
    // No bitmap: text centred vertically and horizontally
    TxtRect := TRectEx.CreateBounds(
      (ItemRect.Left + ItemRect.Right - TxtExtent.cx) div 2,
      (ItemRect.Top + ItemRect.Bottom - TxtExtent.cy) div 2,
      TxtExtent
    );
  end;

  // Erase background
  LB.Canvas.Pen.Color := LB.Color;
  LB.Canvas.Brush.Color := LB.Color;
  LB.Canvas.FillRect(ItemRect);

  if (odFocused in State) or (odSelected in State) then
  begin
    // Draw highlighting (smaller than item's rectangle)
    if odFocused in State then
    begin
      if ThemeServicesEx.ThemesEnabled then
        LB.Canvas.Brush.Color := GetHighLightColor(clHighlight)
      else
        LB.Canvas.Brush.Color := clHighlight;
      LB.Canvas.Font.Color := clHighlightText;
    end
    else
    begin
      LB.Canvas.Brush.Color := clBtnFace;
      LB.Canvas.Font.Color := LB.Font.Color;
    end;
    LB.Canvas.Pen.Color := GetShadowColor(LB.Canvas.Brush.Color);
    LB.Canvas.Rectangle(ItemRect.Inflate(-4, -4));
  end
  else
    // No highlighting: just ensure font colour correct
    LB.Canvas.Font.Color := LB.Font.Color;

  // Draw text and any bitamp
  LB.Canvas.TextOut(TxtRect.Left, TxtRect.Top, Compiler.GetName);
  if Assigned(Bmp) then
    LB.Canvas.BrushCopy(ImgRect, Bmp, Bmp.Canvas.ClipRect, clFuchsia);

  // Draw separator line if item not last one
  if Index < Pred(LB.Count) then
  begin
    LB.Canvas.Pen.Color := clBtnShadow;
    LB.Canvas.MoveTo(ItemRect.Left + 4, ItemRect.Bottom - 1);
    LB.Canvas.LineTo(ItemRect.Right - 4, ItemRect.Bottom - 1);
  end;

  // Remove any focus rectangle
  if odFocused in State then
    LB.Canvas.DrawFocusRect(ItemRect);
end;

procedure TCompilerListMgr.Refresh;
begin
  fLB.Invalidate;
end;

procedure TCompilerListMgr.Refresh(Compiler: ICompiler);
var
  InvalidRect: TRectEx;
begin
  InvalidRect := fLB.ItemRect(Ord(Compiler.GetID));
  InvalidateRect(fLB.Handle, @InvalidRect, False);
end;

end.