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) 2005-2013, Peter Johnson (www.delphidabbler.com).
 *
 * $Rev$
 * $Date$
 *
 * Implements classes that define syntax highlighter attributes along with an
 * object that provides a list of named highlighter attributes.
}


unit Hiliter.UAttrs;


interface


uses
  // Delphi
  Generics.Collections,
  // Project
  Hiliter.UGlobals, IntfCommon, UBaseObjects;


type
  ///  <summary>Factory class used to create various highlight attributes
  ///  objects.</summary>
  THiliteAttrsFactory = class(TNoConstructObject)
  public
    ///  <summary>Creates and returns a null highlighter attributes object
    ///  instance.</summary>
    ///  <remarks>Null attributes use no styling other than default font name
    ///  and size.</remarks>
    class function CreateNulAttrs: IHiliteAttrs;
    ///  <summary>Creates and returns a highlighter attributes object instance
    ///  that uses the program's default syntax highlighting style.</summary>
    class function CreateDefaultAttrs: IHiliteAttrs;
    ///  <summary>Creates and returns a highlighter attributes object instance
    ///  that uses a syntax highlighting style defined by the user.</summary>
    class function CreateUserAttrs: IHiliteAttrs;
    ///  <summary>Creates and returns a copy of the given highlighter attributes
    ///  instance in a form suitable for printing. If UseColour is False, all
    ///  colour information is removed from the highlighter. If Attrs is nil a
    ///  null highlighter is returned.</summary>
    class function CreatePrintAttrs(const Attrs: IHiliteAttrs;
      const UseColour: Boolean): IHiliteAttrs;
    ///  <summary>Creates and returns a highlighter attributes object instance
    ///  with the given predefined style.</summary>
    class function CreatePredefinedAttrs(const Style: TPredefinedHiliteStyle):
      IHiliteAttrs;
    ///  <summary>Creates a returns a highlighter attributes object instance
    ///  that is a clone of the given highlighter attributes.</summary>
    class function CloneAttrs(Attrs: IHiliteAttrs): IHiliteAttrs;
    ///  <summary>Creates and returns named highlighter attributes object
    ///  instance.</summary>
    class function CreateNamedAttrs: INamedHiliteAttrs;
  end;


implementation


uses
  // Delphi
  SysUtils, Graphics,
  // Project
  UComparers, UExceptions, UFontHelper, UPreferences;


type
  ///  <summary>Class that records display attributes for use when syntax
  ///  highlighting source code.</summary>
  ///  <remarks>The class records the font face and size used for the whole
  ///  highighted along with font style and colour information of each
  ///  recognised source code element.</remarks>
  THiliteAttrs = class(TInterfacedObject,
    IHiliteAttrs, IAssignable
  )
  strict private
    var
      ///  <summary>List of highlight attributes for each source code element.
      ///  </summary>
      fElemAttrs: TList<IHiliteElemAttrs>;
      ///  <summary>Size of font in points.</summary>
      fFontSize: Integer;
      ///  <summary>Name of font.</summary>
      fFontName: string;
    const
      ///  <summary>Default font name.</summary>
      cDefFontName = 'Courier New';
      ///  <summary>Default font size.</summary>
      cDefFontSize = 9;
  public
    ///  <summary>Creates a new instance of the class with default values.
    ///  </summary>
    constructor Create;
    ///  <summary>Destroys this instance.</summary>
    destructor Destroy; override;
    ///  <summary>Gets name of highlighter font.</summary>
    ///  <remarks>Method of IHiliteAttrs.</remarks>
    function GetFontName: string;
    ///  <summary>Sets name of highlighter font.</summary>
    ///  <remarks>Method of IHiliteAttrs.</remarks>
    procedure SetFontName(const AFontName: string);
    ///  <summary>Gets size of highlighter font.</summary>
    ///  <remarks>Method of IHiliteAttrs.</remarks>
    function GetFontSize: Integer;
    ///  <summary>Sets size of highlighter font.</summary>
    ///  <remarks>Method of IHiliteAttrs.</remarks>
    procedure SetFontSize(const AFontSize: Integer);
    ///  <summary>Resets highlighter font name and size to default values.
    ///  </summary>
    ///  <remarks>Method of IHiliteAttrs.</remarks>
    procedure ResetDefaultFont;
    ///  <summary>Returns the highlighter attributes for the given source code
    ///  element.</summary>
    ///  <remarks>Method of IHiliteAttrs.</remarks>
    function GetElement(const Elem: THiliteElement): IHiliteElemAttrs;
    ///  <summary>Assigns the properties of the given highlighter attributes
    ///  object to this instance.</summary>
    ///  <remarks>
    ///  <para>Src must either support IHiliteAttrs or be nil. If nil then this
    ///  instance is reset to its default values.</para>
    ///  <para>Method of IAssignable.</para>
    ///  </remarks>
    procedure Assign(const Src: IInterface);
  end;

