CodeSnip Old Code (SVN)

{
 * This Source Code Form is subject to the terms of the Mozilla Public License,
 * v. 2.0. If a copy of the MPL was not distributed with this file, You can
 * obtain one at http://mozilla.org/MPL/2.0/
 *
 * Copyright (C) 2006-2012, Peter Johnson (www.delphidabbler.com).
 *
 * $Rev$
 * $Date$
 *
 * Implements various classes used to create content of a rich text document.
}


unit URTFBuilder;


interface


uses
  // Delphi
  Generics.Collections, Graphics,
  // Project
  UEncodings, URTFStyles, URTFUtils;


type
  ///  <summary>Encapsulates an RTF colour table.</summary>
  TRTFColourTable = class(TObject)
  strict private
    var
      ///  <summary>List of colours in table.</summary>
      fColours: TList<TColor>;
  public
    ///  <summary>Constructs object.</summary>
    constructor Create;
    ///  <summary>Destroys object.</summary>
    destructor Destroy; override;
    ///  <summary>Adds given colour to colour table unless it is already
    ///  present.</summary>
    procedure Add(const Colour: TColor);
    ///  <summary>Ensures that any colour defined in the given style is present
    ///  in the colour table.</summary>
    ///  <remarks>Does nothing if the style doesn't define a colour.</remarks>
    procedure AddFromStyle(const Style: TRTFStyle);
    ///  <summary>Returns index of given colour in colour table.</summary>
    ///  <exception>EBug raised if colour is not in colour table.</exception>
    function ColourRef(const Colour: TColor): Integer;
    ///  <summary>Builds and returns RTF code representing colour
    ///  table.</summary>
    function AsString: ASCIIString;
  end;

type
  ///  <summary>Encapsulates an RTF font table.</summary>
  TRTFFontTable = class(TObject)
  strict private
    var
      ///  <summary>List of fonts in table.</summary>
      fFonts: TList<TRTFFont>;  // List of fonts in table
    ///  <summary>Returns index of given font name in table or -1 if font not
    ///  present.</summary>
    function FindFont(const FontName: string): Integer;
  public
    ///  <summary>Constructs object.</summary>
    constructor Create;
    ///  <summary>Destroys object.</summary>
    destructor Destroy; override;
    ///  <summary>Adds new font to table if not already present.</summary>
    ///  <remarks>Does nothing except return index if a font with same name is
    ///  already in table.</remarks>
    ///  <param name="FontName">string [in] Name of font.</param>
    ///  <param name="Generic">TRTFGenericFont [in] Generic font family of font.
    ///  </param>
    ///  <param name="Charset">TFontCharset [in] Character set used by new font.
    ///  </param>
    ///  <returns>Integer. Index of font in font table, either existing or new.
    ///  </returns>
    function Add(const FontName: string; const Generic: TRTFGenericFont;
      const Charset: TFontCharset): Integer; overload;
    ///  <summary>Adds new font to table if not already present.</summary>
    ///  <remarks>Does nothing except return index if a font with same name is
    ///  already in table.</remarks>
    ///  <param name="Font">TRTFFont [in] Font to be added.</param>
    ///  <returns>Integer. Index of font in font table, either existing or new.
    ///  </returns>
    function Add(const Font: TRTFFont): Integer; overload;
    ///  <summary>Ensures that any font defined in the given style is present in
    ///  the font table.</summary>
    ///  <remarks>Does nothing if the style doesn't define a font or if the font
    ///  is null.</remarks>
    procedure AddFromStyle(const Style: TRTFStyle);
    ///  <summary>Returns index of a named font in table.</summary>
    ///  <exception>EBug raise if font not in table.</exception>
    function FontRef(const FontName: string): Integer;
    ///  <summary>Builds and returns RTF code representing font table.</summary>
    function AsString: ASCIIString;
  end;

type
  ///  <summary>Encapsulate properties of an RTF document.</summary>
  TRTFDocProperties = class(TObject)
  strict private
    var
      ///  <summary>Value of Title property.</summary>
      fTitle: string;
      ///  <summary>Code page used by document.</summary>
      fCodePage: Integer;
    ///  <summary>Checks if document properties are empty, i.e. have not be
    ///  defined.</summary>
    function IsEmpty: Boolean;
  public
    ///  <summary>Constructs object for document using given code page.
    ///  </summary>
    constructor Create(const CodePage: Integer);
    ///  <summary>Builds and returns RTF code representing document properties.
    ///  </summary>
    function AsString: ASCIIString;
    ///  <summary>Document title.</summary>
    property Title: string read fTitle write fTitle;
  end;

