CodeSnip Old Code (SVN)

{
 * FmTestCompileDlg.pas
 *
 * Implements a dialog box which test compiles a snippet and displays the
 * results.
 *
 * $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 FmTestCompileDlg.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 FmTestCompileDlg;

interface

uses
  Classes, ActnList, StdCtrls, Forms, Controls, ExtCtrls, Messages,
  Generics.Collections,

  Compilers.UGlobals, DB.USnippet, FmGenericViewDlg, UBaseObjects, UCompileMgr,
  ULEDImageList;

type
  ///  <summary>
  ///  Implements a dialog box that test compiles a snippet and displays the
  ///  results.
  ///  </summary>
  TTestCompileDlg = class(TGenericViewDlg, INoPublicConstruct)
    sbCompilers: TScrollBox;
    lblSnippetName: TLabel;
    lblSnippetNameDesc: TLabel;
    alMain: TActionList;
    actScrollPageUp: TAction;
    actScrollPageDown: TAction;
    actScrollLineUp: TAction;
    actScrollLineDown: TAction;
    btnViewErrors: TButton;
    actViewErrors: TAction;
    ///  <summary>Instantiates owned object and notes dialog initialising.
    ///  </summary>
    procedure FormCreate(Sender: TObject);
    ///  <summary>Tidies up form: frees owned object.</summary>
    procedure FormDestroy(Sender: TObject);
    ///  <summary>Scrolls up one page in scroll box.</summary>
    procedure actScrollPageUpExecute(Sender: TObject);
    ///  <summary>Scrolls down one page in scroll box.</summary>
    procedure actScrollPageDownExecute(Sender: TObject);
    ///  <summary>Scrolls up one "line" in scroll box.</summary>
    procedure actScrollLineUpExecute(Sender: TObject);
    ///  <summary>Scrolls down one "line" in scroll box.</summary>
    procedure actScrollLineDownExecute(Sender: TObject);
    ///  <summary>Updates enabled state of View Errors action.</summary>
    procedure actViewErrorsUpdate(Sender: TObject);
    ///  <summary>Displays any compile errors in dialog box.</summary>
    procedure actViewErrorsExecute(Sender: TObject);
  strict private
    type
      ///  <summary>Component that displays information about a compiler and its
      ///  compile result.</summary>
      TCompilerCtrl = class(TGraphicControl)
      strict private
        var
          ///  <summary>Value of Compiler property.</summary>
          fCompiler: ICompiler;
          ///  <summary>Value of CompileResult property.</summary>
          fCompileResult: TCompileResult;
        class var
          ///  <summary>Reference to image list containing images of compile
          ///  result LED.</summary>
          fLEDs: TLEDImageList;
      strict private
        ///  <summary>Write accessor for Compiler property.</summary>
        ///  <remarks>Adjusts control height and invalidates it.</remarks>
        procedure SetCompiler(Compiler: ICompiler);
        ///  <summary>Write accessor for CompileResult property.</summary>
        ///  <remarks>Causes control to be repainted.</remarks>
        procedure SetCompileResult(CompileResult: TCompileResult);
        ///  <summary>Resizes control in response to changes in font.</summary>
        procedure CMFontChanged(var Msg: TMessage); message CM_FONTCHANGED;
        ///  <summary>Calculates and returns required height of control.
        ///  </summary>
        function GetHeight: Integer;
        ///  <summary>Updates height of control.</summary>
        procedure UpdateHeight;
      strict protected
        ///  <summary>Paints control, displaying compiler and compile result
        ///  information.</summary>
        procedure Paint; override;
      public
        ///  <summary>Creates LED image list shared between all instances.
        ///  </summary>
        class constructor Create;
        ///  <summary>Frees shared LED image list instance.</summary>
        class destructor Destroy;
        ///  <summary>Object constructor override. Sets default property values.
        ///  </summary>
        constructor Create(AOwner: TComponent); override;
        ///  <summary>Override of inherited method to ignore any given height
        ///  and replace it with calculated height.</summary>
        procedure SetBounds(ALeft, ATop, AWidth, AHeight: Integer); override;
        ///  <summary>Reference to compiler whose info is displayed.</summary>
        property Compiler: ICompiler read fCompiler write SetCompiler;
        ///  <summary>Compiler result to be displayed.</summary>
        property CompileResult: TCompileResult
          read fCompileResult write SetCompileResult;
      end;
    type
      ///  <summary>List of compiler controls.</summary>
      TCompilerCtrls = TList<TCompilerCtrl>;
  strict private
    var
      ///  <summary>Reference to snippet to be test compiled.</summary>
      fSnippet: TSnippet;
      ///  <summary>Reference to compiler manager object used to perform and
      ///  record results of test compilation.</summary>
      fCompileMgr: TCompileMgr;
      ///  <summary>List of compiler controls to be displayed.</summary>
      fCompilerCtrlList: TCompilerCtrls;
      ///  <summary>Flag true if form is initialising. Set to false after
      ///  compilation complete and results displayed.</summary>
      fInitialising: Boolean;
    ///  <summary>Creates all required compiler controls and stores in list.
    ///  </summary>
    procedure CreateCompilerCtrls;
    ///  <summary>Displays results of test compilation.</summary>
    procedure DisplayCompileResults(const Compilers: ICompilers);
  strict protected
    ///  <summary>Arranges controls on form.</summary>
    ///  <remarks>Called from ancestor class.</remarks>
    procedure ArrangeForm; override;
    ///  <summary>Creates and configures required controls.</summary>
    ///  <remarks>Called from ancestor class.</remarks>
    procedure ConfigForm; override;
    ///  <summary>Performs test compilation after form is displayed and displays
    ///  results.</summary>
    ///  <remarks>Called from ancestor class.</remarks>
    procedure AfterShowForm; override;
  public
    ///  <summary>Displays dialog box that performs test compilation and
    ///  displays results.</summary>
    ///  <param name="AOwner">TComponent [in] Reference to any owning control.
    ///  </param>
    ///  <param name="ACompileMgr">TCompileMgr [in] Object used to perform test
    ///  compilation and record results.</param>
    ///  <param name="ASnippet">TSnippet [in] Snippet to be test compiled.
    ///  </param>
    class procedure Execute(const AOwner: TComponent;
      const ACompileMgr: TCompileMgr; const ASnippet: TSnippet);
  end;


implementation


uses
  // Delphi
  Math, Windows, Graphics,
  // Project
  UColours, UCtrlArranger, UFontHelper;

{$R *.dfm}


{ TTestCompileDlg }

procedure TTestCompileDlg.actScrollLineDownExecute(Sender: TObject);
begin
  sbCompilers.Perform(WM_VSCROLL, SB_LINEDOWN, 0);
end;

procedure TTestCompileDlg.actScrollLineUpExecute(Sender: TObject);
begin
  sbCompilers.Perform(WM_VSCROLL, SB_LINEUP, 0);
end;

procedure TTestCompileDlg.actScrollPageDownExecute(Sender: TObject);
begin
  sbCompilers.Perform(WM_VSCROLL, SB_PAGEDOWN, 0);
end;

procedure TTestCompileDlg.actScrollPageUpExecute(Sender: TObject);
begin
  sbCompilers.Perform(WM_VSCROLL, SB_PAGEUP, 0);
end;

procedure TTestCompileDlg.actViewErrorsExecute(Sender: TObject);
begin
  fCompileMgr.ShowErrors;
end;

procedure TTestCompileDlg.actViewErrorsUpdate(Sender: TObject);
begin
  actViewErrors.Enabled := not fInitialising and fCompileMgr.HaveErrors;
end;

procedure TTestCompileDlg.AfterShowForm;
begin
  inherited;
  Enabled := False;
  try
    fCompileMgr.Compile(pnlBody, fSnippet, DisplayCompileResults);
  finally
    Enabled := True;
  end;
  fInitialising := False;
end;

procedure TTestCompileDlg.ArrangeForm;
const
  // Various margins, offsets and sizes
  MaxBodyPanelWidth = 760;
  ViewErrorsBtnRightMargin = 16;
  SnippetLblTop = 0;
  SnippetLblBottomMargin = 8;
  CompilerCtrlListTop = 0;
var
  CompCtrl: TCompilerCtrl;  // each compiler control
  NextTop: Integer;         // top of next compiler control in scroll box
begin
  TCtrlArranger.SetLabelHeight(lblSnippetNameDesc);

  // Set horizontal alignments
  TCtrlArranger.MoveToRightOf(lblSnippetNameDesc, lblSnippetName);
  btnViewErrors.Left := pnlBody.Left;

  // Set widths
  pnlBody.ClientWidth := Min(
    Max(
      pnlBody.ClientWidth,
      Max(
        // allow room for long snippet names
        TCtrlArranger.RightOf(lblSnippetName),
        // allow room for button at bottom
        btnViewErrors.Width + ViewErrorsBtnRightMargin
          + TCtrlArranger.RightOf(btnHelp)- btnClose.Left
      )
    ),
    MaxBodyPanelWidth // body panel to be no more this any case!
  );
  sbCompilers.Width := pnlBody.ClientWidth;

  // Set vertical alignments
  TCtrlArranger.AlignVCentres(
    SnippetLblTop, [lblSnippetName, lblSnippetNameDesc]
  );
  sbCompilers.Top := TCtrlArranger.BottomOf(
    lblSnippetName, SnippetLblBottomMargin
  );
  sbCompilers.Height := pnlBody.ClientHeight - sbCompilers.Top;
  btnViewErrors.Top := btnHelp.Top;

  // Arrange compiler controls vertically within scroll box
  NextTop := CompilerCtrlListTop;
  for CompCtrl in fCompilerCtrlList do
  begin
    CompCtrl.Top := NextTop;
    Inc(NextTop, CompCtrl.Height);
  end;
  // Set compiler controls' widths: must do this after above loop so that any
  // vertical scroll bar in scroll box has been created
  for CompCtrl in fCompilerCtrlList do
    CompCtrl.Width := sbCompilers.ClientWidth;
  inherited;
end;

procedure TTestCompileDlg.ConfigForm;
begin
  inherited;
  CreateCompilerCtrls;
  // Set required label fonts and captions
  TFontHelper.SetDefaultBaseFont(lblSnippetName.Font, False);
  if fSnippet.UserDefined then
    lblSnippetName.Font.Color := clUserSnippet;
  lblSnippetName.Caption := fSnippet.Name;
end;

procedure TTestCompileDlg.CreateCompilerCtrls;
var
  Compiler: ICompiler;  // each supported compiler
  Ctrl: TCompilerCtrl;  // compiler control
begin
  for Compiler in fCompileMgr.Compilers do
  begin
    Ctrl := TCompilerCtrl.Create(Self);
    Ctrl.Parent := sbCompilers;
    Ctrl.Compiler := Compiler;
    fCompilerCtrlList.Add(Ctrl);
  end;
end;

procedure TTestCompileDlg.DisplayCompileResults(const Compilers: ICompilers);
var
  Ctrl: TCompilerCtrl;  // each compiler control in list
begin
  for Ctrl in fCompilerCtrlList do
    Ctrl.CompileResult := Compilers[Ctrl.Compiler.GetID].GetLastCompileResult;
end;

class procedure TTestCompileDlg.Execute(const AOwner: TComponent;
  const ACompileMgr: TCompileMgr; const ASnippet: TSnippet);
begin
  Assert(Assigned(ACompileMgr), ClassName + '.Execute: ACompileMgr is nil');
  Assert(Assigned(ASnippet), ClassName + '.Execute: ASnippet is nil');
  with InternalCreate(AOwner) do
    try
      fCompileMgr := ACompileMgr;
      fSnippet := ASnippet;
      ShowModal;
    finally
      Free;
    end;
end;

procedure TTestCompileDlg.FormCreate(Sender: TObject);
begin
  fInitialising := True;
  inherited;
  fCompilerCtrlList := TCompilerCtrls.Create;
end;

procedure TTestCompileDlg.FormDestroy(Sender: TObject);
begin
  fCompilerCtrlList.Free;
  inherited;
end;

{ TTestCompileDlg.TCompilerCtrl }

procedure TTestCompileDlg.TCompilerCtrl.CMFontChanged(var Msg: TMessage);
begin
  inherited;
  UpdateHeight;
end;

constructor TTestCompileDlg.TCompilerCtrl.Create(AOwner: TComponent);
begin
  inherited;
  ParentColor := True;
  ParentFont := True;
  fCompileResult := crQuery;
  Width := 180;
end;

class constructor TTestCompileDlg.TCompilerCtrl.Create;
begin
  fLEDs := TLEDImageList.Create(nil);
end;

class destructor TTestCompileDlg.TCompilerCtrl.Destroy;
begin
  fLEDS.Free;
end;

function TTestCompileDlg.TCompilerCtrl.GetHeight: Integer;
const
  CompilerGlyphHeight = 24; // estimated height of compiler glyph
  Padding = 4;              // padding applied to calculated height
begin
  if not Assigned(fCompiler) then
    Exit(0);
  Result := Max(
    CompilerGlyphHeight, Max(Canvas.TextHeight(fCompiler.GetName), fLEDs.Height)
  ) + Padding;
end;

procedure TTestCompileDlg.TCompilerCtrl.Paint;
const
  GlyphLeftOffset = 4;          // left offset of any compiler glyph
  NameLeftOffset = 28;          // left offset of compiler name text
  LEDLeftMargin = 4;            // margin before LED image (after divider)
  LEDRightMargin = 6;           // margin after LED image
  DividerLeftMargin = 2;        // margin before divider bar (after name)
  DividerWidth = 2;             // width of divider bar
var
  MaxNameWidth: Integer;        // max width for displaying compiler name text
  NameRect: TRect;              // rectangle containing compiler name text
  LEDLeftOffset: Integer;       // left offset of LEDs in control
  DividerLeftOffset: Integer;   // left offset of divider bar in control
  DividerRect: TRect;           // rectangle used to display divider bar
  BoundsRect: TRect;            // control's bounding rectangle (control coords)
  Glyph: TBitmap;               // reference to any compiler glyph
  Name: string;                 // name of compiler
begin
  inherited;
  if not Assigned(fCompiler) then
    Exit;

  Glyph := fCompiler.GetGlyph;
  Name := fCompiler.GetName;

  // Calculate widths and offsets that depend on control width
  LEDLeftOffset := Width - LEDRightMargin - fLEDs.Width;
  DividerLeftOffset := LEDLeftOffset - LEDLeftMargin - DividerWidth;
  MaxNameWidth := DividerLeftOffset - DividerLeftMargin - NameLeftOffset;

  Canvas.Font := Font;
  Canvas.Brush.Color := Color;

  // Draw compiler glyph, if any
  if Assigned(Glyph) then
    Canvas.BrushCopy(
      Bounds(
        GlyphLeftOffset,
        (Height - Glyph.Height) div 2,
        Glyph.Width,
        Glyph.Height
      ),
      Glyph,
      Rect(0, 0, Glyph.Width, Glyph.Height),
      clFuchsia
    );

  // Draw compiler name
  if fCompiler.IsAvailable then
    Canvas.Font.Color := clWindowText
  else
    Canvas.Font.Color := clGrayText;
  NameRect := Bounds(
    NameLeftOffset,
    (Height - Canvas.TextHeight(Name)) div 2,
    MaxNameWidth,
    Canvas.TextHeight(Name)
  );
  Canvas.TextRect(NameRect, Name, [tfLeft, tfNoPrefix]);

  // Draw divider
  DividerRect := Bounds(DividerLeftOffset, 0, DividerWidth, Height - 3);
  Windows.DrawEdge(
    Canvas.Handle,
    DividerRect,
    EDGE_RAISED,
    BF_LEFT or BF_RIGHT
  );

  // Draw compiler result
  fLEDs.Draw(
    Canvas,
    Point(LEDLeftOffset, (Height - fLEDs.Height) div 2),
    fCompileResult
  );

  // Draw bottom ruling
  BoundsRect := Bounds(0, Height - 2, Width, 2);
  Windows.DrawEdge(
    Canvas.Handle,
    BoundsRect,
    EDGE_RAISED,
    BF_BOTTOM or BF_TOP
  );
end;

procedure TTestCompileDlg.TCompilerCtrl.SetBounds(ALeft, ATop, AWidth,
  AHeight: Integer);
begin
  AHeight := GetHeight;
  inherited;
end;

procedure TTestCompileDlg.TCompilerCtrl.SetCompiler(Compiler: ICompiler);
begin
  fCompiler := Compiler;
  UpdateHeight;
  Invalidate;
end;

procedure TTestCompileDlg.TCompilerCtrl.SetCompileResult(
  CompileResult: TCompileResult);
begin
  fCompileResult := CompileResult;
  Invalidate;
end;

procedure TTestCompileDlg.TCompilerCtrl.UpdateHeight;
begin
  SetBounds(Left, Top, Width, 0); // Height is set automatically
end;

end.