CodeSnip Old Code (SVN)

{
 * USyntaxHiliters.pas
 *
 * Provides highlighter classes used to format and highlight source code in
 * various file formats. Contains an interface supported by all highlighters, a
 * factory object and implementation of various different highlighter objects.
 *
 * v0.1 of 17 Mar 2005  - Original version. This is a reworking of earlier
 *                        syntax highlighter implementation in the former
 *                        UBaseHiliter and UDetailHTMLHiliter units.
 * v0.2 of 21 Apr 2005  - Added new IntfHilite unit that contains type
 *                        declarations formerly in other units.
 * v0.3 of 04 Jun 2005  - Changed invalid default font in
 *                        TXHTMLHiliter.GetMainCSSStyle from mono to monospace.
 * v1.0 of 25 May 2006  - Improved and corrected comments.
 *                      - Localised literal HTML document title string.
 * v1.1 of 07 Nov 2006  - Changed to use UCSSUtils methods to generate CSS
 *                        attributes.
 *                      - Completely rewrote RTF hiliter using new TRTFBuilder
 *                        class. Also changed class to generate smaller RTF
 *                        code.
 *                      - Changed reference to fAttrs private field of parent
 *                        class to reference to protected Attrs property in
 *                        TXHTMLHiliter.
 * v1.2 of 25 Nov 2006  - Changed to use new THiliterCSS class to handle CSS
 *                        generation and class names. As a result removed all
 *                        explicit CSS generation and interogation code from
 *                        this unit.
 *                      - Pushed BeforeElem() and AfterElem() methods from
 *                        TDetailHTMLHiliter and TCHTMLHiliter up into super
 *                        class TBaseHTMLHiliter. This leaves TDetailHTMLHiliter
 *                        as an empty class that is retained for informational
 *                        purposes.
 *                      - TBaseHTMLHiliter now takes note of provided
 *                        highlighter class when determining which highlighter
 *                        elements are formatted. This means that
 *                        TDetailHTMLHighlighter also now requires a suitable
 *                        highlighter object. (Previously it ignored any
 *                        highlighter and CSS classes were hard wired).
 * v1.3 of 03 Dec 2006  - TDetailHTMLHighlighter changed to surround generated
 *                        HTML in <pre>..</pre> tags. This means that
 *                        TDetailHTMLHighlighter is no longer an empty class.
 * v1.4 of 02 Jul 2007  - Added support for document titles where document type
 *                        supports this.
 *                      - Changed XHTML code generation to use THTMLBuilder.
 * v1.5 of 04 Nov 2007  - Removed the IAssignable cast from the parameter to
 *                        IAssignable.Assign method calls.
 * v1.6 of 05 Oct 2008  - Changed TSyntaxHiliterFactory to derive from
 *                        TNoConstructObject and hence prevented it from being
 *                        constructed.
 *                      - Made some private and protected sections of some
 *                        classes strict.
 *
 *
 * ***** 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 USyntaxHiliters.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-2008 Peter
 * Johnson. All Rights Reserved.
 *
 * ***** END LICENSE BLOCK *****
}


unit USyntaxHiliters;


interface


uses
  // Project
  IntfHiliter, UBaseObjects;


type

  {
  TSyntaxHiliterFactory:
    Factory class used to create syntax highlighter objects.
  }
  TSyntaxHiliterFactory = class(TNoConstructObject)
  public
    class function CreateHiliter(
      const Kind: TSyntaxHiliterKind): ISyntaxHiliter;
      {Creates syntax highlighter of required kind.
        @param Kind [in] Kind of highlighter required.
        @return Highlighter object.
      }
  end;


implementation


{
  NOTES:

  The class heirachy for syntax highlighter classes in this unit is:

  TSyntaxHiliter - abstract base class
  |
  +-- * TNulHiliter - do nothing class that passes source thru unchanged
  |                   ignores highlight attributes
  |
  +-- TParsedHiliter - abstract base class for classes that parse source code
      |
      +-- TBaseHTMLHiliter - base class for highlighters that generate HTML
      |   |
      |   +-- * TDetailHTMLHiliter - creates HTML fragment for Details pane
      |   |                          uses highlight attributes
      |   |
      |   +-- * TXHTMLHiliter - creates complete XHTML document
      |                         uses highlight attributes
      |
      +-- * TRTFHiliter - creates complete RTF document
                          uses highlight attributes

* indicates a class constructed by factory class

}