type
  ///  <summary>Class that records display attributes for use in highlighting a
  ///  source code element.</summary>
  ///  <remarks>The class records the font style and colour for a single source
  ///  code element.</remarks>
  THiliteElemAttrs = class(TInterfacedObject,
    IHiliteElemAttrs, IAssignable
  )
  strict private
    var
      ///  <summary>Foreground (font) colour of the source code element.
      ///  </summary>
      fForeColor: TColor;
      ///  <summary>Font style of the source code element.</summary>
      fFontStyle: TFontStyles;
  public
    ///  <summary>Creates a new instance of the class with default values.
    ///  </summary>
    constructor Create;
    ///  <summary>Checks if the element's attributes are "null", i.e. all
    ///  properties default values.</summary>
    ///  <remarks>
    ///  <para>This method is used to determines whether to output formatting
    ///  information for an element.</para>
    ///  <para>Method of IHiliteElemAttrs.</para>
    ///  </remarks>
    function IsNul: Boolean;
    ///  <summary>Returns the element's font style.</summary>
    ///  <remarks>Method of IHiliteElemAttrs.</remarks>
    function GetFontStyle: TFontStyles;
    ///  <summary>Sets the element's font style to the given value.</summary>
    ///  <remarks>Method of IHiliteElemAttrs.</remarks>
    procedure SetFontStyle(const AFontStyle: TFontStyles);
    ///  <summary>Gets the element's foreground (font) colour.</summary>
    ///  <remarks>Method of IHiliteElemAttrs.</remarks>
    function GetForeColor: TColor;
    ///  <summary>Sets the element's foreground (font) colour to the given
    ///  value.</summary>
    ///  <remarks>Method of IHiliteElemAttrs.</remarks>
    procedure SetForeColor(const AColor: TColor);
    ///  <summary>Assigns the properties of the given element attributes
    ///  object to this instance.</summary>
    ///  <remarks>
    ///  <para>Src must either support IHiliteElemAttrs or be nil. If nil then
    ///  this instance is reset to its default values.</para>
    ///  <para>Method of IAssignable.</para>
    ///  </remarks>
    procedure Assign(const Src: IInterface);
  end;

