CodeSnip Old Code (SVN)

{
 * FmCompErrorDlg.pas
 *
 * Dialog box that displays compiler error and warning logs.
 *
 * $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 FmCompErrorDlg.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 FmCompErrorDlg;


interface


uses
  // Delphi
  Forms, StdCtrls, Controls, ExtCtrls, Classes, Tabs, ActnList, ImgList,
  Generics.Collections,
  // Project
  Compilers.UGlobals, FmGenericViewDlg, FrBrowserBase, FrHTMLDlg, FrHTMLTpltDlg,
  UBaseObjects, USnippetIDs;


type

  ///  <summary>
  ///  Implements a dialog box that displays error and warning logs from last
  ///  test compilation.
  ///  </summary>
  ///  <remarks>
  ///  It is an error if there are no compiler warnings or errors.
  ///  </remarks>
  TCompErrorDlg = class(TGenericViewDlg, INoPublicConstruct)
    frmHTML: THTMLTpltDlgFrame;
    tsCompilers: TTabSet;
    ilCompilers: TImageList;
    alTabs: TActionList;
    actNextTab: TAction;
    actPrevTab: TAction;
    ///  <summary>Form construction event handler. Creates owned object.
    ///  </summary>
    procedure FormCreate(Sender: TObject);
    ///  <summary>Form destruction event handler. Free owned object.</summary>
    procedure FormDestroy(Sender: TObject);
    ///  <summary>Handles Ctrl+Tab and Shift+Ctrl+Tab action OnExecute events.
    ///  Cycles through tabs in forward or reverse direction depending on which
    ///  action triggered event.</summary>
    procedure TabShortcutExecute(Sender: TObject);
    ///  <summary>Handles Ctrl+Tab and Shift+Ctrl+Tab action OnUpdate events.
    ///  Enables / disables actions that cycle through displayed tags.</summary>
    procedure TabShortcutUpdate(Sender: TObject);
    /// <summary>OnChange event handler for tabset. Displays warnings or errors
    ///  for newly specified by NewTab parameter.</summary>
    ///  <remarks>Tab change is always permitted.</remarks>
    procedure tsCompilersChange(Sender: TObject; NewTab: Integer;
      var AllowChange: Boolean);
    ///  <summary>Handles tabset's OnGetImageIndex event. Sets ImageIndex to
    ///  index of compiler glyph in image list for given tab index.</summary>
    procedure tsCompilersGetImageIndex(Sender: TObject; TabIndex: Integer;
      var ImageIndex: Integer);
  strict private
    type
      ///  <summary>Class that analyses compiler logs and extract information
      ///  required to be displayed in dialog box.</summary>
      TCompilerLog = class(TObject)
      strict private
        ///  <summary>Reference to compiler whose log being used.</summary>
        fCompiler: ICompiler;
        ///  <summary>Records analysed log.</summary>
        fLog: TStrings;
        ///  <summary>Value of Staus property.</summary>
        fStatus: string;
        ///  <summary>Analyses compiler log file, extracting require
        ///  information.</summary>
        procedure AnalyseLog;
      public
        ///  <summary>Constructs object for given compiler.</summary>
        constructor Create(Compiler: ICompiler);
        ///  <summary>Tears down object.</summary>
        destructor Destroy; override;
        ///  <summary>Renders list of required log entries as HTML.</summary>
        function LogListHTML: string;
        ///  <summary>Text describing log status. Warning or error.</summary>
        property Status: string read fStatus;
      end;
  strict private
    ///  <summary>Snippet for which last compilation took place.</summary>
    fSnippet: TSnippetID;
    ///  <summary>List of compilers for which errors or warnings are to be
    ///  displayed.</summary>
    fRequiredCompilers: TList<ICompiler>;
    ///  <summary>Maps compiler ids to index of compiler images in image list.
    ///  </summary>
    fCompGlyphIndexes: array[TCompilerId] of Integer;
    ///  <summary>Gets vertical space required to display warnings or error
    ///  messages in pixels.</summary>
    ///  <remarks>Calculates maximum height of mesages for each required
    ///  compiler.</remarks>
    function GetHTMLHeight: Integer;
    ///  <summary>Gets total height of tabset control.</summary>
    ///  <remarks>Returns 0 if tabset not required.</remarks>
    function GetTabsetHeight: Integer;
    ///  <summary>Loads HTML representation of given compiler's error or warning
    ///  log into browser control.</summary>
    ///  <remarks>EBug raised if compiler result is not a warning or an error.
    ///  </remarks>
    procedure LoadHTML(const Compiler: ICompiler);
  strict protected
    ///  <summary>Arranges controls on form.</summary>
    ///  <remarks>Called from ancestor class.</remarks>
    procedure ArrangeForm; override;
    ///  <summary>Initialises HTML frame and Sets UI font for tab set tabs.
    ///  </summary>
    ///  <remarks>Called from ancestor class.</remarks>
    procedure ConfigForm; override;
    ///  <summary>Configures tab set and sets form's caption.</summary>
    ///  <remarks>Called from ancestor class.</remarks>
    procedure InitForm; override;
  public
    ///  <summary>Shows a dialog box that displays error and warning logs for
    ///  each compiler that reported errors or warnings when test compiling a
    ///  snippet. There is a tab for each compiler.</summary>
    ///  <param name="AOwner">TComponent [in] Component that owns this form.
    ///  </param>
    ///  <param name="ASnippet">TSnippetID [in] ID of snippet that was compiled.
    ///  </param>
    ///  <param name="ACompilers">ICompilers [in] List of all supported
    ///  compilers.</param>
    class procedure Execute(const AOwner: TComponent;
      const ASnippet: TSnippetID; const ACompilers: ICompilers);
  end;


implementation


uses
  // Delphi
  Graphics,
  // Project
  UConsts, UExceptions, UHTMLUtils, UHTMLTemplate;


{$R *.dfm}

{
  NOTE:

  The error log HTML template is stored in RT_HTML resources as
  "dlg-comperror-tplt.html". It has the following placeholders that are replaced
  by values in this code:

  <%Status%>        log status - Error(s) or Warning(s)
  <%SnippetName%>   name of snippet being compiled
  <%CompilerID%>    if of compiler that caused warning/error
  <%ErrorList%>     a CRLF delimited list of the errors/warnings from the log as
                    HTML list items in form <li>log-line</li>
}


resourcestring
  // Strings for display in dialog
  sLogStatusWarning   = 'Warning';
  sLogStatusWarnings  = 'Warnings';
  sLogStatusError     = 'Error';
  sLogStatusErrors    = 'Errors';


{ TCompErrorDlg }

procedure TCompErrorDlg.ArrangeForm;
begin
  pnlBody.Height := GetHTMLHeight + GetTabsetHeight;
  // set size of dialog
  inherited;
end;

procedure TCompErrorDlg.ConfigForm;
begin
  inherited;
  LoadHTML(fRequiredCompilers[0]);
  // must set tab set font because for some reason tab control sets its font to
  // Tahoma
  tsCompilers.Font := Self.Font;
end;

class procedure TCompErrorDlg.Execute(const AOwner: TComponent;
  const ASnippet: TSnippetID; const ACompilers: ICompilers);
var
  Compiler: ICompiler;  // each supported compiler
begin
  Assert(Assigned(ACompilers), ClassName + '.Execute: ACompilers is nil');
  with InternalCreate(AOwner) do
    try
      fSnippet := ASnippet;
      for Compiler in ACompilers do
        if Compiler.HasErrorsOrWarnings then
          fRequiredCompilers.Add(Compiler);
      ShowModal;
    finally
      Free;
    end;
end;

procedure TCompErrorDlg.FormCreate(Sender: TObject);
begin
  inherited;
  fRequiredCompilers := TList<ICompiler>.Create;
end;

procedure TCompErrorDlg.FormDestroy(Sender: TObject);
begin
  fRequiredCompilers.Free;
  inherited;
end;

function TCompErrorDlg.GetHTMLHeight: Integer;
var
  Compiler: ICompiler;  // reference to each required compiler
begin
  Result := 0;
  // load each compiler result into frame and measure height, recording largest
  for Compiler in fRequiredCompilers do
  begin
    LoadHTML(Compiler);
    if frmHTML.DocHeight > Result then
      Result := frmHTML.DocHeight;
  end;
end;

function TCompErrorDlg.GetTabsetHeight: Integer;
begin
  Result := tsCompilers.Height;
  if tsCompilers.AlignWithMargins then
    Inc(Result, tsCompilers.Margins.Top + tsCompilers.Margins.Bottom);
end;

procedure TCompErrorDlg.InitForm;
var
  Compiler: ICompiler;  // references each required compiler
  Glyph: TBitmap;       // each compiler glyph
begin
  inherited;
  tsCompilers.Tabs.Clear;
  for Compiler in fRequiredCompilers do
  begin
    Glyph := Compiler.GetGlyph;
    if Assigned(Glyph) then
      fCompGlyphIndexes[Compiler.GetID] :=
        ilCompilers.AddMasked(Glyph, Glyph.Canvas.Pixels[0, 0])
    else
      fCompGlyphIndexes[Compiler.GetID] := -1;
    tsCompilers.Tabs.Add(' ' + Compiler.GetName + ' ');
  end;
  tsCompilers.TabIndex := 0;
  LoadHTML(fRequiredCompilers[tsCompilers.TabIndex]);
end;

procedure TCompErrorDlg.LoadHTML(const Compiler: ICompiler);
var
  Log: TCompilerLog; // stores compiler log
begin
  inherited;
  Log := TCompilerLog.Create(Compiler);
  try
    frmHTML.Initialise(
      'dlg-comperror-tplt.html',
      procedure(Tplt: THTMLTemplate)
      begin
        Tplt.ResolvePlaceholderText('Status', Log.Status);
        Tplt.ResolvePlaceholderHTML('ErrorList', Log.LogListHTML);
        Tplt.ResolvePlaceholderText('SnippetName', fSnippet.Name);
        Tplt.ResolvePlaceholderText('CompilerID', Compiler.GetName);
      end
    );
  finally
    Log.Free;
  end;
end;

procedure TCompErrorDlg.TabShortcutExecute(Sender: TObject);
var
  TabIdx: Integer;  // index of next or previous tab
begin
  // Ctrl+Tab and Shift+Ctrl+Tab actions have tag property containing direction:
  // (1 => forward and -1 => backward)
  TabIdx := tsCompilers.TabIndex + (Sender as TAction).Tag;
  if TabIdx < 0 then
    TabIdx := Pred(tsCompilers.Tabs.Count)
  else if TabIdx = tsCompilers.Tabs.Count then
    TabIdx := 0;
  tsCompilers.TabIndex := TabIdx;
end;

procedure TCompErrorDlg.TabShortcutUpdate(Sender: TObject);
begin
  (Sender as TAction).Enabled := fRequiredCompilers.Count > 1;
end;

procedure TCompErrorDlg.tsCompilersChange(Sender: TObject; NewTab: Integer;
  var AllowChange: Boolean);
begin
  LoadHTML(fRequiredCompilers[NewTab]);
end;

procedure TCompErrorDlg.tsCompilersGetImageIndex(Sender: TObject;
  TabIndex: Integer; var ImageIndex: Integer);
begin
  ImageIndex := fCompGlyphIndexes[fRequiredCompilers[TabIndex].GetID];
end;

{ TCompErrorDlg.TCompilerLog }

procedure TCompErrorDlg.TCompilerLog.AnalyseLog;
const
  // singular & plural warning text
  cWarnText: array[Boolean] of string = (
    sLogStatusWarning, sLogStatusWarnings
  );
  // singular & plural error text
  cErrorText: array[Boolean] of string = (
    sLogStatusError, sLogStatusErrors
  );
  // bug error message
  cBadResult = '%s.AnalyseLog: compile result must be warning or error';
begin
  case fCompiler.GetLastCompileResult of
    crWarning:
    begin
      // Extract warnings from raw log and note this is warning
      fCompiler.Log(cfWarnings, fLog);
      fStatus := cWarnText[fLog.Count > 1];
    end;
    crError:
    begin
      // Extract errors from raw log and note this is error
      fCompiler.Log(cfErrors, fLog);
      fStatus := cErrorText[fLog.Count > 1];
    end;
    else
      // Not a warning or error: this is a bug
      raise EBug.CreateFmt(cBadResult, [ClassName]);
  end;
end;

constructor TCompErrorDlg.TCompilerLog.Create(Compiler: ICompiler);
begin
  inherited Create;
  fCompiler := Compiler;
  fLog := TStringList.Create;
  AnalyseLog;
end;

destructor TCompErrorDlg.TCompilerLog.Destroy;
begin
  fLog.Free;
  inherited;
end;

function TCompErrorDlg.TCompilerLog.LogListHTML: string;
var
  Line: string;   // each line of log
begin
  Result := '';
  for Line in fLog do
    Result := Result + MakeCompoundTag('li', MakeSafeHTMLText(Line)) + EOL;
end;

end.