uses
  // Delphi
  SysUtils, Classes, Graphics,
  // Project
  IntfCommon, UCSSBuilder, UHiliteAttrs, UHiliterCSS, UHilitePasParser,
  UHTMLBuilder, URTFBuilder, UStrStreamWriter;


type

  {
  TSyntaxHiliterClass:
    Class type for syntax highlighters. Used by factory class to create syntax
    highlighter objects of different types.
  }
  TSyntaxHiliterClass = class of TSyntaxHiliter;

  {
  TSyntaxHiliter:
    Abstract base class for all syntax highlighter classes. Provides virtual
    abstract methods and a virtual constructor that descendants override. This
    class is provided to give common base class that allows factory class to
    use TSyntaxHiliterClass for object creation.
  }
  TSyntaxHiliter = class(TInterfacedObject)
  protected
    { ISyntaxHiliter methods }
    procedure Hilite(const Src, Dest: TStream; const Attrs: IHiliteAttrs = nil;
      const Title: string = ''); overload; virtual; abstract;
      {Highlights source code on an input stream and writes to output stream.
        @param Src [in] Stream containing source code to be highlighted.
        @param Dest [in] Stream that receives formatted / highlighted document.
        @param Attrs [in] Attributes to be used by highlighter. Nil value causes
          a nul highlighter to be used.
        @param Title [in] Optional title to be used as meta data in output
          document. Will be ignored if document type does not support title.
      }
    function Hilite(const RawCode: string; const Attrs: IHiliteAttrs = nil;
      const Title: string = ''): string; overload; virtual; abstract;
      {Creates string containing highlighted source code.
        @param RawCode [in] Contains source code to be highlighted.
        @param Attrs [in] Attributes to be used by highlighter. Nil value causes
          a nul highlighter to be used.
        @param Title [in] Optional title to be used as meta data in output
          document. Will be ignored if document type does not support title.
        @return Formatted / highlighted source code.
      }
    constructor Create; virtual;
      {Class constructor. Instantiates object. This do-nothing virtual
      constructor is required to enable polymorphism to work for descendant
      classes.
      }
  end;

  {
  TNulHiliter:
    A do nothing highlighter class that passes source code through unchanged.
  }
  TNulHiliter = class(TSyntaxHiliter,
    ISyntaxHiliter
  )
  protected
    { ISyntaxHiliter methods }
    procedure Hilite(const Src, Dest: TStream; const Attrs: IHiliteAttrs = nil;
      const Title: string = ''); overload; override;
      {Copies source code on an input stream to output stream unchanged.
        @param Src [in] Stream containing source code.
        @param Dest [in] Stream that receives unchanged copy of source code from
          Src.
        @param Attrs [in] Attributes to be used by highlighter. Ignored.
        @param Title [in] Title of output document. Ignored.
      }
    function Hilite(const RawCode: string; const Attrs: IHiliteAttrs = nil;
      const Title: string = ''): string; overload; override;
      {Returns provided source code unchanged.
        @param RawCode [in] Contains source code.
        @param Attrs [in] Attributes to be used by highlighter. Ignored.
        @param Title [in] Title of output document. Ignored.
        @return Unchanged source code.
      }
  end;

  {
  TParsedHiliter:
    Abstract base class for all highlighter classes that parse source code using
    Pascal parser object. Handles parser events and calls virtual methods to
    write the various document parts. Also provides a helper object to simplify
    output of formatted code.
  }
  TParsedHiliter = class(TSyntaxHiliter)
  strict private
    fWriter: TStrStreamWriter;
      {Helper object used to emit formatted source code}
    fAttrs: IHiliteAttrs;
      {Reference to highlighter attributes}
    fTitle: string;
      {Document title}
    procedure ElementHandler(Parser: THilitePasParser; Elem: THiliteElement;
      const ElemText: string);
      {Handles parser's OnElement event. Calls virtual do nothing and abstract
      methods that descendants override to write a document element in required
      format.
        @param Parser [in] Reference to parser that triggered event (unused).
        @param Elem [in] Type of element to output.
        @param ElemText [in] Text to be output for element.
      }
    procedure LineBeginHandler(Parser: THilitePasParser);
      {Handles parser's OnLineBegin event. Calls virtual do nothing method that
      descendants override to output data needed to start a new line.
        @param Parser [in] Reference to parser that triggered event (unused).
      }
    procedure LineEndHandler(Parser: THilitePasParser);
      {Handles parser's OnLineEnd event. Calls virtual do nothing method that
      descendants override to output data needed to end a new line.
        @param Parser [in] Reference to parser that triggered event (unused).
      }
  protected
    { ISyntaxHiliter methods }
    procedure Hilite(const Src, Dest: TStream; const Attrs: IHiliteAttrs = nil;
      const Title: string = ''); overload; override;
      {Highlights source code on an input stream and writes to output stream.
        @param Src [in] Stream containing source code to be highlighted.
        @param Dest [in] Stream that receives formatted / highlighted document.
        @param Attrs [in] Attributes to be used by highlighter. Nil value causes
          a nul highlighter to be used.
        @param Title [in] Optional title to be used as meta data in output
          document. Will be ignored if document type does not support title.
      }
    function Hilite(const RawCode: string; const Attrs: IHiliteAttrs = nil;
      const Title: string = ''): string; overload; override;
      {Creates string containing highlighted source code.
        @param RawCode [in] Contains source code to be highlighted.
        @param Attrs [in] Attributes to be used by highlighter. Nil value causes
          a nul highlighter to be used.
        @param Title [in] Optional title to be used as meta data in output
          document. Will be ignored if document type does not support title.
        @return Formatted / highlighted source code.
      }
  strict protected
    procedure BeginDoc; virtual;
      {Called just before document is parsed. Used to initialise document.
      }
    procedure EndDoc; virtual;
      {Called after parsing complete. Used to finalise document.
      }
    procedure BeginLine; virtual;
      {Called when a new line in output is started. Used to initialise a line in
      output.
      }
    procedure EndLine; virtual;
      {Called when a line is ending. Used to terminate a line in output.
      }
    procedure WriteElem(const ElemText: string); virtual; abstract;
      {Called for each different highlight element in document and is overridden
      to output element's text.
        @param ElemText [in] Text of the element.
      }
    procedure BeforeElem(Elem: THiliteElement); virtual;
      {Called before a highlight element is output. Used to write code to
      display element in required format.
        @param Elem [in] Kind of highlight element.
      }
    procedure AfterElem(Elem: THiliteElement); virtual;
      {Called after a highlight element is output. Used to write code to
      finalise element formatting.
        @param Elem [in] Kind of highlight element.
      }
    property Writer: TStrStreamWriter read fWriter;
      {Helper object used to write formatted code to output}
    property Attrs: IHiliteAttrs read fAttrs;
      {Object storing attributes of highlighter. Defines appearance of document
      and each highlight element}
    property Title: string read fTitle;
      {Title of document. May be ignored if document type doesn't support title
      meta data}
  public
    constructor Create; override;
      {Class constructor. Sets up object.
      }
    destructor Destroy; override;
      {Class destructor. Tears down object.
      }
  end;

  {
  TRTFHiliter:
    Highlighter object used to write highlighted rich text.
  }
  TRTFHiliter = class(TParsedHiliter,
    ISyntaxHiliter
  )
  strict private
    fRTFBuilder: TRTFBuilder;
      {Object used to construct rich text document}
  strict protected
    procedure BeginDoc; override;
      {Called just before document is parsed. Used to emit RTF header.
      }
    procedure EndDoc; override;
      {Called after parsing complete. Writes closing brace that terminates RTF
      document.
      }
    procedure BeginLine; override;
      {Called when a new line in output is started. Used to initialise a line in
      output.
      }
    procedure EndLine; override;
      {Called when a line is ending. Writes end of line RTF control.
      }
    procedure WriteElem(const ElemText: string); override;
      {Outputs element's text.
        @param ElemText [in] Text of the element.
      }
    procedure BeforeElem(Elem: THiliteElement); override;
      {Called before a highlight element is output. Used to emit RTF controls
      that define style of element.
        @param Elem [in] Kind of highlight element.
      }
    procedure AfterElem(Elem: THiliteElement); override;
      {Called after a highlight element is output. Used to write code to
      finalise element formatting.
        @param Elem [in] Kind of highlight element.
      }
  public
    constructor Create; override;
      {Class constructor. Sets up object.
      }
    destructor Destroy; override;
      {Class destructor. Tears down object.
      }
  end;

  {
  TBaseHTMLHiliter:
    Base class for all highlighters that emit HTML. Provides some common
    functionality. Emits HTML for highlighted source code only, not a complete
    HTML document. No CSS definitions are written since these are expected to
    have been provided elsewhere and match standard highlighter class names.
    (THiliterCSS is used to provide CSS class names and definitions).
  }
  TBaseHTMLHiliter = class(TParsedHiliter)
  strict private
    fIsFirstLine: Boolean;
      {Records whether we are about to write first line}
    fHTMLBuilder: THTMLBuilder;
      {Object used to construct XHTML document}
  strict protected
    procedure BeginDoc; override;
      {Called just before document is parsed. Used to initialise document.
      }
    procedure BeginLine; override;
      {Called when a new line in output is started. Writes new line where
      required.
      }
    procedure WriteElem(const ElemText: string); override;
      {Outputs element's text.
        @param ElemText [in] Text of the element.
      }
    procedure BeforeElem(Elem: THiliteElement); override;
      {Called before a highlight element is output. Used to write span tag for
      any CSS class that is required.
        @param Elem [in] Kind of highlight element.
      }
    procedure AfterElem(Elem: THiliteElement); override;
      {Called after a highlight element is output. Writes closing span tag if
      required.
        @param Elem [in] Kind of highlight element.
      }
    property IsFirstLine: Boolean read fIsFirstLine;
      {Flag true when line to be written is first line and false after that}
    property HTMLBuilder: THTMLBuilder read fHTMLBuilder;
      {Object used to construct XHTML document}
  public
    constructor Create; override;
      {Class constructor. Sets up object.
      }
    destructor Destroy; override;
      {Class destructor. Tears down object.
      }
  end;

  {
  TDetailHTMLHiliter:
    Highlighter that is used to display source code in program's Details pane.
    The class produces HTML suitable for use in HTML template document,
    therefore it does not emit a complete document, just HTML between
    <pre>..</pre> tags.
  }
  TDetailHTMLHiliter = class(TBaseHTMLHiliter,
    ISyntaxHiliter
  )
  strict protected
    procedure BeginDoc; override;
      {Called just before document is parsed. Used to write opening pre tag.
      }
    procedure EndDoc; override;
      {Called after parsing complete. Writes closing pre tag.
      }
  end;

  {
  TXHTMLHiliter:
    Highlighter that emits a complete XHTML document containing the source code.
    It creates an emebedded style sheet containing information from given
    highlight attribute objects and then writes code that uses these classes for
    formatting.
  }
  TXHTMLHiliter = class(TBaseHTMLHiliter,
    ISyntaxHiliter
  )
  strict private
    function GenerateCSSRules: string;
      {Generates CSS rule for use in head section of HTML document.
        @return List of CSS class rules.
      }
  strict protected
    procedure BeginDoc; override;
      {Called just before document is parsed. Used to write XHTML code for
      document head section and first part of body.
      }
    procedure EndDoc; override;
      {Called after parsing complete. Writes XHTML that closes document.
      }
  end;