type
  ///  <summary>Implements a list of named syntax highlighter attributes where
  ///  attributes are accessed by name.</summary>
  TNamedHiliterAttrs = class(TInterfacedObject,
    INamedHiliteAttrs, IAssignable
  )
  strict private
    var
      ///  <summary>Map of names to syntax highlighter attributes.</summary>
      fMap: TDictionary<string,IHiliteAttrs>;
  public
    ///  <summary>Creates new instance with empty list.</summary>
    constructor Create;
    ///  <summary>Destroys instance.</summary>
    destructor Destroy; override;
    ///  <summary>Checks if highlighter attributes with given name exists.
    ///  </summary>
    ///  <remarks>Method of INamedHiliteAttrs.</remarks>
    function Contains(const Name: string): Boolean;
    ///  <summary>Checks if list is empty.</summary>
    ///  <remarks>Method of INamedHiliteAttrs.</remarks>
    function IsEmpty: Boolean;
    ///  <summary>Deletes highlighter attributes with given name.</summary>
    ///  <remarks>Method of INamedHiliteAttrs.</remarks>
    procedure Delete(const Name: string);
    ///  <summary>Clears list of highlighter attributes.</summary>
    ///  <remarks>Method of INamedHiliteAttrs.</remarks>
    procedure Clear;
    ///  <summary>Gets highlighter attributes with given name, which must exist.
    ///  </summary>
    ///  <remarks>Method of INamedHiliteAttrs.</remarks>
    function GetHiliter(const Name: string): IHiliteAttrs;
    ///  <summary>Stores given highlighter attributes in list with given name.
    ///  If name is already present its highighter attributes are overwritten.
    ///  </summary>
    ///  <remarks>Method of INamedHiliteAttrs.</remarks>
    procedure SetHiliter(const Name: string; Hiliter: IHiliteAttrs);
    ///  <summary>Returns an array of highlighter attribute names.</summary>
    ///  <remarks>Method of INamedHiliteAttrs.</remarks>
    function GetNames: TArray<string>;
    ///  <summary>Assigns properties of given Src object to this instance. Src
    ///  must support INamedHiliteAttrs.</summary>
    ///  <remarks>Method of IAssignable.</remarks>
    procedure Assign(const Src: IInterface);
  end;

{ THiliteAttrs }

procedure THiliteAttrs.Assign(const Src: IInterface);
var
  Elem: THiliteElement; // loops thru all highlight elements
begin
  if Assigned(Src) then
  begin
    if not Supports(Src, IHiliteAttrs) then
      raise EBug.Create(
        ClassName + '.Assign: Src does not support IHiliteAttrs'
      );
    // Src is assigned: copy its properties
    with Src as IHiliteAttrs do
    begin
      Self.SetFontName(FontName);
      Self.SetFontSize(FontSize);
      for Elem := Low(THiliteElement) to High(THiliteElement) do
        (Self.GetElement(Elem) as IAssignable).Assign(Elements[Elem]);
    end;
  end
  else
  begin
    // Src is nil: set defaults
    Self.SetFontName(cDefFontName);
    Self.SetFontSize(cDefFontSize);
    // Get each element attribute to sets its own default by assigning nil
    for Elem := Low(THiliteElement) to High(THiliteElement) do
      (Self.GetElement(Elem) as IAssignable).Assign(nil);
  end;
end;

constructor THiliteAttrs.Create;
var
  Elem: THiliteElement; // loops thru all highlight elements
begin
  inherited;
  // Set default font values
  fFontName := cDefFontName;
  fFontSize := cDefFontSize;
  // Create list that holds an null object for each highlight element
  // Low(THiliteElement) is at index 0 in list
  fElemAttrs := TList<IHiliteElemAttrs>.Create;
  for Elem := Low(THiliteElement) to High(THiliteElement) do
    fElemAttrs.Add(THiliteElemAttrs.Create);
end;

destructor THiliteAttrs.Destroy;
begin
  fElemAttrs.Free;  // releases each object in list
  inherited;
end;

function THiliteAttrs.GetElement(
  const Elem: THiliteElement): IHiliteElemAttrs;
begin
  // Note: Low(THiliteElement) is at index 0 in list. Following code does *not*
  // assume that Ord(Low(THiliteElement)) = 0.
  Result := fElemAttrs[Ord(Elem) - Ord(Low(THiliteElement))];
end;

function THiliteAttrs.GetFontName: string;
begin
  Result := fFontName;
end;

function THiliteAttrs.GetFontSize: Integer;
begin
  Result := fFontSize;
end;

procedure THiliteAttrs.ResetDefaultFont;
begin
  SetFontName(cDefFontName);
  SetFontSize(cDefFontSize);
