synuniclasses.pas

SynEditStudio delphi 代码编辑器

{
@abstract(TSynUniSyn classes source)
@authors(Fantasist [[e-mail]], Vit [[e-mail]],
         Vitalik [[e-mail]], Quadr0 [[e-mail]])
@created(2004)
@lastmod(2006-07-23)
}

{$IFNDEF QSynUniClasses}
unit SynUniClasses;
{$ENDIF}

{$I SynUniHighlighter.inc}

interface

uses
{$IFDEF SYN_CLX}
  Qt,
  Types,
  QGraphics,
  QSynEditTypes,
  QSynEditHighlighter,
  QSynEditStrConst,
{$ELSE}
  Windows,
  Graphics,
  SynEditTypes,
  SynEditHighlighter,
  SynEditStrConst,
{$ENDIF}
  Classes,
  SysUtils;

type
  TCharSet = set of Char;

  TSynInfo = class;

  TSynToken = class;

  TTokenNode = class;

  TTokenNodeList = class;

  TAuthorInfo = record
    Name: string;
    Email: string;
    Web: string;
    Copyright: string;
    Company: string;
    Remark: string;
  end;

  TGeneralInfo = record
    Name: string;
    Extensions: string;
    Version: Integer;
    Revision: Integer;
    History: string;
    Sample: string;
  end;
  
  TSynInfo = class
  public
    Author: TAuthorInfo;
    General: TGeneralInfo;    
    procedure Clear;
    procedure LoadFromFile(AFileName: string);
    procedure LoadFromStream(AStream: TStream);
    procedure SaveToFile(AFileName: string);
    procedure SaveToStream(AStream: TStream);
  end;
  
  TStartType = (stUnspecified, stAny, stTerm);
  TBreakType = (btUnspecified, btAny, btTerm);
  TStartLine = (slNotFirst, slFirst, slFirstNonSpace);
  
  TSynAttributes = class(TSynHighlighterAttributes)
  public
    ParentForeground: Boolean;
    ParentBackground: Boolean;
    constructor Create(AName: string);
    destructor Destroy(); override;
    {$IFNDEF SYNEDIT11}
    procedure AssignColorAndStyle(AStyle: TSynAttributes); overload;
    {$ENDIF}
    //property Name: string read fName write fName;
  end;

  TEditorProperties = class
  public
    ActiveLineColor: TColor;
    SelectedForeground: TColor;
    SelectedBackground: TColor;
    constructor Create();
    destructor Destroy();
    procedure Clear();
  end;

  TAbstractRule = class;

  TAbstractSynToken = class
  public
    Attributes: TSynHighlighterAttributes;
    BreakType: TBreakType;
    FinishOnEol: Boolean;
    fIsRegexp: Boolean; //new
    fOpenRule: TAbstractRule;
    StartLine: TStartLine;
    StartType: TStartType;
    constructor Create(); reintroduce; overload;
    constructor Create(Attribs: TSynHighlighterAttributes); reintroduce; overload;
    constructor Create(ASynToken: TAbstractSynToken); reintroduce; overload;
    destructor Destroy(); override;
    procedure Clear;
  end;

  TSynMultiToken = class(TAbstractSynToken)
  private
    fSymbols: TStringList;
    function GetSymbol(Index: Integer): string;
    procedure SetSymbol(Index: Integer; ASymbol: string);
  public
    constructor Create(); reintroduce; overload;
    constructor Create(Attribs: TSynHighlighterAttributes); reintroduce; overload;
    constructor Create(ASynMultiToken: TSynMultiToken); reintroduce; overload;
    destructor Destroy(); override;
    function AddSymbol(ASymbol: string): Integer;
    function SymbolCount(): Integer;
    procedure Clear();
    procedure DeleteSymbol(Index: Integer);
    //property SymbolList: TStringList read fSymbols write fSymbols;
    property Symbols[Index: Integer]: string read GetSymbol write SetSymbol; //眢骓?index 漕徉忤螯 ?蝮溧 #0
  end;
  
  TSynToken = class(TAbstractSynToken)
  private
    fSymbol: string;
    function GetSymbol: string;
  public                       
    ClosingToken: TSynToken;
    Temporary: Boolean;
    constructor Create(); overload;
    constructor Create(Attribs: TSynHighlighterAttributes); overload;
    constructor Create(ASynToken: TSynToken); overload;
    constructor Create(ASynMultiToken: TSynMultiToken; Index: Integer); overload;
    destructor Destroy(); override;
    procedure Clear();
    property Symbol: string read GetSymbol write fSymbol;
  end;

  //TODO: 忸珈铈眍 耱铊?邈?皲咫囹?磬耠邃龛觐?TAbstractSynSymbol
  TTokenNode = class //was: TSymbolNode
  private
    fChar: Char;
  public
    BreakType: TBreakType;
    StartType: TStartType;
    NextNodes: TTokenNodeList;
    SynToken: TSynToken;
    constructor Create(AChar: Char; ASynToken: TSynToken; ABreakType: TBreakType); overload; //virtual;
    constructor Create(AChar: Char); overload;
    destructor Destroy(); override;
    property Char: Char read fChar write fChar;
  end;

  TTokenNodeList = class //was: TSymbolList
    NodeList: TList;
    constructor Create(); //virtual;
    destructor Destroy(); override;
    function FindNode(AChar: Char): TTokenNode;
    function GetCount: Integer;
    function GetNode(Index: Integer): TTokenNode;
    procedure AddNode(Node: TTokenNode);
    procedure SetNode(Index: Integer; Value: TTokenNode);
    property Count: Integer read GetCount;
    property Nodes[index: Integer]: TTokenNode read GetNode write SetNode;
  end;

  { Color scheme }
  TSynScheme = class
  private
    fName: string;
    fStyleList: TList;

    function GetCount: Integer;
    function GetStyle(Index: Integer): TSynAttributes;
    procedure SetStyle(Index: Integer; Value: TSynAttributes);
  public
    EditorProperties: TEditorProperties;

    constructor Create(const AName: string); virtual;
    destructor Destroy(); override;

    function AddStyle(AName: string; Foreground, Background: TColor;
      FontStyle: TFontStyles): TSynAttributes; overload;
    function GetStyleDefault(const AName: string;
      const Default: TSynAttributes): TSynAttributes;
    function GetStyleName(const AName: string): TSynAttributes;
    function IndexOf(const AName: string): Integer;

    procedure AddStyle(AStyle: TSynAttributes); overload;
    procedure Clear();
    procedure Delete(const Index: Integer);

    property Count: Integer read GetCount;
    property Name: string read fName write fName;
    property Styles[index: Integer]: TSynAttributes read GetStyle write SetStyle;
  end;

  TSynUniSchemes = class
  protected
    fSchemesList: TList;    
    
    function GetCount(): Integer;
    function GetScheme(Index: Integer): TSynScheme;
    procedure SetScheme(Index: Integer; Value: TSynScheme);
  public
    constructor Create(); virtual;
    destructor Destroy(); override;

    function AddScheme(const AName: string): TSynScheme; overload;
    function GetSchemeName(const AName: string): TSynScheme;
    function IndexOf(AScheme: TSynScheme): Integer;

    procedure AddScheme(const AScheme: TSynScheme); overload;
    procedure Clear();
    procedure Delete(AScheme: TSynScheme); overload;
    procedure Delete(const Index: Integer); overload;
    procedure ListStyleNames(AList: TStrings);
    procedure LoadFromFile(AFileName: string);
    procedure LoadFromStream(AStream: TStream);
    procedure SaveToFile(AFileName: string);
    procedure SaveToStream(AStream: TStream);

    property Count: Integer read GetCount;
    property Schemes[index: Integer]: TSynScheme read GetScheme write SetScheme;
  end;

  TAbstractRule = class
  private   
    fEnabled: Boolean;   
    procedure SetEnabled(Value: Boolean);
  public
    constructor Create();
    destructor Destroy(); override;
    property Enabled: Boolean read fEnabled write SetEnabled
      default True;
  end;
  
  function FontStyleToStr(AFontStyle: TFontStyles): string;
  function StrToFontStyle(AString: string): TFontStyles;
  function SetToStr(ACharSet: TCharSet): string;
  function StrToSet(AString: string): TCharSet;
  function StartLineToStr(AStartLine: TStartLine): string;
  function StrToStartLine(AString: string): TStartLine;
  function StartTypeToStr(AStartType: TStartType): string;
  function StrToStartType(AString: string): TStartType;
  function BreakTypeToStr(ABreakType: TBreakType): string;
  function StrToBreakType(AString: string): TBreakType;

  procedure ClearList(var List: TList);
  procedure FreeList(var List: TList);