type
  ///  <summary>Class used to construct and render a RTF document.</summary>
  TRTFBuilder = class(TObject)
  strict private
    var
      ///  <summary>Accumulates RTF code for doc body.</summary>
      fBody: ASCIIString;
      ///  <summary>Code page used for RTF document.</summary>
      fCodePage: Integer;
      ///  <summary>Flag True when emitting RTF controls and False when emitting
      ///  text.</summary>
      fInControls: Boolean;
      ///  <summary>Value of ColourTable property.</summary>
      fColourTable: TRTFColourTable;
      ///  <summary>Value of FontTable property.</summary>
      fFontTable: TRTFFontTable;
      ///  <summary>Value of DefaultFontIdx property.</summary>
      fDefaultFontIdx: Integer;
      ///  <summary>Value of DocProperties property.</summary>
      fDocProperties: TRTFDocProperties;
    ///  <summary>Appends given text string to document body.</summary>
    procedure AppendBody(const S: ASCIIString);
    ///  <summary>Generates RTF code for document header.</summary>
    function DocHeader: ASCIIString;
    ///  <summary>Adds given RTF control to document body.</summary>
    procedure AddControl(const Ctrl: ASCIIString);
    ///  <summary>Generates RTF code for whole document.</summary>
    function AsString: ASCIIString;
  public
    ///  <summary>Constructs object for RTF document using given code page.
    ///  </summary>
    constructor Create(const CodePage: Integer);
    ///  <summary>Destroys object.</summary>
    destructor Destroy; override;
    ///  <summary>Ends a paragraph in document body.</summary>
    procedure EndPara;
    ///  <summary>Begins a new group in document body.</summary>
    procedure BeginGroup;
    ///  <summary>Closes current group in document body.</summary>
    procedure EndGroup;
    ///  <summary>Adds given text to document body.</summary>
    procedure AddText(const Text: string);
    ///  <summary>Clears paragraph formatting.</summary>
    procedure ClearParaFormatting;
    ///  <summary>Resets character styles to defaults.</summary>
    procedure ResetCharStyle;
    ///  <summary>Sets colour to be used as foreground colour for subsequent
    ///  text.</summary>.
    ///  <exception>EBug raised if colour not in colour table.</exception>
    procedure SetColour(const Colour: TColor);
    ///  <summary>Sets name of font to be used for subsequent text.</summary>
    ///  <exception>EBug raised if font name is not in font table.</exception>
    procedure SetFont(const FontName: string);
    ///  <summary>Sets size of font, in points, to be used for subsequent text.
    ///  </summary>
    procedure SetFontSize(const Points: Double);
    ///  <summary>Sets style of font to be used for subsequent text.</summary>
    procedure SetFontStyle(const Style: TFontStyles);
    ///  <summary>Sets before and after spacing, in points, to be used for
    ///  subsequent paragraphs.</summary>
    procedure SetParaSpacing(const Spacing: TRTFParaSpacing);
    ///  <summary>Sets paragraph and character styling for subsequent text
    ///  according to given RTF style.</summary>
    procedure ApplyStyle(const Style: TRTFStyle);
    ///  <summary>Generates RTF code for whole document.</summary>
    function Render: TRTF;
    ///  <summary>Table of colours used in document.</summary>
    property ColourTable: TRTFColourTable
      read fColourTable write fColourTable;
    ///  <summary>Table of fonts used in document.</summary>
    property FontTable: TRTFFontTable
      read fFontTable write fFontTable;
    ///  <summary>Index of default font in font table.</summary>
    property DefaultFontIdx: Integer
      read fDefaultFontIdx write fDefaultFontIdx;
    ///  <summary>Document's properties.</summary>
    property DocProperties: TRTFDocProperties
      read fDocProperties write fDocProperties;
  end;


implementation


uses
  // Delphi
  Generics.Defaults, Windows, Character,
  // Project
  UConsts, UExceptions, ULocales, UStrUtils, UUtils;


{ TRTFBuilder }

procedure TRTFBuilder.AddControl(const Ctrl: ASCIIString);
begin
  Assert((Ctrl <> '') and not TCharacter.IsWhiteSpace(Char(Ctrl[Length(Ctrl)])),
    ClassName + '.AddControls: Ctrl ends in whitespace');
  AppendBody(Ctrl);
  fInControls := True;
end;