end;

procedure THiliteAttrs.SetFontName(const AFontName: string);
begin
  fFontName := AFontName;
end;

procedure THiliteAttrs.SetFontSize(const AFontSize: Integer);
begin
  fFontSize := AFontSize;
end;

{ THiliteElemAttrs }

procedure THiliteElemAttrs.Assign(const Src: IInterface);
begin
  if Assigned(Src) then
  begin
    if not Supports(Src, IHiliteElemAttrs) then
      raise EBug.Create(
        ClassName + '.Assign: Src does not support IHiliteElemAttrs'
      );
    // Src is assigned: copy its properties
    with Src as IHiliteElemAttrs do
    begin
      Self.SetForeColor(ForeColor);
      Self.SetFontStyle(FontStyle);
    end;
  end
  else
  begin
    // Src is nil: reset properties to default (null) values
    Self.SetForeColor(clNone);
    Self.SetFontStyle([]);
  end;
end;

constructor THiliteElemAttrs.Create;
begin
  inherited;
  // Intialise properties to default (null) values
  fForeColor := clNone;
  fFontStyle := [];
end;

function THiliteElemAttrs.GetFontStyle: TFontStyles;
begin
  Result := fFontStyle;
end;

function THiliteElemAttrs.GetForeColor: TColor;
begin
  Result := fForeColor;
end;

function THiliteElemAttrs.IsNul: Boolean;
begin
  Result := (fFontStyle = []) and (fForeColor = clNone);
end;

procedure THiliteElemAttrs.SetFontStyle(const AFontStyle: TFontStyles);
begin
  fFontStyle := AFontStyle;
end;

procedure THiliteElemAttrs.SetForeColor(const AColor: TColor);
begin
  fForeColor := AColor;
end;

{ THiliteAttrsFactory }

class function THiliteAttrsFactory.CloneAttrs(
  Attrs: IHiliteAttrs): IHiliteAttrs;
begin
  Result := THiliteAttrs.Create;
  (Result as IAssignable).Assign(Attrs);
end;

class function THiliteAttrsFactory.CreateDefaultAttrs: IHiliteAttrs;
begin
  Result := THiliteAttrsFactory.CreatePredefinedAttrs(hsRADStudio);
end;

class function THiliteAttrsFactory.CreateNamedAttrs: INamedHiliteAttrs;
begin
  Result := TNamedHiliterAttrs.Create;
end;

class function THiliteAttrsFactory.CreateNulAttrs: IHiliteAttrs;
begin
  // Just create highlighter object: null values are defaults
  Result := THiliteAttrs.Create;
end;

class function THiliteAttrsFactory.CreatePredefinedAttrs(
  const Style: TPredefinedHiliteStyle): IHiliteAttrs;
type
  // Table of highlighter attributes.
  TAttrsTable = array[THiliteElement] of record
    ForeColor: TColor;        // foreground (text) colour
    FontStyle: TFontStyles;   // set of font styles
  end;