{ TSyntaxHiliterFactory }

class function TSyntaxHiliterFactory.CreateHiliter(
  const Kind: TSyntaxHiliterKind): ISyntaxHiliter;
  {Creates syntax highlighter of required kind.
    @param Kind [in] Kind of highlighter required.
    @return Highlighter object.
  }
const
  // Map of highlighter kinds to highlighter classes
  cHiliterMap: array[TSyntaxHiliterKind] of TSyntaxHiliterClass = (
    TNulHiliter,
    TDetailHTMLHiliter,
    TXHTMLHiliter,
    TRTFHiliter
  );
var
  Obj: TSyntaxHiliter;  // created object
begin
  Obj := cHiliterMap[Kind].Create;  // create object
  Result := Obj as ISyntaxHiliter;  // return ISyntaxHiliter interface to object
end;


{ TSyntaxHiliter }

constructor TSyntaxHiliter.Create;
  {Class constructor. Instantiates object. This do-nothing virtual constructor
  is required to enable polymorphism to work for descendant classes.
  }
begin
  inherited;
  // Do nothing ** Do not remove - required for polymorphism to work **
end;


{ TNulHiliter }

procedure TNulHiliter.Hilite(const Src, Dest: TStream;
  const Attrs: IHiliteAttrs; const Title: string);
  {Copies source code on an input stream to output stream unchanged.
    @param Src [in] Stream containing source code.
    @param Dest [in] Stream that receives unchanged copy of source code from
      Src.
    @param Attrs [in] Attributes to be used by highlighter. Ignored.
    @param Title [in] Title of output document. Ignored.
  }