procedure TRTFBuilder.AddText(const Text: string);
begin
  if fInControls then
  begin
    // We were emitting controls: need a space to terminate controls
    AppendBody(' ');
    fInControls := False;
  end;
  // Add text, escaping disallowed characters
  AppendBody(RTFMakeSafeText(Text, fCodePage));
end;

procedure TRTFBuilder.AppendBody(const S: ASCIIString);
begin
  fBody := fBody + S;
end;

procedure TRTFBuilder.ApplyStyle(const Style: TRTFStyle);
begin
  if scParaSpacing in Style.Capabilities then
    SetParaSpacing(Style.ParaSpacing);
  if scFont in Style.Capabilities then
    SetFont(Style.Font.Name);
  if scFontSize in Style.Capabilities then
    SetFontSize(Style.FontSize);
  if scFontStyles in Style.Capabilities then
    SetFontStyle(Style.FontStyles);
  if scColour in Style.Capabilities then
    SetColour(Style.Colour);
end;

function TRTFBuilder.AsString: ASCIIString;
begin
  Result := '{' + DocHeader + fBody + '}';
end;

procedure TRTFBuilder.BeginGroup;
begin
  AppendBody('{');
  fInControls := False;
end;

procedure TRTFBuilder.ClearParaFormatting;
begin
  AddControl(RTFControl(rcPard));
end;

constructor TRTFBuilder.Create(const CodePage: Integer);
begin
  inherited Create;
  if CodePage = 0 then
    fCodePage := ULocales.DefaultAnsiCodePage
  else
    fCodePage := CodePage;
  fColourTable := TRTFColourTable.Create;
  fFontTable := TRTFFontTable.Create;
  fDocProperties := TRTFDocProperties.Create(fCodePage);
  fBody := '';
  fInControls := False;
end;

destructor TRTFBuilder.Destroy;
begin
  fDocProperties.Free;
  fFontTable.Free;
  fColourTable.Free;
  inherited;
end;

function TRTFBuilder.DocHeader: ASCIIString;
begin
  Result := RTFControl(rcRTF, cRTFVersion)
    + RTFControl(rcAnsi)
    + RTFControl(rcAnsiCodePage, fCodePage)
    + RTFControl(rcDefFontNum, DefaultFontIdx)
    + RTFControl(rcDefLanguage, DefaultLanguageID)
    + fFontTable.AsString
    + fColourTable.AsString
    + fDocProperties.AsString
    + EOL;
end;

procedure TRTFBuilder.EndGroup;
begin
  AppendBody('}');
  fInControls := False;
end;

procedure TRTFBuilder.EndPara;
begin
  AddControl(RTFControl(rcPar));
  AppendBody(EOL);
  fInControls := False;
end;

function TRTFBuilder.Render: TRTF;
begin
  Result := TRTF.Create(AsString);
end;

procedure TRTFBuilder.ResetCharStyle;
begin
  AddControl(RTFControl(rcPlain));
end;

procedure TRTFBuilder.SetColour(const Colour: TColor);
begin
  AddControl(RTFControl(rcForeColorNum, fColourTable.ColourRef(Colour)));
end;

procedure TRTFBuilder.SetFont(const FontName: string);
var
  FontIdx: Integer; // index of font in font table
begin
  // We don't emit control if this is default font
  FontIdx := fFontTable.FontRef(FontName);
  if FontIdx <> DefaultFontIdx then
    AddControl(RTFControl(rcFontNum, FontIdx));
end;

procedure TRTFBuilder.SetFontSize(const Points: Double);
begin
  AddControl(RTFControl(rcFontSize, FloatToInt(2 * Points)));
end;

procedure TRTFBuilder.SetFontStyle(const Style: TFontStyles);
begin
  if fsBold in Style then
    AddControl(RTFControl(rcBold));
  if fsItalic in Style then
    AddControl(RTFControl(rcItalic));
  if fsUnderline in Style then
    AddControl(RTFControl(rcUnderline));
end;

procedure TRTFBuilder.SetParaSpacing(const Spacing: TRTFParaSpacing);
begin
  // Note: 20 Twips in a point
  AddControl(RTFControl(rcSpaceBefore, FloatToInt(20 * Spacing.Before)));
  AddControl(RTFControl(rcSpaceAfter, FloatToInt(20 * Spacing.After)));
end;

{ TRTFFontTable }

function TRTFFontTable.Add(const FontName: string;
  const Generic: TRTFGenericFont; const Charset: TFontCharset): Integer;
begin
  Result := FindFont(FontName);
  if Result = -1 then
    Result := fFonts.Add(TRTFFont.Create(FontName, Generic, Charset));
end;