const
  // Map of predefined styles to source code element attributes.
  cPredefinedStyle: array[TPredefinedHiliteStyle] of TAttrsTable =  (
    ( // hsNul
      (ForeColor: clNone;     FontStyle: [];),          // heWhitespace
      (ForeColor: clNone;     FontStyle: [];),          // heComment
      (ForeColor: clNone;     FontStyle: [];),          // heReserved
      (ForeColor: clNone;     FontStyle: [];),          // heIdentifier
      (ForeColor: clNone;     FontStyle: [];),          // heSymbol
      (ForeColor: clNone;     FontStyle: [];),          // heString
      (ForeColor: clNone;     FontStyle: [];),          // heNumber
      (ForeColor: clNone;     FontStyle: [];),          // heFloat
      (ForeColor: clNone;     FontStyle: [];),          // heHex
      (ForeColor: clNone;     FontStyle: [];),          // hePreProcessor
      (ForeColor: clNone;     FontStyle: [];),          // heAssembler
      (ForeColor: clNone;     FontStyle: [];)           // heError
    ),
    ( // hsCodeSnip
      (ForeColor: clNone;     FontStyle: [];),          // heWhitespace
      (ForeColor: clNavy;     FontStyle: [fsItalic];),  // heComment
      (ForeColor: clNone;     FontStyle: [fsBold];),    // heReserved
      (ForeColor: clNone;     FontStyle: [];),          // heIdentifier
      (ForeColor: clNone;     FontStyle: [];),          // heSymbol
      (ForeColor: clPurple;   FontStyle: [];),          // heString
      (ForeColor: clMaroon;   FontStyle: [];),          // heNumber
      (ForeColor: clMaroon;   FontStyle: [];),          // heFloat
      (ForeColor: clMaroon;   FontStyle: [];),          // heHex
      (ForeColor: clGreen;    FontStyle: [];),          // hePreProcessor
      (ForeColor: clNone;     FontStyle: [fsItalic];),  // heAssembler
      (ForeColor: clRed;      FontStyle: [];)           // heError
    ),
    ( // hsDelphi7
      (ForeColor: clNone;     FontStyle: [];),          // heWhitespace
      (ForeColor: clNavy;     FontStyle: [fsItalic];),  // heComment
      (ForeColor: clBlack;    FontStyle: [fsBold];),    // heReserved
      (ForeColor: clBlack;    FontStyle: [];),          // heIdentifier
      (ForeColor: clBlack;    FontStyle: [];),          // heSymbol
      (ForeColor: clNavy;     FontStyle: [];),          // heString
      (ForeColor: clNavy;     FontStyle: [];),          // heNumber
      (ForeColor: clNavy;     FontStyle: [];),          // heFloat
      (ForeColor: clNavy;     FontStyle: [];),          // heHex
      (ForeColor: clNavy;     FontStyle: [];),          // hePreProcessor
      (ForeColor: clBlack;    FontStyle: [];),          // heAssembler
      (ForeColor: clRed;      FontStyle: [];)           // heError
    ),
    ( // hsRADStudio
      (ForeColor: clNone;     FontStyle: [];),          // heWhitespace
      (ForeColor: clGreen;    FontStyle: [fsItalic];),  // heComment
      (ForeColor: clNavy;     FontStyle: [fsBold];),    // heReserved
      (ForeColor: clNone;     FontStyle: [];),          // heIdentifier
      (ForeColor: clNone;     FontStyle: [];),          // heSymbol
      (ForeColor: clBlue;     FontStyle: [];),          // heString
      (ForeColor: clBlue;     FontStyle: [];),          // heNumber
      (ForeColor: clBlue;     FontStyle: [];),          // heFloat
      (ForeColor: clBlue;     FontStyle: [];),          // heHex
      (ForeColor: clTeal;     FontStyle: [];),          // hePreProcessor
      (ForeColor: clNone;     FontStyle: [];),          // heAssembler
      (ForeColor: clRed;      FontStyle: [];)           // heError
    ),
    ( // hsVisualStudio
      (ForeColor: clNone;     FontStyle: [];),          // heWhitespace
      (ForeColor: clGreen;    FontStyle: [];),          // heComment
      (ForeColor: clBlue;     FontStyle: [];),          // heReserved
      (ForeColor: clBlack;    FontStyle: [];),          // heIdentifier
      (ForeColor: clNone;     FontStyle: [];),          // heSymbol
      (ForeColor: clNone;     FontStyle: [];),          // heString
      (ForeColor: clNone;     FontStyle: [];),          // heNumber
      (ForeColor: clNone;     FontStyle: [];),          // heFloat
      (ForeColor: clNone;     FontStyle: [];),          // heHex
      (ForeColor: clBlue;     FontStyle: [];),          // hePreProcessor
      (ForeColor: clBlack;    FontStyle: [];),          // heAssembler
      (ForeColor: clRed;      FontStyle: [];)           // heError
    )
  );