begin
  // Copy source from current location in input stream to end of stream into
  // destination stream
  Dest.CopyFrom(Src, Src.Size - Src.Position);
end;

function TNulHiliter.Hilite(const RawCode: string; const Attrs: IHiliteAttrs;
  const Title: string): string;
  {Returns provided source code unchanged.
    @param RawCode [in] Contains source code.
    @param Attrs [in] Attributes to be used by highlighter. Ignored.
    @param Title [in] Title of output document. Ignored.
    @return Unchanged source code.
  }
begin
  Result := RawCode;
end;


{ TParsedHiliter }

procedure TParsedHiliter.AfterElem(Elem: THiliteElement);
  {Called after a highlight element is output. Used to write code to finalise
  element formatting.
    @param Elem [in] Kind of highlight element.
  }
begin
  // Do nothing: descendants override
end;

procedure TParsedHiliter.BeforeElem(Elem: THiliteElement);
  {Called before a highlight element is output. Used to write code to display
  element in required format.
    @param Elem [in] Kind of highlight element.
  }
begin
  // Do nothing: descendants override
end;

procedure TParsedHiliter.BeginDoc;
  {Called just before document is parsed. Used to initialise document.
  }
begin
  // Do nothing: descendants override
end;

procedure TParsedHiliter.BeginLine;
  {Called when a new line in output is started. Used to initialise a line in
  output.
  }