function TRTFFontTable.Add(const Font: TRTFFont): Integer;
begin
  Result := FindFont(Font.Name);
  if Result = -1 then
    Result := fFonts.Add(Font);
end;

procedure TRTFFontTable.AddFromStyle(const Style: TRTFStyle);
begin
  if (scFont in Style.Capabilities) and not Style.Font.IsNull then
    Add(Style.Font);
end;

function TRTFFontTable.AsString: ASCIIString;
const
  // Map of generic font families to RTF controls
  cGenericFonts: array[TRTFGenericFont] of TRTFControl = (
    rcFontFamilyNil, rcFontFamilyRoman, rcFontFamilySwiss, rcFontFamilyModern,
    rcFontFamilyScript, rcFontFamilyDecor, rcFontFamilyTech
  );
var
  Idx: Integer;     // loops thru fonts in table
  Font: TRTFFont;   // reference to a font in table
begin
  Result := '{' + RTFControl(rcFontTable);
  for Idx := 0 to Pred(fFonts.Count) do
  begin
    Font := fFonts[Idx];
    Result := Result + '{'
      + RTFControl(rcFontNum, Idx)
      + RTFControl(rcFontPitch, 1)
      + RTFControl(cGenericFonts[Font.Generic])
      + RTFControl(rcFontCharset, Font.Charset)
      + ' '
      + StringToASCIIString(Font.Name)
      + '}';
  end;
  Result := Result + '}';
end;

constructor TRTFFontTable.Create;
begin
  inherited;
  fFonts := TList<TRTFFont>.Create(
    TDelegatedComparer<TRTFFont>.Create(
      function(const Left, Right: TRTFFont): Integer
      begin
        Result := Left.CompareTo(Right);
      end
    )
  );
end;

destructor TRTFFontTable.Destroy;
begin
  fFonts.Free;
  inherited;
end;

function TRTFFontTable.FindFont(const FontName: string): Integer;
begin
  Result := fFonts.IndexOf(TRTFFont.Create(FontName));
end;

function TRTFFontTable.FontRef(const FontName: string): Integer;
begin
  Result := FindFont(FontName);
  if Result = -1 then
    raise EBug.Create(ClassName + '.FontRef: Font not found');
end;

{ TRTFColourTable }

procedure TRTFColourTable.Add(const Colour: TColor);
begin
  if not fColours.Contains(Colour) then
    fColours.Add(Colour);
end;

procedure TRTFColourTable.AddFromStyle(const Style: TRTFStyle);
begin
  if scColour in Style.Capabilities then
    Add(Style.Colour);
end;

function TRTFColourTable.AsString: ASCIIString;
var
  Colour: TColor;     // each colour in table
  RGB: Cardinal;      // RGB representation of a colour
begin
  // Begin table
  Result := '{'
    + RTFControl(rcColorTable)
    + ' ';
  // Add entry for each colour
  for Colour in fColours do
  begin
    if Colour <> clNone then
    begin
      RGB := ColorToRGB(Colour);
      Result := Result
        + RTFControl(rcRed, GetRValue(RGB))
        + RTFControl(rcGreen, GetGValue(RGB))
        + RTFControl(rcBlue, GetBValue(RGB))
        + ';'
    end
    else
      // Colour not specified: provide empty entry
      Result := Result + ';'
  end;
  Result := Result + '}';
end;

function TRTFColourTable.ColourRef(const Colour: TColor): Integer;
begin
  Result := fColours.IndexOf(Colour);
  if Result = -1 then
    raise EBug.Create(ClassName + '.ColourRef: Unknown colour');
end;

constructor TRTFColourTable.Create;
begin
  inherited;
  fColours := TList<TColor>.Create; // use default integer comparer
  Add(clNone);
end;

destructor TRTFColourTable.Destroy;
begin
  fColours.Free;
  inherited;
end;

{ TRTFDocProperties }

function TRTFDocProperties.AsString: ASCIIString;
begin
  if IsEmpty then
  begin
    // No code if no properties
    Result := '';
    Exit;
  end;
  // Start with \info control word in group
  Result := '{' + RTFControl(rcInfo);
  if fTitle <> '' then
    Result := Result + RTFUnicodeSafeDestination(rcTitle, fTitle, fCodePage);
  // Close \info group
  Result := Result + '}';
end;

constructor TRTFDocProperties.Create(const CodePage: Integer);
begin
  inherited Create;
  fCodePage := CodePage;
end;

function TRTFDocProperties.IsEmpty: Boolean;
begin
  Result := fTitle = '';
end;

end.