var
  Elem: THiliteElement;   // loops thru highlighter elements
begin
  // Create highlighter with default (null) values
  // (we accept default font name and size)
  Result := THiliteAttrs.Create;
  // Set required properties for highlight elements per table
  for Elem := Low(THiliteElement) to High(THiliteElement) do
  begin
    Result[Elem].FontStyle := cPredefinedStyle[Style][Elem].FontStyle;
    Result[Elem].ForeColor := cPredefinedStyle[Style][Elem].ForeColor;
  end;
end;

class function THiliteAttrsFactory.CreatePrintAttrs(
  const Attrs: IHiliteAttrs; const UseColour: Boolean): IHiliteAttrs;
var
  Elem: THiliteElement; // loops thru all highlighter elements
begin
  if not Assigned(Attrs) then
    // No highlighter: use null
    Result := CreateNulAttrs
  else
  begin
    // Copy provided Attr
    Result := THiliteAttrs.Create;
    (Result as IAssignable).Assign(Attrs);
    if not UseColour then
      // Remove colour information: not used
      for Elem := Low(THiliteElement) to High(THiliteElement) do
        Result[Elem].ForeColor := clNone;
  end;
end;

class function THiliteAttrsFactory.CreateUserAttrs: IHiliteAttrs;
begin
  Result := THiliteAttrs.Create;
  (Result as IAssignable).Assign(Preferences.HiliteAttrs);
end;

{ TNamedHiliterAttrs }

procedure TNamedHiliterAttrs.Assign(const Src: IInterface);
var
  Name: string;
  SrcHiliters: INamedHiliteAttrs;
begin
  Assert(Supports(Src, INamedHiliteAttrs), ClassName + '.Assign: Src is nil');
  Clear;
  SrcHiliters := Src as INamedHiliteAttrs;
  for Name in SrcHiliters.Names do
    fMap.Add(Name, SrcHiliters[Name]);
end;

procedure TNamedHiliterAttrs.Clear;
begin
  fMap.Clear;
end;

function TNamedHiliterAttrs.Contains(const Name: string): Boolean;
begin
  Result := fMap.ContainsKey(Name);
end;

constructor TNamedHiliterAttrs.Create;
begin
  inherited Create;
  fMap := TDictionary<string,IHiliteAttrs>.Create(
    TTextEqualityComparer.Create
  );
end;

procedure TNamedHiliterAttrs.Delete(const Name: string);
begin
  if fMap.ContainsKey(Name) then
    fMap.Remove(Name);
end;

destructor TNamedHiliterAttrs.Destroy;
begin
  fMap.Free;
  inherited;
end;

function TNamedHiliterAttrs.GetHiliter(const Name: string): IHiliteAttrs;
begin
  Assert(fMap.ContainsKey(Name), ClassName + '.GetHiliter: Name not found');
  Result := THiliteAttrsFactory.CloneAttrs(fMap[Name]);
end;

function TNamedHiliterAttrs.GetNames: TArray<string>;
var
  Idx: Integer;
  Enum: TEnumerator<string>;
begin
  SetLength(Result, fMap.Count);
  Enum := fMap.Keys.GetEnumerator;
  try
    Idx := 0;
    while Enum.MoveNext do
    begin
      Result[Idx] := Enum.Current;
      Inc(Idx);
    end;
  finally
    Enum.Free;
  end;
end;

function TNamedHiliterAttrs.IsEmpty: Boolean;
begin
  Result := fMap.Count = 0;
end;

procedure TNamedHiliterAttrs.SetHiliter(const Name: string;
  Hiliter: IHiliteAttrs);
var
  Clone: IHiliteAttrs;
begin
  Clone := THiliteAttrsFactory.CloneAttrs(Hiliter);
  if fMap.ContainsKey(Name) then
    fMap[Name] := Clone
  else
    fMap.Add(Name, Clone);
end;

end.