begin
  // Do nothing: descendants override
end;

constructor TParsedHiliter.Create;
  {Class constructor. Sets up object.
  }
begin
  inherited;
  // Create nul highlighter object used by default
  fAttrs := THiliteAttrsFactory.CreateNulAttrs;
end;

destructor TParsedHiliter.Destroy;
  {Class destructor. Tears down object.
  }
begin
  fAttrs := nil;
  inherited;
end;

procedure TParsedHiliter.ElementHandler(Parser: THilitePasParser;
  Elem: THiliteElement; const ElemText: string);
  {Handles parser's OnElement event. Calls virtual do nothing and abstract
  methods that descendants override to write a document element in required
  format.
    @param Parser [in] Reference to parser that triggered event (unused).
    @param Elem [in] Type of element to output.
    @param ElemText [in] Text to be output for element.
  }
begin
  BeforeElem(Elem);
  WriteElem(ElemText);
  AfterElem(Elem);
end;

procedure TParsedHiliter.EndDoc;
  {Called after parsing complete. Used to finalise document.
  }
begin
  // Do nothing: descendants override
end;

procedure TParsedHiliter.EndLine;
  {Called when a line is ending. Used to terminate a line in output.
  }
begin
  // Do nothing: descendants override
end;

procedure TParsedHiliter.Hilite(const Src, Dest: TStream;
  const Attrs: IHiliteAttrs; const Title: string);
  {Highlights source code on an input stream and writes to output stream.
    @param Src [in] Stream containing source code to be highlighted.
    @param Dest [in] Stream that receives formatted / highlighted document.
    @param Attrs [in] Attributes to be used by highlighter. Nil value causes a
      nul highlighter to be used.
    @param Title [in] Optional title to be used as meta data in output document.
      Will be ignored if document type does not support title.
  }
var
  Parser: THilitePasParser;   // object used to parse source
begin
  (fAttrs as IAssignable).Assign(Attrs);  // Attrs may be nil
  fTitle := Title;
  fWriter := TStrStreamWriter.Create(Dest);
  try
    // Create parser
    Parser := THilitePasParser.Create;
    try
      Parser.OnElement := ElementHandler;
      Parser.OnLineBegin := LineBeginHandler;
      Parser.OnLineEnd := LineEndHandler;
      // Parse the document:
      BeginDoc;   // overridden in descendants to initialise document
      Parser.Parse(Src);
      EndDoc;     // overridden in descendants to finalise document
    finally
      Parser.Free;
    end;
  finally
    fWriter.Free;
  end;
