CodeSnip Old Code (SVN)

{
 * UActiveTextHTML.pas
 *
 * Static class that provides assistance when rendering active text as HTML.
 * The class renders the active text as HTML and provides CSS to style it.
 *
 * $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 UActiveTextHTML.pas
 *
 * The Initial Developer of the Original Code is Peter Johnson
 * (http://www.delphidabbler.com/).
 *
 * Portions created by the Initial Developer are Copyright (C) 2009 Peter
 * Johnson. All Rights Reserved.
 *
 * Contributors:
 *   NONE
 *
 * ***** END LICENSE BLOCK *****
}


unit UActiveTextHTML;


interface


uses
  // Delphi
  Graphics,
  // Project
  UActiveText, UBaseObjects, UCSSBuilder;


type

  {
  TActiveTextHTML:
    Static class that provides assistance when rendering active text as HTML.
    The class renders the active text as HTML and provides CSS to style it.
  }
  TActiveTextHTML = class(TNoConstructObject)
  public
    class function Render(const ActiveText: IActiveText): string;
     {Builds valid HTML containing information from snippet's Extra property.
     May contain links and some formatting.
        @return Required HTML.
      }
    class procedure Styles(const DefFont: TFont; const CSSBuilder: TCSSBuilder);
      {Sets the CSS styles required to render an HTML representation of REML.
        @param DefFont [in] Default font to use for styles.
        @param  CSSBuilder [in] Object that is used to create the CSS.
      }
  end;


implementation


uses
  // Delphi
  SysUtils,
  // Project
  UColours, UCSSUtils, UFontHelper, UHTMLDetailUtils, UHTMLUtils, UIStringList;


{ TActiveTextHTML }

class function TActiveTextHTML.Render(const ActiveText: IActiveText): string;
 {Builds valid HTML containing information from snippet's Extra property. May
  contain links and some formatting.
    @return Required HTML.
  }
const
  // maps state of an active text element to equivalent HTML tag type
  cTagTypeMap: array[TActiveTextElemState] of THTMLTagType = (
    ttClose,  // fsClose: closing tag e.g. </tagname>
    ttOpen    // fsOpen: opening tag e.g. <tagname [params]>
  );
resourcestring
  sCreditsURLHint = 'Visit %s';       // hint used in <a> tag title attribute
var
  Elem: IActiveTextElem;              // each active text element
  TextElem: IActiveTextTextElem;      // a text active text element
  ActionElem: IActiveTextActionElem;  // an action active text element
  EncloseInDiv: Boolean;

  // ---------------------------------------------------------------------------
  function ClassAttr(const ClassName: string): IHTMLAttributes;
    {Creates an HTML attributes object containing a class attribute.
      @param ClassName [in] Name of class.
      @return Required HTML attributes object.
    }
  begin
    Result := THTMLAttributes.Create;
    Result.Add('class', ClassName);
  end;
  // ---------------------------------------------------------------------------

begin
  Result := '';
  // Process each active text element
  for Elem in ActiveText do
  begin
    if Supports(Elem, IActiveTextTextElem, TextElem) then
      // A text element: write it literally as safe HTML text
      Result := Result + MakeSafeHTMLText(TextElem.Text)
    else if Supports(Elem, IActiveTextActionElem, ActionElem) then
    begin
      // An action element: if supported output it in HTML
      case ActionElem.Kind of
        ekLink:
        begin
          // REML <a> => HTML <a class="external-link">
          //   REML href => HTML href
          if ActionElem.State = fsOpen then
            // opening tag: element's Param property is HTML href attribute
            Result := Result + AOpenTag(
              ActionElem.Param,
              '',
              '|' + Format(sCreditsURLHint, [ActionElem.Param]),
              TIStringList.Create('external-link')
            )
          else
            // an </a> tag
            Result := Result + MakeTag('a', ttClose);
        end;
        ekStrong:
          // REML <strong> => HTML <strong>
          Result := Result + MakeTag('strong', cTagTypeMap[ActionElem.State]);
        ekEm:
          // REML <em> => HTML <em>
          Result := Result + MakeTag('em', cTagTypeMap[ActionElem.State]);
        ekVar:
          // REML <var> => HTML <var class="extra">
          Result := Result + MakeTag(
            'var', cTagTypeMap[ActionElem.State], ClassAttr('extra')
          );
        ekPara:
          // REML <p> => HTML <p>
          Result := Result + MakeTag('p', cTagTypeMap[ActionElem.State]);
        ekWarning:
          // REML <warning> => HTML <span class="extra-warning">
          Result := Result + MakeTag(
            'span', cTagTypeMap[ActionElem.State], ClassAttr('extra-warning')
          );
        ekMono:
          // REML <mono> => HTML <span class="extra-mono">
          Result := Result + MakeTag(
            'span', cTagTypeMap[ActionElem.State], ClassAttr('extra-mono')
          );
        ekHeading:
          // REML <heading> => HTML <h2 class="extra">
          Result := Result + MakeTag(
            'h2', cTagTypeMap[ActionElem.State], ClassAttr('extra')
          );
        else
          {Unsupported action element type: do nothing};
      end;
    end;
  end;
  // Extra property may have "p" or "heading" tags, but may not have. So we
  // check and add enclosing "div" tags if necessary with required properties.
  // paragraph tags if
  EncloseInDiv := not ActiveText.IsEmpty and
    not ((ActiveText[0].Kind in [ekPara, ekHeading]));
  if EncloseInDiv then
    Result := MakeTag('div', ttOpen, ClassAttr('extra-wrapper')) +
      Result +
      MakeTag('div', ttClose);
end;

class procedure TActiveTextHTML.Styles(const DefFont: TFont;
  const CSSBuilder: TCSSBuilder);
  {Sets the CSS styles required to render an HTML representation of REML.
    @param DefFont [in] Default font to use for styles.
    @param  CSSBuilder [in] Object that is used to create the CSS.
  }
var
  CSSFont: TFont; // font used for CSS styles
begin
  // Add CSS relating to Extra REML code
  // -- heading tag
  with CSSBuilder.AddSelector('h2.extra') do
  begin
    AddProperty(CSSFontSizeProp(DefFont.Size + 1));
  end;
  // -- warning tag
  with CSSBuilder.AddSelector('span.extra-warning') do
  begin
    AddProperty(CSSFontWeightProp(cfwBold));
    AddProperty(CSSColorProp(clWarningText));
  end;
  // -- mono tag
  with CSSBuilder.AddSelector('span.extra-mono') do
  begin
    CSSFont := TFont.Create;
    try
      TFontHelper.SetDefaultMonoFont(CSSFont, True);
      AddProperty(CSSFontProps(CSSFont));
    finally
      FreeAndNil(CSSFont);
    end;
  end;
  // -- var tag
  with CSSBuilder.AddSelector('var.extra') do
  begin
    AddProperty(CSSColorProp(clVarText));
    AddProperty(CSSFontStyleProp(cfsItalic));
  end;
end;

end.