end;

function TParsedHiliter.Hilite(const RawCode: string; const Attrs: IHiliteAttrs;
  const Title: string): string;
  {Creates string containing highlighted source code.
    @param RawCode [in] Contains source code to be highlighted.
    @param Attrs [in] Attributes to be used by highlighter. Nil value causes a
      nul highlighter to be used.
    @param Title [in] Optional title to be used as meta data in output document.
      Will be ignored if document type does not support title.
    @return Formatted / highlighted source code.
  }
var
  SrcStm: TStringStream;  // stream used to store raw source code
  DestStm: TStringStream; // stream used to receive output
begin
  DestStm := nil;
  // Create string stream containing raw source code
  SrcStm := TStringStream.Create(RawCode);
  try
    // Create string stream to received formatted / highlighted output
    DestStm := TStringStream.Create('');
    // Use stream version of method to perform highlighting
    Hilite(SrcStm, DestStm, Attrs, Title);
    // Return string stored in destination stream
    Result := DestStm.DataString;
  finally
    DestStm.Free;
    SrcStm.Free;
  end;
end;

procedure TParsedHiliter.LineBeginHandler(Parser: THilitePasParser);
  {Handles parser's OnLineBegin event. Calls virtual do nothing method that
  descendants override to output data needed to start a new line.
    @param Parser [in] Reference to parser that triggered event (unused).
  }
begin
  BeginLine;
end;

procedure TParsedHiliter.LineEndHandler(Parser: THilitePasParser);
  {Handles parser's OnLineEnd event. Calls virtual do nothing method that
  descendants override to output data needed to end a new line.
    @param Parser [in] Reference to parser that triggered event (unused).
  }
begin
  EndLine;
end;


{ TRTFHiliter }

procedure TRTFHiliter.AfterElem(Elem: THiliteElement);
  {Called after a highlight element is output. Used to write code to finalise
  element formatting.
    @param Elem [in] Kind of highlight element.
  }
begin
  if not Attrs[Elem].IsNul then
    fRTFBuilder.EndGroup;
end;

procedure TRTFHiliter.BeforeElem(Elem: THiliteElement);
  {Called before a highlight element is output. Used to emit RTF controls that
  define style of element.
    @param Elem [in] Kind of highlight element.
  }
begin
  if not Attrs[Elem].IsNul then
  begin
    fRTFBuilder.BeginGroup;
    if Attrs[Elem].ForeColor <> clNone then
      fRTFBuilder.SetColour(Attrs[Elem].ForeColor);
    if Attrs[Elem].FontStyle <> [] then
      fRTFBuilder.SetFontStyle(Attrs[Elem].FontStyle);
  end;
end;

procedure TRTFHiliter.BeginDoc;
  {Called just before document is parsed. Used to emit RTF header.
  }
var
  Elem: THiliteElement; // loops thru all highlight elements
begin
  // Set up font table
  fRTFBuilder.FontTable.Add(Attrs.FontName, rgfModern, 0);
  // Set up colour table
  for Elem := Low(THiliteElement) to High(THiliteElement) do
    fRTFBuilder.ColourTable.Add(Attrs[Elem].ForeColor);
  // Add any document title
  fRTFBuilder.DocProperties.Title := Title;
  // Clear any paragraph formatting
  fRTFBuilder.ClearParaFormatting;
end;

procedure TRTFHiliter.BeginLine;
  {Called when a new line in output is started. Used to initialise a line in
  output.
  }
begin
  fRTFBuilder.ResetCharStyle;
  fRTFBuilder.SetFont(Attrs.FontName);
  fRTFBuilder.SetFontSize(Attrs.FontSize);
end;

constructor TRTFHiliter.Create;
  {Class constructor. Sets up object.
  }
begin
  inherited;
  fRTFBuilder := TRTFBuilder.Create;
end;

destructor TRTFHiliter.Destroy;
  {Class destructor. Tears down object.
  }
begin
  FreeAndNil(fRTFBuilder);
  inherited;
end;

procedure TRTFHiliter.EndDoc;
  {Called after parsing complete. Writes closing brace that terminates RTF
  document.
  }
begin
  Writer.WriteStrLn(fRTFBuilder.AsString);
end;

procedure TRTFHiliter.EndLine;
  {Called when a line is ending. Writes end of line RTF control.
  }
begin
  fRTFBuilder.EndPara;
end;

procedure TRTFHiliter.WriteElem(const ElemText: string);
  {Outputs element's text.
    @param ElemText [in] Text of the element.
  }
begin
  fRTFBuilder.AddText(ElemText);
end;


{ TBaseHTMLHiliter }

procedure TBaseHTMLHiliter.AfterElem(Elem: THiliteElement);
  {Called after a highlight element is output. Writes closing span tag if
  required.
    @param Elem [in] Kind of highlight element.
  }
begin
  if not Attrs[Elem].IsNul then
    HTMLBuilder.CloseSpan;
end;

procedure TBaseHTMLHiliter.BeforeElem(Elem: THiliteElement);
  {Called before a highlight element is output. Used to write span tag for any
  CSS class that is required.
    @param Elem [in] Kind of highlight element.
  }
begin
  if not Attrs.Elements[Elem].IsNul then
    HTMLBuilder.OpenSpan(THiliterCSS.GetElemCSSClassName(Elem));
end;

procedure TBaseHTMLHiliter.BeginDoc;
  {Called just before document is parsed. Used to initialise document.
  }
begin
  // Note that we are about to write first line
  fIsFirstLine := True;
end;

procedure TBaseHTMLHiliter.BeginLine;
  {Called when a new line in output is started. Writes new line where required.
  }
begin
  // Note we don't emit CRLF before first line since it must be on same line as
  // <pre> tag that will have been written.
  if fIsFirstLine then
    fIsFirstLine := False
  else
    HTMLBuilder.NewLine;
end;

constructor TBaseHTMLHiliter.Create;
  {Class constructor. Sets up object.
  }
begin
  inherited;
  fHTMLBuilder := THTMLBuilder.Create;
end;

destructor TBaseHTMLHiliter.Destroy;
  {Class destructor. Tears down object.
  }
begin
  FreeAndNil(fHTMLBuilder);
  inherited;
end;

procedure TBaseHTMLHiliter.WriteElem(const ElemText: string);
  {Outputs element's text.
    @param ElemText [in] Text of the element.
  }
begin
  HTMLBuilder.AddText(ElemText);
end;


{ TDetailHTMLHiliter }

procedure TDetailHTMLHiliter.BeginDoc;
  {Called just before document is parsed. Used to write opening pre tag.
  }
begin
  inherited;
  HTMLBuilder.OpenPre(THiliterCSS.GetMainCSSClassName);
end;

procedure TDetailHTMLHiliter.EndDoc;
  {Called after parsing complete. Writes closing pre tag.
  }
begin
  inherited;
  HTMLBuilder.ClosePre;
  Writer.WriteStr(HTMLBuilder.HTMLFragment);
end;


{ TXHTMLHiliter }

procedure TXHTMLHiliter.BeginDoc;
  {Called just before document is parsed. Used to write XHTML code for document
  head section and first part of body.
  }
resourcestring
  // Default document title
  sDefaultTitle = 'DelphiDabbler CodeSnip Database';
begin
  inherited;
  if Title <> '' then
    HTMLBuilder.Title := Title
  else
    HTMLBuilder.Title := sDefaultTitle;
  HTMLBuilder.CSS := GenerateCSSRules;
  HTMLBuilder.OpenPre(THiliterCSS.GetMainCSSClassName);
end;

procedure TXHTMLHiliter.EndDoc;
  {Called after parsing complete. Writes XHTML that closes document.
  }
begin
  inherited;
  HTMLBuilder.ClosePre;
  Writer.WriteStr(HTMLBuilder.HTMLDocument);
end;

function TXHTMLHiliter.GenerateCSSRules: string;
  {Generates CSS rule for use in head section of HTML document.
    @return List of CSS class rules.
  }
var
  CSSBuilder: TCSSBuilder;  // builds CSS code
  HiliterCSS: THiliterCSS;  // generates CSS names and properties for hiliter
begin
  HiliterCSS := THiliterCSS.Create(Attrs);
  CSSBuilder := nil;
  try
    CSSBuilder := TCSSBuilder.Create;
    HiliterCSS.BuildCSS(CSSBuilder);
    Result := CSSBuilder.AsString;
  finally
    FreeAndNil(CSSBuilder);
    FreeAndNil(HiliterCSS);
  end;
end;

end.