* Add commands unit

(cherry picked from commit 5de228eeea8d70c470dfb59b455bd1e066e74a20)

packages/fcl-pdf/src/fppdfcommands.pp

@@ -0,0 +1,2050 @@
+unit fppdfcommands;
+
+{$mode ObjFPC}{$H+}
+
+interface
+
+uses
+  Classes, SysUtils, fppdfconsts, types, fppdfobjects;
+
+Type
+
+{ ----------------------------------------------------------------------
+  General types, to be used as parents for specific commands
+  ----------------------------------------------------------------------}
+
+ // Do not register these classes !!
+
+  { TPDFBTCommand }
+
+  TPDFTextStateCommand = class(TPDFCommand)
+    class function CommandType : TPDFCommandType; override;
+  end;
+
+  { TPDFGraphicStateCommand }
+
+  TPDFGraphicStateCommand = class(TPDFCommand)
+    class function CommandType : TPDFCommandType; override;
+  end;
+
+  { TPDFNameCommand }
+
+  TPDFNameCommand = class(TPDFCommand)
+  protected
+    function GetValue: String;
+  Public
+    Property Name : String Read GetValue;
+  end;
+
+  { TPDFMarkedContentCommand }
+
+  TPDFMarkedContentCommand = class(TPDFNameCommand)
+  Public
+    Class function CommandType: TPDFCommandType; override;
+    Property Tag : String Read GetValue;
+  end;
+
+
+  { TPDFTextCommand }
+
+  TPDFTextCommand = Class(TPDFCommand)
+  Public
+    class function CommandType : TPDFCommandType; override;
+    Function GetFullText(aUnicodeMap : TPDFCMap) : RawByteString; virtual; overload;
+    Function GetFullText : RawByteString; virtual; abstract; overload;
+  end;
+
+  // Some parents that allow easy access to the arguments
+
+  { TPDFNumberCommand }
+
+  TPDFNumberCommand = class(TPDFCommand)
+  private
+    function GetAsArray: TSingleDynArray;
+    function GetValues(Index: Integer): Single;
+  protected
+    function GetValue: Single;
+  Public
+    Property Value : Single Read GetValue;
+    Property Values[Index: Integer] : Single Read GetValues;
+    Property AsArray : TSingleDynArray Read GetAsArray;
+  end;
+
+  { TPDFIntegerNumberCommand }
+
+  TPDFIntegerNumberCommand = class(TPDFCommand)
+  protected
+    function GetValue: Integer;
+  Public
+    Property Value : Integer Read GetValue;
+  end;
+
+  { TPDFStringCommand }
+
+  TPDFStringCommand = class(TPDFCommand)
+  protected
+    function GetValue: String;
+  Public
+    Property Value : String Read GetValue;
+  end;
+
+
+  { Transformation matrix :
+    [ a b 0 ]  [ hscale skew1   0]
+    [ c d 0 ]  [ skew2  vscale  0]
+    [ e f 1 ]  [ hoff   voff    1]
+  }
+
+  { TPDFTransformCommand }
+
+  TPDFTransformCommand = class(TPDFCommand)
+  private
+    function GetMatrixPos(aIndex: Integer): double;
+    function GetTransFormation: TPDFTransFormation;
+  public
+    property a : double Index 0 Read GetMatrixPos; // Horz scale
+    property b : double Index 1 Read GetMatrixPos; // Skew 1
+    property c : double Index 2 Read GetMatrixPos; // Skew 2
+    property d : double Index 3 Read GetMatrixPos; // Vert scale
+    property e : double Index 4 Read GetMatrixPos; // Horz offset
+    property f : double Index 5 Read GetMatrixPos; // Vert offset
+    Property TransFormation : TPDFTransFormation read GetTransFormation;
+  end;
+
+  { TPDFTranslateCommand }
+
+  TPDFTranslateCommand = class(TPDFCommand)
+  private
+    function GetPos(AIndex: Integer): double;
+  public
+    property x : double Index 0 Read GetPos;
+    property y : double Index 1 Read GetPos;
+  end;
+
+  { TPDFDrawcommand }
+
+  TPDFDrawcommand = class(TPDFCommand)
+    class function CommandType : TPDFCommandType; override;
+  end;
+
+  { TPDFPointcommand }
+
+  TPDFPointcommand = class(TPDFDrawcommand)
+  protected
+    function GetCoord(AIndex: Integer): Single;
+    function GetPoint(AIndex: Integer): TPDFPoint;
+  end;
+
+  TPDFOnePointcommand = class(TPDFPointCommand)
+  protected
+  Public
+    property X : Single Index 0 Read GetCoord;
+    property Y : Single Index 1 Read GetCoord;
+    Property AsPoint : TPDFPoint Index 0 Read GetPoint;
+  end;
+
+  TPDFTwoPointscommand = class(TPDFPointCommand)
+  Public
+    property X1 : Single Index 0 Read GetCoord;
+    property Y1 : Single Index 1 Read GetCoord;
+    property X2 : Single Index 2 Read GetCoord;
+    property Y2 : Single Index 3 Read GetCoord;
+    Property Point1 : TPDFPoint Index 0 Read GetPoint;
+    Property Point2 : TPDFPoint Index 1 Read GetPoint;
+  end;
+
+  { TPDFThreePointscommand }
+
+  TPDFThreePointscommand = class(TPDFTwoPointsCommand)
+  Public
+    property X3 : Single Index 4 Read GetCoord;
+    property Y3 : Single Index 5 Read GetCoord;
+    Property Point3 : TPDFPoint Index 2 Read GetPoint;
+  end;
+
+  { TPDFStrokeCommand }
+
+  TPDFStrokeCommand = class(TPDFCommand)
+    class function CommandType : TPDFCommandType; override;
+    class Function StrokeOptions : TPDFStrokeOptions; virtual; abstract;
+  end;
+
+{ ----------------------------------------------------------------------
+  Other commands
+  ----------------------------------------------------------------------}
+
+
+  { TPDFBXCommand }
+
+  // begin compatibility section
+  TPDFBXCommand = class(TPDFCommand)
+    Class Function RegisterCommandName : String;override;
+  end;
+
+  { TPDFEXCommand }
+
+  // end compatibility section
+  TPDFEXCommand = class(TPDFCommand)
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFTextStateCommand }
+
+  // begin text
+  TPDFBTCommand = class(TPDFTextStateCommand)
+    Class Function RegisterCommandName : String;override;
+  end;
+
+  { TPDFETCommand }
+
+  // end text
+  TPDFETCommand = class(TPDFTextStateCommand)
+    Class Function RegisterCommandName : String; override;
+  end;
+
+
+  { TPDFBDCCommand }
+
+  // Begin Marked Content with properties
+  TPDFBDCCommand = class(TPDFMarkedContentCommand)
+    Class Function RegisterCommandName : String;override;
+  end;
+
+
+  { TPDFBMCCommand }
+
+  // Begin Marked Content
+  TPDFBMCCommand = class(TPDFMarkedContentCommand)
+    Class Function RegisterCommandName : String;override;
+  end;
+
+
+  { TPDFEMCCommand }
+
+  // End Marked Content
+  TPDFEMCCommand = class(TPDFMarkedContentCommand)
+    Class Function RegisterCommandName : String; override;
+  end;
+
+
+  { TPDFMPCommand }
+
+  // Marked content Point
+  TPDFMPCommand = class(TPDFMarkedContentCommand)
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFDPCommand }
+
+  // Marked content Point with properties
+  TPDFDPCommand = class(TPDFMarkedContentCommand)
+    Class Function RegisterCommandName : String; override;
+  end;
+
+
+  { TPDFDoCommand }
+
+  // Invoke named object
+  TPDFDoCommand = class(TPDFCommand)
+    Class Function RegisterCommandName : String;override;
+  end;
+
+{ ----------------------------------------------------------------------
+  Graphics state
+  ----------------------------------------------------------------------}
+
+  { TPDFcmCommand }
+
+  // concat CMT matrix
+  TPDFcmCommand = class(TPDFGraphicStateCommand)
+    Class Function RegisterCommandName : String;override;
+  end;
+
+
+  { TPDFcm_Command }
+  // set current transformation matrix
+  TPDFcm_Command = class(TPDFTransformCommand)
+    Class Function RegisterCommandName : String; override;
+    class function CommandType : TPDFCommandType; override;
+  end;
+
+
+
+  { TPDFq_Command }
+
+  // Push graphics drawing state
+  TPDFq_Command = class(TPDFGraphicStateCommand)
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFQCommand }
+
+  // Pop graphics drawing state
+  TPDFQCommand = class(TPDFGraphicStateCommand)
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFw_Command }
+  // Set line width
+  TPDFw_Command = class(TPDFNumberCommand)
+  public
+    class function CommandType : TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+    Property LineWidth : Single Read GetValue;
+  end;
+
+  { TPDFJCommand }
+  // Set line cap
+  TPDFJCommand = class(TPDFintegerNumberCommand)
+  private
+    function GetLineCap: TPDFLineCapStyle;
+  public
+    class function CommandType : TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+    Property LineCap : TPDFLineCapStyle Read GetLineCap;
+  end;
+
+  { TPDFj_Command }
+  // Set line join
+  TPDFj_Command = class(TPDFintegerNumberCommand)
+  private
+    function GetLineJoin: TPDFLineJoinStyle;
+  public
+    class function CommandType : TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+    Property LineJoin : TPDFLineJoinStyle Read GetLineJoin;
+  end;
+
+  { TPDFMCommand }
+  // Set Miter limit
+  TPDFMCommand = class(TPDFNumberCommand)
+  public
+    class function CommandType : TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+    Property MiterLimit : Single Read GetValue;
+  end;
+
+  { TPDFd_Command }
+  // Set dash style
+  TPDFd_Command = class(TPDFCommand)
+  private
+    function GetDash: TPDFDashPattern;
+    function GetPattern: TIntegerDynArray;
+    function GetPhase: Integer;
+  public
+    class function CommandType : TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+    Property Pattern : TIntegerDynArray Read GetPattern;
+    Property Phase : Integer Read GetPhase;
+    Property AsDash : TPDFDashPattern Read GetDash;
+  end;
+
+
+  { TPDFi_Command }
+  // set flatness limit
+  TPDFi_Command = class(TPDFintegerNumberCommand)
+  public
+    class function CommandType : TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+    Property Flatness : Integer Read GetValue;
+  end;
+
+  { TPDFri_Command }
+  // Set color rendering intent
+  TPDFri_Command = class(TPDFStringCommand)
+  public
+    class function CommandType : TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+    Property Intent : string Read GetValue;
+  end;
+
+  { TPDFgs_Command }
+  // Set graphics state from dictionary
+  TPDFgs_Command = class(TPDFNameCommand)
+  public
+    class function CommandType: TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+    Property DictName : string Read GetValue;
+  end;
+
+{ ----------------------------------------------------------------------
+  Color commands
+  ----------------------------------------------------------------------}
+
+  { TPDFCSCommand }
+  // Set stroke color space
+
+  TPDFCSCommand = class(TPDFNameCommand)
+    class function CommandType: TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+    function ColorSpace : TPDFColorSpace;
+  end;
+
+  // Set fill color space
+
+  { TPDFcs_Command }
+
+  TPDFcs_Command = class(TPDFNameCommand)
+    class function CommandType: TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+    function ColorSpace : TPDFColorSpace;
+  end;
+
+
+  { TPDFSCCommand }
+
+  // Set stroke color
+  TPDFSCCommand = class(TPDFNumberCommand)
+    class function CommandType: TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFsc_Command }
+
+  // Set non-stroke color
+  TPDFsc_Command = class(TPDFNumberCommand)
+    class function CommandType: TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFSCNCommand }
+
+  { TPDFColorNamespaceCommand }
+
+  TPDFColorNamespaceCommand = class(TPDFCommand)
+  private
+    function GetAsArray: TSingleDynArray;
+    function HasName : Boolean;
+  Public
+    class function CommandType: TPDFCommandType; override;
+    Function ColorSpaceName : String;
+    Property AsArray : TSingleDynArray Read GetAsArray;
+  end;
+
+  TPDFSCNCommand = class(TPDFColorNamespaceCommand)
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFscn_Command }
+
+  TPDFscn_Command = class(TPDFColorNamespaceCommand)
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFscn_Command }
+
+  // Set devicegray and gray level for stroke operations
+
+  { TPDFGCommand }
+
+  TPDFGCommand = class(TPDFNumberCommand)
+  private
+    function GetColor: TPDFColor;
+  public
+    class function CommandType: TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+    property gray : single Read GetValue;
+    function ColorSpace : TPDFColorSpace;
+    property AsColor : TPDFColor Read GetColor;
+  end;
+
+  // Set devicegray and gray level for non-stroke operations
+
+  { TPDFg_Command }
+
+  TPDFg_Command = class(TPDFNumberCommand)
+  private
+    function GetColor: TPDFColor;
+  public
+    class function CommandType: TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+    property gray : single Read GetValue;
+    function ColorSpace : TPDFColorSpace;
+    property AsColor : TPDFColor Read GetColor;
+  end;
+
+
+  { TPDFRGBCommand }
+
+  // Set deviceRGB color space and color - parent
+  TPDFRGBCommand = class(TPDFNumberCommand)
+  private
+    function GetColor: TPDFColor;
+  Public
+    class function CommandType: TPDFCommandType; override;
+    function ColorSpace : TPDFColorSpace;
+    property R : single read GetValue;
+    property G : single index 1 read GetValues;
+    property B : single index 2 read GetValues;
+    Property AsColor : TPDFColor Read GetColor;
+  end;
+
+  { TPDFRGCommand }
+
+  // Set deviceRGB color space and color for stroke operations
+  TPDFRGCommand = class(TPDFRGBCommand)
+    Class Function RegisterCommandName : String; override;
+  end;
+
+
+  { TPDFrg_Command }
+
+  // Set deviceRGB color space and color for non-stroke operations
+  TPDFrg_Command = class(TPDFRGBCommand)
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFCMYKCommand }
+
+  // Select CMYK color space and color - parent
+  TPDFCMYKCommand = class(TPDFNumberCommand)
+  private
+    function GetAsColor: TPDFColor;
+  Public
+    class function CommandType: TPDFCommandType; override;
+    function ColorSpace : TPDFColorSpace;
+    property C : single read GetValue;
+    property M : single index 1 read GetValues;
+    property Y : single index 2 read GetValues;
+    property K : single index 3 read GetValues;
+    property AsColor : TPDFColor Read GetAsColor;
+  end;
+
+  { TPDFKCommand }
+
+  // Set stroke color in CMYK color space
+  TPDFKCommand = class(TPDFCMYKCommand)
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFk_Command }
+
+  // Set non-stroke color in CMYK color space
+  TPDFk_Command = class(TPDFCMYKCommand)
+    Class Function RegisterCommandName : String; override;
+  end;
+
+
+{ ----------------------------------------------------------------------
+  Text drawing
+  ----------------------------------------------------------------------}
+
+
+  { TPDFTJCommand }
+  // Draw text segments
+  TPDFTJCommand = class(TPDFTextCommand)
+    Class Function RegisterCommandName : String; override;
+    Function GetFullText(aUnicodeMap : TPDFCMap) : RawByteString; override; overload;
+    Function GetFullText : RawByteString; override;
+  end;
+
+  { TPDFTj_Command }
+
+  // Draw text
+  TPDFTj_Command = class(TPDFTextCommand)
+    Class Function RegisterCommandName : String; override;
+    Function GetFullText : RawByteString; override;
+  end;
+
+{ ----------------------------------------------------------------------
+  Text state commands
+  ----------------------------------------------------------------------}
+
+  { TPDFTf_Command }
+
+  // Set font
+  TPDFTf_Command = class(TPDFTextStateCommand)
+  private
+    function GetFontName: String;
+    function GetFontSize: Integer;
+  public
+    Class Function RegisterCommandName : String; override;
+    property FontName : String Read GetFontName;
+    Property FontSize : Integer Read GetFontSize;
+  end;
+
+
+  { TPDFTm_Command }
+
+  // Set text matrix
+  TPDFTm_Command = class(TPDFTransformCommand)
+    class function CommandType : TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFTAsterixCommand }
+
+  // Move to start of next line
+  TPDFTAsterixCommand = class(TPDFTransformCommand)
+    class function CommandType : TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFTc_Command }
+
+  // set text character spacing
+  TPDFTc_Command = class(TPDFNumberCommand)
+    class function CommandType : TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFTw_Command }
+
+  // Set text word spacing
+  TPDFTw_Command = class(TPDFNumberCommand)
+    class function CommandType : TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFTz_Command }
+
+  // set text horizontal scaling
+  TPDFTz_Command = class(TPDFNumberCommand)
+    class function CommandType : TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFTLCommand }
+
+  // Set text leading
+  TPDFTLCommand = class(TPDFNumberCommand)
+    class function CommandType : TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+  end;
+
+
+  { TPDFTr_Command }
+
+  // set text rendering mode
+  TPDFTr_Command = class(TPDFIntegerNumberCommand)
+    class Function CommandType: TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+    Function RenderMode : TPDFTextRenderMode;
+  end;
+
+  { TPDFTs_Command }
+
+  // set text rise
+  TPDFTs_Command = class(TPDFNumberCommand)
+    class Function CommandType: TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+  end;
+
+
+  //  Move text position
+  TPDFTd_Command = class(TPDFTranslateCommand)
+    class function CommandType : TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFTDCommand }
+
+  // Move text position and leading
+  TPDFTDCommand = class(TPDFTranslateCommand)
+    class function CommandType : TPDFCommandType; override;
+    Class Function RegisterCommandName : String; override;
+  end;
+
+{ ----------------------------------------------------------------------
+  Drawing (path creation)
+  ----------------------------------------------------------------------}
+
+  { TPDFm_command }
+
+  TPDFm_command = Class(TPDFOnePointcommand)
+  public
+    Class Function RegisterCommandName : String; override;
+    Function PathSegment : TPDFPathSegment;
+  end;
+
+  { TPDFl_command }
+
+  TPDFl_command = Class(TPDFOnePointcommand)
+  public
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFy_command }
+
+  TPDFy_command = Class(TPDFTwoPointsCommand)
+  public
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFv_command }
+
+  TPDFv_command = Class(TPDFTwoPointsCommand)
+  public
+    Class Function RegisterCommandName : String; override;
+  end;
+
+
+  { TPDFc_command }
+
+  TPDFc_command = Class(TPDFThreePointsCommand)
+  public
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFh_command }
+
+  TPDFh_command = Class(TPDFDrawcommand)
+  public
+    Class Function RegisterCommandName : String; override;
+  end;
+
+  { TPDFre_command }
+
+  TPDFre_command = class(TPDFPointCommand)
+  Public
+    Class Function RegisterCommandName : String; override;
+    property X : Single Index 0 Read GetCoord;
+    property Y : Single Index 1 Read GetCoord;
+    property Width : Single Index 2 Read GetCoord;
+    property Height : Single Index 3 Read GetCoord;
+  end;
+
+{ ----------------------------------------------------------------------
+  Stroke (path closing) commands
+  ----------------------------------------------------------------------}
+
+  { TPDFScommand }
+
+  TPDFScommand = class(TPDFStrokeCommand)
+  public
+    Class Function RegisterCommandName : String; override;
+    class Function StrokeOptions : TPDFStrokeOptions; override;
+  end;
+
+  { TPDFs_command }
+
+  TPDFs_command = class(TPDFStrokeCommand)
+  public
+    Class Function RegisterCommandName : String; override;
+    class Function StrokeOptions : TPDFStrokeOptions; override;
+  end;
+
+  { TPDFf_command }
+
+  TPDFf_command = class(TPDFStrokeCommand)
+  public
+    Class Function RegisterCommandName : String; override;
+    class Function StrokeOptions : TPDFStrokeOptions; override;
+  end;
+
+  { TPDFFcommand }
+
+  TPDFFcommand = class(TPDFStrokeCommand)
+  public
+    Class Function RegisterCommandName : String; override;
+    class Function StrokeOptions : TPDFStrokeOptions; override;
+  end;
+
+  { TPDfAsterisk_command }
+
+  { TPDFfAsterisk_command }
+
+  TPDFfAsterisk_command = class(TPDFStrokeCommand)
+  public
+    Class Function RegisterCommandName : String; override;
+    class Function StrokeOptions : TPDFStrokeOptions; override;
+  end;
+
+  { TPDFBcommand }
+
+  TPDFBcommand = class(TPDFStrokeCommand)
+  public
+    Class Function RegisterCommandName : String; override;
+    class Function StrokeOptions : TPDFStrokeOptions; override;
+  end;
+
+  { TPDFBAsteriskcommand }
+
+  TPDFBAsteriskcommand = class(TPDFStrokeCommand)
+  public
+    Class Function RegisterCommandName : String; override;
+    class Function StrokeOptions : TPDFStrokeOptions; override;
+  end;
+
+  { TPDFb_command }
+
+  TPDFb_command = class(TPDFStrokeCommand)
+  public
+    Class Function RegisterCommandName : String; override;
+    class Function StrokeOptions : TPDFStrokeOptions; override;
+  end;
+
+  { TPDFbAsterisk_command }
+
+  TPDFbAsterisk_command = class(TPDFStrokeCommand)
+  public
+    Class Function RegisterCommandName : String; override;
+    class Function StrokeOptions : TPDFStrokeOptions; override;
+  end;
+
+  { TPDFn_command }
+
+  TPDFn_command = class(TPDFStrokeCommand)
+  public
+    Class Function RegisterCommandName : String; override;
+    class Function StrokeOptions : TPDFStrokeOptions; override;
+  end;
+
+{ ----------------------------------------------------------------------
+  Image commands
+  ----------------------------------------------------------------------}
+
+  TPDFImageData = record
+    Width,
+    height,
+    BitsPerComponent : Integer;
+    ColorSpace : String;
+    ColorSpaceComponents : Integer;
+    Filters : Array of String;
+  end;
+
+  { TPDFImageDataCommand }
+
+  TPDFImageDataCommand = Class(TPDFCommand)
+    Class Procedure ParseImageOperands(aOperands : TPDFTokenArray; Out aImageData : TPDFImageData);
+    Class Function RegisterCommandName : String; override;
+  end;
+
+Function StringToColorSpace(aName : string) : TPDFColorSpace;
+
+implementation
+
+Procedure RegisterStandardCommands;
+
+begin
+  // general
+  TPDFBXCommand.Register;
+  TPDFEXCommand.Register;
+  TPDFcm_Command.Register;
+  TPDFDoCommand.Register;
+  TPDFBTCommand.Register;
+  TPDFETCommand.Register;
+  // Graphics state
+  TPDFgs_Command.Register;
+  TPDFQCommand.Register;
+  TPDFq_Command.Register;
+  // text state
+  TPDFTDCommand.Register;
+  TPDFTd_Command.Register;
+  TPDFTf_Command.Register;
+  TPDFTm_Command.Register;
+  TPDFTc_Command.Register;
+  TPDFTw_Command.Register;
+  TPDFTz_Command.Register;
+  TPDFTLCommand.Register;
+  TPDFTr_Command.Register;
+  TPDFTs_Command.Register;
+  TPDFTAsterixCommand.Register;
+  // Text
+  TPDFTJCommand.Register;
+  TPDFTj_Command.Register;
+  // Graphics state
+  TPDFw_Command.Register;
+  TPDFJCommand.Register;
+  TPDFj_Command.Register;
+  TPDFMCommand.Register;
+  TPDFd_Command.Register;
+  TPDFi_Command.Register;
+  TPDFri_Command.Register;
+  // Color space
+
+  // Draw
+  TPDFm_command.Register;
+  TPDFl_command.Register;
+  TPDFy_command.Register;
+  TPDFv_command.Register;
+  TPDFc_command.Register;
+  TPDFh_command.Register;
+  // Stroke
+  TPDFScommand.Register;
+  TPDFs_command.Register;
+  TPDFf_command.Register;
+  TPDFFcommand.Register;
+  TPDFfAsterisk_command.Register;
+  TPDFBcommand.Register;
+  TPDFBAsteriskcommand.Register;
+  TPDFb_command.Register;
+  TPDFbAsterisk_command.Register;
+  TPDFn_command.Register;
+  TPDFre_command.Register;
+  // Marked content
+  TPDFBDCCommand.Register;
+  TPDFBMCCommand.Register;
+  TPDFEMCCommand.Register;
+  TPDFMPCommand.Register;
+  TPDFDPCommand.Register;
+  // Color
+  TPDFCSCommand.Register;
+  TPDFcs_Command.Register;
+  TPDFSCCommand.Register;
+  TPDFsc_Command.Register;
+  TPDFSCNCommand.Register;
+  TPDFGCommand.Register;
+  TPDFg_Command.Register;
+  TPDFRGCommand.Register;
+  TPDFrg_Command.Register;
+  TPDFKCommand.Register;
+  TPDFk_Command.Register;
+end;
+
+
+{ TPDFDrawcommand }
+
+class function TPDFDrawcommand.CommandType: TPDFCommandType;
+begin
+  Result:=cmtPath;
+end;
+
+{ TPDFPointcommand }
+
+function TPDFPointcommand.GetCoord(AIndex: Integer): Single;
+begin
+  if (aIndex>=0) and  (aIndex<Length(Tokens)) then
+    Result:=Tokens[aIndex].AsSingle
+  else
+    Result:=0;
+end;
+
+function TPDFPointcommand.GetPoint(AIndex: Integer): TPDFPoint;
+begin
+  Result.X:=GetCoord(aIndex * 2);
+  Result.Y:=GetCoord((aIndex * 2)+1);
+end;
+
+function TPDFTransformCommand.GetMatrixPos(aIndex: Integer): double;
+begin
+  if (aIndex<Length(Tokens)) then
+    Result:=Tokens[aIndex].AsDouble
+  else
+    Result:=0.0;
+end;
+
+function TPDFTransformCommand.GetTransFormation: TPDFTransFormation;
+begin
+  Result:=TPDFTransFormation.Create(a,b,c,d,e,f);
+end;
+
+
+{ TPDFNumberCommand }
+
+function TPDFNumberCommand.GetAsArray: TSingleDynArray;
+
+var
+  I : Integer;
+
+begin
+  SetLength(Result,Length(Tokens));
+  For I:=0 to Length(Result)-1 do
+    Result[i]:=Values[I];
+end;
+
+function TPDFNumberCommand.GetValues(Index: Integer): Single;
+begin
+  if (Index>=0) and (Index<Length(Tokens)) then
+    Result:=Tokens[Index].AsSingle
+  else
+    Result:=0;
+end;
+
+function TPDFNumberCommand.GetValue: Single;
+begin
+  if Length(Tokens)>0 then
+    Result:=Tokens[0].AsSingle
+  else
+    Result:=0;
+end;
+
+{ TPDFIntegerNumberCommand }
+
+function TPDFIntegerNumberCommand.GetValue: Integer;
+
+begin
+  if Length(Tokens)>0 then
+    Result:=Tokens[0].AsInteger
+  else
+    Result:=0;
+end;
+
+{ TPDFStringCommand }
+
+function TPDFStringCommand.GetValue: String;
+begin
+  if (Length(Tokens)>0) and Tokens[0].IsString then
+    Result:=Tokens[0].AsString
+  else
+    Result:='';
+end;
+
+{ TPDFNameCommand }
+
+function TPDFNameCommand.GetValue: String;
+begin
+  if (Length(Tokens)>0) and Tokens[0].IsName then
+    Result:=Tokens[0].AsName
+  else
+    Result:='';
+end;
+
+
+{ TPDFMarkedContentCommand }
+
+class function TPDFMarkedContentCommand.CommandType: TPDFCommandType;
+begin
+  Result:=cmtMarkedContent;
+end;
+
+{ TPDFGraphicStateCommand }
+
+class function TPDFGraphicStateCommand.CommandType: TPDFCommandType;
+begin
+  Result:=cmtGraphicState;
+end;
+{ TPDFTextStateCommand }
+
+class function TPDFTextStateCommand.CommandType: TPDFCommandType;
+begin
+  Result:=cmtTextState;
+end;
+
+
+
+{ TPDFTextCommand }
+
+class function TPDFTextCommand.CommandType: TPDFCommandType;
+begin
+  Result:=cmtText;
+end;
+
+function TPDFTextCommand.GetFullText(aUnicodeMap: TPDFCMap): RawByteString;
+
+Var
+  aRaw : RawByteString;
+
+begin
+  aRaw:=GetFullText();
+  if not Assigned(aUnicodeMap) then
+    Result:=aRaw
+  else
+    Result:=aUnicodeMap.InterPret(aRaw);
+end;
+
+{ TPDFImageDataCommand }
+
+class procedure TPDFImageDataCommand.ParseImageOperands(
+  aOperands: TPDFTokenArray; out aImageData: TPDFImageData);
+
+Var
+  I,J : Integer;
+
+
+begin
+  aImageData:=Default(TPDFImageData);
+  I:=0;
+  While (I<Length(aOperands)-1) do
+    begin
+    if aOperands[i].IsName then
+      begin
+      Case Copy(aOperands[i].TokenData,2,Length(aOperands[i].TokenData)-1) of
+        SPDFImageKeyW :
+          begin
+          Inc(I);
+          aImageData.Width:=aOperands[i].AsInteger;
+          end;
+        SPDFImageKeyH :
+          begin
+          Inc(I);
+          aImageData.Height:=aOperands[i].AsInteger;
+          end;
+        SPDFImageKeyBPC:
+          begin
+          Inc(I);
+          aImageData.BitsPerComponent:=aOperands[i].AsInteger;
+          end;
+        SPDFImageKeyCS:
+          begin
+          Inc(I);
+          aImageData.ColorSpace:=aOperands[i].TokenData;
+          end;
+        SPDFImageKeyF:
+          begin
+          Inc(i);
+          If aOperands[i].TokenType<>ptSquareOpen then
+            begin
+            Inc(i);
+            aImageData.Filters:=[aOperands[i].TokenData];
+            end
+          else
+            begin
+            Inc(I);
+            J:=I;
+            While (J<Length(aOperands)) and (aOperands[J].TokenType<>ptSquareClose) do
+              Inc(J);
+            SetLength(aImageData.Filters,J);
+            J:=I;
+            While (J<Length(aOperands)) and (aOperands[J].TokenType<>ptSquareClose) do
+              begin
+              aImageData.Filters[J-I]:=aOperands[J].TokenData;
+              Inc(J);
+              end
+            end;
+          end;
+      end;
+      end;
+    inc(I);
+    end;
+  Case Copy(aImageData.ColorSpace,2,Length(aImageData.ColorSpace)-1) of
+    SPDFImageKeyCMYK : aImageData.ColorSpaceComponents:=4;
+    SPDFImageKeyRGB : aImageData.ColorSpaceComponents:=3;
+    SPDFImageKeyG : aImageData.ColorSpaceComponents:=1;
+  end;
+end;
+
+class function TPDFImageDataCommand.RegisterCommandName: String;
+begin
+  Result:='ID';
+end;
+
+{ TPDFTTranslateCommand }
+
+function TPDFTranslateCommand.GetPos(AIndex: Integer): double;
+begin
+  if aIndex<Length(Tokens) then
+    Result:=Tokens[aIndex].AsDouble
+  else
+    Result:=0;
+end;
+
+{ TPDFTd_Command }
+
+class function TPDFTd_Command.CommandType: TPDFCommandType;
+begin
+  Result:=cmtTextState;
+end;
+
+class function TPDFTd_Command.RegisterCommandName: String;
+begin
+  Result:='Td';
+end;
+
+{ TPDFq_Command }
+
+class function TPDFq_Command.RegisterCommandName: String;
+begin
+  Result:='q';
+end;
+
+{ TPDFQCommand }
+
+class function TPDFQCommand.RegisterCommandName: String;
+begin
+  Result:='Q';
+end;
+
+{ TPDFw_Command }
+
+class function TPDFw_Command.CommandType: TPDFCommandType;
+begin
+  Result:=cmtGraphicState;
+end;
+
+class function TPDFw_Command.RegisterCommandName: String;
+begin
+  Result:='w';
+end;
+
+{ TPDFJCommand }
+
+function TPDFJCommand.GetLineCap: TPDFLineCapStyle;
+
+Var
+  i : integer;
+
+begin
+  Result:=lcsbutt;
+  I:=Value;
+  if (I>=0) and (I<Ord(High(TPDFLineCapStyle))) then
+    Result:=TPDFLineCapStyle(I);
+end;
+
+class function TPDFJCommand.CommandType: TPDFCommandType;
+begin
+  Result:=cmtGraphicState;
+end;
+
+class function TPDFJCommand.RegisterCommandName: String;
+begin
+  Result:='J'
+end;
+
+{ TPDFj_Command }
+
+function TPDFj_Command.GetLineJoin: TPDFLineJoinStyle;
+
+Var
+  i : integer;
+
+begin
+  Result:=ljsMiter;
+  I:=Value;
+  if (I>=0) and (I<Ord(High(TPDFLineJoinStyle))) then
+    Result:=TPDFLineJoinStyle(I);
+end;
+
+class function TPDFj_Command.CommandType: TPDFCommandType;
+begin
+  Result:=cmtGraphicState;
+end;
+
+class function TPDFj_Command.RegisterCommandName: String;
+begin
+  Result:='j';
+end;
+
+{ TPDFMCommand }
+
+class function TPDFMCommand.CommandType: TPDFCommandType;
+begin
+  Result:=cmtGraphicState;
+end;
+
+class function TPDFMCommand.RegisterCommandName: String;
+begin
+  Result:='M';
+end;
+
+{ TPDFd_Command }
+
+function TPDFd_Command.GetDash: TPDFDashPattern;
+begin
+  Result.Pattern:=Pattern;
+  Result.Phase:=Phase;
+end;
+
+function TPDFd_Command.GetPattern: TIntegerDynArray;
+
+var
+  i,len : Integer;
+
+begin
+  Result:=[];
+  Len:=Length(Tokens)-2; // Index of ]
+  if (Len<2) then
+    exit;
+  if (Tokens[0].AsString='[') and (Tokens[Len].AsString=']') then
+    begin
+    SetLength(Result,Len-1);
+    for I:=1 to Len-1 do
+      if Tokens[I].IsInteger then
+        Result[i-1]:=Tokens[I].AsInteger
+      else
+        Result[i-1]:=0;
+    end;
+end;
+
+function TPDFd_Command.GetPhase: Integer;
+
+var
+  len : Integer;
+
+begin
+  Len:=Length(Tokens)-1; // Index of phase
+  if (Len>2) and (Tokens[len].IsInteger) then
+    Result:=Tokens[Len].asInteger
+end;
+
+class function TPDFd_Command.CommandType: TPDFCommandType;
+begin
+  Result:=cmtGraphicState;
+end;
+
+class function TPDFd_Command.RegisterCommandName: String;
+begin
+  Result:='d';
+end;
+
+{ TPDFi_Command }
+
+class function TPDFi_Command.CommandType: TPDFCommandType;
+begin
+  Result:=cmtGraphicState;
+end;
+
+class function TPDFi_Command.RegisterCommandName: String;
+begin
+  Result:='i';
+end;
+
+{ TPDFri_Command }
+
+class function TPDFri_Command.CommandType: TPDFCommandType;
+begin
+  Result:=cmtGraphicState;
+end;
+
+class function TPDFri_Command.RegisterCommandName: String;
+begin
+  Result:='ri';
+end;
+
+{ TPDFgs_Command }
+
+class function TPDFgs_Command.CommandType: TPDFCommandType;
+begin
+  Result:=cmtGraphicState;
+end;
+
+class function TPDFgs_Command.RegisterCommandName: String;
+begin
+  Result:='gs';
+end;
+
+{ ----------------------------------------------------------------------
+  Color commands
+  ----------------------------------------------------------------------}
+
+
+{ TPDFCSCommand }
+
+class function TPDFCSCommand.CommandType: TPDFCommandType;
+begin
+  Result:=cmtColor;
+end;
+
+class function TPDFCSCommand.RegisterCommandName: String;
+begin
+  Result:='CS';
+end;
+
+Function StringToColorSpace(aName : string) : TPDFColorSpace;
+
+begin
+  if (aName<>'') and (aName[1]='/') then
+    Delete(aName,1,1);
+  case aName of
+    SPDFColorSpaceDeviceRGB  : result:=csDeviceRGB;
+    SPDFColorSpaceDeviceGray : result:=csDeviceGray;
+    SPDFColorSpaceDeviceCMYK : result:=csDeviceCMYK;
+  else
+    Result:=csDict;
+  end;
+end;
+
+function TPDFCSCommand.ColorSpace: TPDFColorSpace;
+begin
+  StringToColorSpace(Name);
+end;
+
+{ TPDFcs_Command }
+
+class function TPDFcs_Command.CommandType: TPDFCommandType;
+begin
+  Result:=cmtColor;
+end;
+
+class function TPDFcs_Command.RegisterCommandName: String;
+begin
+  Result:='cs';
+end;
+
+function TPDFcs_Command.ColorSpace: TPDFColorSpace;
+begin
+  Result:=StringToColorSpace(Name);
+end;
+
+{ TPDFSCCommand }
+
+class function TPDFSCCommand.CommandType: TPDFCommandType;
+begin
+  Result:=cmtColor;
+end;
+
+class function TPDFSCCommand.RegisterCommandName: String;
+begin
+  Result:='SC';
+end;
+
+{ TPDFsc_Command }
+
+class function TPDFsc_Command.CommandType: TPDFCommandType;
+begin
+  Result:=cmtColor;
+end;
+
+class function TPDFsc_Command.RegisterCommandName: String;
+begin
+  Result:='sc';
+end;
+
+{ TPDFColorNamespaceCommand }
+
+function TPDFColorNamespaceCommand.GetAsArray: TSingleDynArray;
+
+var
+  I,aCount : Integer;
+
+begin
+  aCount:=Length(Tokens)-Ord(HasName);
+  SetLength(Result,aCount);
+  For I:=0 to aCount-1 do
+    Result[i]:=Tokens[i].AsSingle;
+end;
+
+function TPDFColorNamespaceCommand.HasName: Boolean;
+begin
+  Result:=(Length(Tokens)>0) and (Tokens[Length(Tokens)].TokenType=ptName);
+end;
+
+class function TPDFColorNamespaceCommand.CommandType: TPDFCommandType;
+begin
+  Result:=cmtColor;
+end;
+
+function TPDFColorNamespaceCommand.ColorSpaceName: String;
+begin
+  if HasName then
+    Result:=Tokens[Length(Tokens)-1].AsName;
+end;
+
+{ TPDFSCNCommand }
+
+
+class function TPDFSCNCommand.RegisterCommandName: String;
+begin
+  Result:='SCN';
+end;
+
+{ TPDFscn_Command }
+
+class function TPDFscn_Command.RegisterCommandName: String;
+begin
+  Result:='scn';
+end;
+
+{ TPDFg_Command }
+
+function TPDFg_Command.GetColor: TPDFColor;
+begin
+  Result:=Default(TPDFColor);
+  Result[0]:=Gray;
+end;
+
+class function TPDFg_Command.CommandType: TPDFCommandType;
+begin
+  Result:=cmtColor
+end;
+
+class function TPDFg_Command.RegisterCommandName: String;
+begin
+  Result:='g';
+end;
+
+function TPDFg_Command.ColorSpace: TPDFColorSpace;
+begin
+  Result:=csDeviceGray;
+end;
+
+{ TPDFRGBCommand }
+
+function TPDFRGBCommand.GetColor: TPDFColor;
+begin
+  Result:=Default(TPDFColor);
+  Result[0]:=R;
+  Result[1]:=G;
+  Result[2]:=B;
+end;
+
+class function TPDFRGBCommand.CommandType: TPDFCommandType;
+begin
+  Result:=cmtColor;
+end;
+
+function TPDFRGBCommand.ColorSpace: TPDFColorSpace;
+begin
+  Result:=csDeviceRGB;
+end;
+
+{ TPDFRGCommand }
+
+class function TPDFRGCommand.RegisterCommandName: String;
+begin
+  Result:='RG';
+end;
+
+{ TPDFrg_Command }
+
+class function TPDFrg_Command.RegisterCommandName: String;
+begin
+  Result:='rg';
+end;
+
+{ TPDFCMYKCommand }
+
+function TPDFCMYKCommand.GetAsColor: TPDFColor;
+begin
+  Result:=Default(TPDFColor);
+  Result[0]:=C;
+  Result[1]:=M;
+  Result[2]:=Y;
+  Result[3]:=K;
+end;
+
+class function TPDFCMYKCommand.CommandType: TPDFCommandType;
+begin
+  Result:=cmtColor;
+end;
+
+function TPDFCMYKCommand.ColorSpace: TPDFColorSpace;
+begin
+  result:=csDeviceCMYK;
+end;
+
+{ TPDFKCommand }
+
+class function TPDFKCommand.RegisterCommandName: String;
+begin
+  Result:='K';
+end;
+
+{ TPDFk_Command }
+
+class function TPDFk_Command.RegisterCommandName: String;
+begin
+  Result:='k';
+end;
+
+{ TPDFGCommand }
+
+function TPDFGCommand.GetColor: TPDFColor;
+begin
+  Result:=Default(TPDFColor);
+  Result[0]:=Gray;
+end;
+
+class function TPDFGCommand.CommandType: TPDFCommandType;
+begin
+  Result:=cmtColor;
+end;
+
+class function TPDFGCommand.RegisterCommandName: String;
+begin
+  Result:='G';
+end;
+
+function TPDFGCommand.ColorSpace: TPDFColorSpace;
+begin
+  Result:=csDeviceGray;
+end;
+
+{ ----------------------------------------------------------------------
+  Drawing commands
+  ----------------------------------------------------------------------}
+
+
+{ TPDFm_command }
+
+class function TPDFm_command.RegisterCommandName: String;
+begin
+  Result:='m'
+end;
+
+function TPDFm_command.PathSegment: TPDFPathSegment;
+begin
+  Result:=Default(TPDFPathSegment);
+  Result.SegmentType:=stStart;
+  Result.P1:=asPoint;
+end;
+
+{ TPDFl_command }
+
+class function TPDFl_command.RegisterCommandName: String;
+begin
+  Result:='l';
+end;
+
+{ TPDFy_command }
+
+class function TPDFy_command.RegisterCommandName: String;
+begin
+  Result:='y';
+end;
+
+{ TPDFv_command }
+
+class function TPDFv_command.RegisterCommandName: String;
+begin
+  Result:='v';
+end;
+
+{ TPDFc_command }
+
+class function TPDFc_command.RegisterCommandName: String;
+begin
+  Result:='c';
+end;
+
+{ TPDFh_command }
+
+class function TPDFh_command.RegisterCommandName: String;
+begin
+  Result:='h';
+end;
+
+{ TPDFTre_command }
+
+class function TPDFre_command.RegisterCommandName: String;
+begin
+  Result:='re';
+end;
+
+{ TPDFStrokeCommand }
+
+class function TPDFStrokeCommand.CommandType: TPDFCommandType;
+begin
+  Result:=cmtStroke;
+end;
+
+{ TPDFScommand }
+
+class function TPDFScommand.RegisterCommandName: String;
+begin
+  Result:='S';
+end;
+
+class function TPDFScommand.StrokeOptions: TPDFStrokeOptions;
+begin
+  Result:=[soStroke]
+end;
+
+{ TPDFs_command }
+
+class function TPDFs_command.RegisterCommandName: String;
+begin
+  Result:='s';
+end;
+
+class function TPDFs_command.StrokeOptions: TPDFStrokeOptions;
+begin
+  Result:=[soClose,soStroke]
+end;
+
+{ TPDFf_command }
+
+class function TPDFf_command.RegisterCommandName: String;
+begin
+  Result:='f';
+end;
+
+class function TPDFf_command.StrokeOptions: TPDFStrokeOptions;
+begin
+  Result:=[soFill,soNonZeroWinding];
+end;
+
+{ TPDFFcommand }
+
+class function TPDFFcommand.RegisterCommandName: String;
+begin
+  Result:='F';
+end;
+
+class function TPDFFcommand.StrokeOptions: TPDFStrokeOptions;
+begin
+  Result:=[soFill,soNonZeroWinding];
+end;
+
+{ TPDFfAsterisk_command }
+
+class function TPDFfAsterisk_command.RegisterCommandName: String;
+begin
+  Result:='f*';
+end;
+
+class function TPDFfAsterisk_command.StrokeOptions: TPDFStrokeOptions;
+begin
+  Result:=[soFill,soEvenOdd];
+end;
+
+{ TPDFBcommand }
+
+class function TPDFBcommand.RegisterCommandName: String;
+begin
+  Result:='B';
+end;
+
+class function TPDFBcommand.StrokeOptions: TPDFStrokeOptions;
+begin
+  Result:=[soStroke,soFill,soNonZeroWinding];
+end;
+
+{ TPDFBAsteriskcommand }
+
+class function TPDFBAsteriskcommand.RegisterCommandName: String;
+begin
+  Result:='B*';
+end;
+
+class function TPDFBAsteriskcommand.StrokeOptions: TPDFStrokeOptions;
+begin
+  Result:=[soStroke,soFill,soEvenOdd];
+end;
+
+{ TPDFb_command }
+
+class function TPDFb_command.RegisterCommandName: String;
+begin
+  Result:='b';
+end;
+
+class function TPDFb_command.StrokeOptions: TPDFStrokeOptions;
+begin
+  Result:=[soClose,soStroke,soFill,soNonZeroWinding];
+end;
+
+{ TPDFbAsterisk_command }
+
+class function TPDFbAsterisk_command.RegisterCommandName: String;
+begin
+  Result:='b*';
+end;
+
+class function TPDFbAsterisk_command.StrokeOptions: TPDFStrokeOptions;
+begin
+  Result:=[soStroke,soFill,soEvenOdd];
+end;
+
+{ TPDFn_command }
+
+class function TPDFn_command.RegisterCommandName: String;
+begin
+  Result:='n';
+end;
+
+class function TPDFn_command.StrokeOptions: TPDFStrokeOptions;
+begin
+  Result:=[soClose];
+end;
+
+{ TPDFTj_Command }
+
+class function TPDFTj_Command.RegisterCommandName: String;
+begin
+  Result:='Tj';
+end;
+
+function TPDFTj_Command.GetFullText: RawByteString;
+begin
+  Result:='';
+  if Length(Self.Tokens)>0 then
+    try
+      Result:=Tokens[0].AsString;
+    except
+      on E : exception do
+        begin
+        Writeln('Exception ',E.ClassName,'getting text for token: "',E.Message,'". Token data :',GetDescription);
+        Raise;
+        end;
+
+    end;
+end;
+
+{ TPDFTfCommand }
+
+function TPDFTf_Command.GetFontName: String;
+begin
+  Result:='';
+  If (Length(Tokens)>0) then
+    if Tokens[0].IsString then
+      Result:=Tokens[0].AsString
+    else if Tokens[0].IsName then
+      Result:=Tokens[0].AsName;
+end;
+
+function TPDFTf_Command.GetFontSize: Integer;
+
+begin
+  Result:=0;
+  If (Length(Tokens)>1) and Tokens[1].IsInteger then
+    Result:=Tokens[1].AsInteger
+end;
+
+class function TPDFTf_Command.RegisterCommandName: String;
+begin
+  Result:='Tf';
+end;
+
+{ TPDFTdCommand }
+
+class function TPDFTDCommand.CommandType: TPDFCommandType;
+begin
+  Result:=cmtTextState;
+end;
+
+class function TPDFTDCommand.RegisterCommandName: String;
+begin
+  Result:='TD';
+end;
+
+{ TPDFTm_Command }
+
+
+class function TPDFTm_Command.CommandType: TPDFCommandType;
+begin
+  Result:=cmtTextState;
+end;
+
+class function TPDFTm_Command.RegisterCommandName: String;
+begin
+  Result:='Tm';
+end;
+
+{ TPDFTAsterixCommand }
+
+class function TPDFTAsterixCommand.CommandType: TPDFCommandType;
+begin
+  Result:=cmtTextState;
+end;
+
+class function TPDFTAsterixCommand.RegisterCommandName: String;
+begin
+  Result:='T*';
+end;
+
+{ TPDFTc_Command }
+
+class function TPDFTc_Command.CommandType: TPDFCommandType;
+begin
+  Result:=cmtTextState;
+end;
+
+class function TPDFTc_Command.RegisterCommandName: String;
+begin
+  Result:='Tc';
+end;
+
+{ TPDFTw_Command }
+
+class function TPDFTw_Command.CommandType: TPDFCommandType;
+begin
+  Result:=cmtTextState;
+end;
+
+class function TPDFTw_Command.RegisterCommandName: String;
+begin
+  Result:='Tw';
+end;
+
+{ TPDFTz_Command }
+
+class function TPDFTz_Command.CommandType: TPDFCommandType;
+begin
+  Result:=cmtTextState;
+end;
+
+class function TPDFTz_Command.RegisterCommandName: String;
+begin
+  Result:='Tz';
+end;
+
+{ TPDFTLCommand }
+
+class function TPDFTLCommand.CommandType: TPDFCommandType;
+begin
+  Result:=cmtTextState;
+end;
+
+class function TPDFTLCommand.RegisterCommandName: String;
+begin
+  Result:='TL';
+end;
+
+{ TPDFTrCommand }
+
+class function TPDFTr_Command.CommandType: TPDFCommandType;
+begin
+  Result:=cmtTextState;
+end;
+
+class function TPDFTr_Command.RegisterCommandName: String;
+begin
+  Result:='Tr';
+end;
+
+function TPDFTr_Command.RenderMode: TPDFTextRenderMode;
+begin
+  Case Value of
+    0 : Result:=[trmFill];
+    1 : Result:=[trmStroke];
+    2 : Result:=[trmFill,trmStroke];
+    3 : Result:=[];
+    4 : Result:=[trmFill,trmAddToClippingPath];
+    5 : Result:=[trmStroke,trmAddToClippingPath];
+    6 : Result:=[trmFill,trmStroke,trmAddToClippingPath];
+    7 : Result:=[trmAddToClippingPath];
+  else
+    Result:=[trmFill];
+  end;
+end;
+
+{ TPDFTsCommand }
+
+class function TPDFTs_Command.CommandType: TPDFCommandType;
+begin
+  Result:=cmtTextState;
+end;
+
+class function TPDFTs_Command.RegisterCommandName: String;
+begin
+  Result:='Ts';
+end;
+
+{ TPDFcm_Command }
+
+class function TPDFcm_Command.RegisterCommandName: String;
+begin
+  Result:='cm';
+end;
+
+class function TPDFcm_Command.CommandType: TPDFCommandType;
+begin
+  Result:=cmtGraphicState;
+end;
+
+{ TPDFTJCommand }
+
+class function TPDFTJCommand.RegisterCommandName: String;
+begin
+  Result:='TJ';
+end;
+
+function TPDFTJCommand.GetFullText(aUnicodeMap: TPDFCMap): RawByteString;
+Var
+  i : integer;
+
+begin
+  if aUnicodeMap=Nil then
+    Exit(GetFullText());
+  Result:='';
+  if Length(Tokens)>=2 then
+    For I:=1 to Length(Tokens)-2 do
+      case Tokens[I].TokenType of
+      ptString,ptHexString:
+        Result:=Result+aUnicodeMap.InterPret(Tokens[I].TokenData);
+      ptNumber:
+        if Abs(Tokens[i].AsDouble)>PDFTextArraySpaceTreshold then
+          Result:=Result+' ';
+      else
+        Raise EConvertError.Create('Unexpected char');
+      end;
+end;
+
+function TPDFTJCommand.GetFullText: RawByteString;
+
+Var
+  i : integer;
+
+begin
+  Result:='';
+  if Length(Tokens)>=2 then
+    For I:=1 to Length(Tokens)-2 do
+      begin
+      if Tokens[I].TokenType=ptString then
+        Result:=Result+Tokens[I].TokenData
+      else if Tokens[i].IsNumber then
+        begin
+        if Abs(Tokens[i].AsDouble)>PDFTextArraySpaceTreshold then
+          Result:=Result+' '
+        end
+      else if Tokens[I].TokenType=ptHexString then
+        Result:='' // Tokens[I].AsHexInteger
+      else
+        Raise EConvertError.Create('Unexpected char');
+      end;
+end;
+
+{ TPDFETCommand }
+
+class function TPDFETCommand.RegisterCommandName: String;
+begin
+  Result:='ET';
+end;
+
+{ TPDFEMCCommand }
+
+class function TPDFEMCCommand.RegisterCommandName: String;
+begin
+  Result:='EMC';
+end;
+
+{ TPDFMPCommand }
+
+class function TPDFMPCommand.RegisterCommandName: String;
+begin
+  Result:='MP';
+end;
+
+{ TPDFDPCommand }
+
+class function TPDFDPCommand.RegisterCommandName: String;
+begin
+  Result:='DP';
+end;
+
+
+{ TPDFBTCommand }
+
+class function TPDFBTCommand.RegisterCommandName: String;
+begin
+  Result:='BT';
+end;
+
+{ TPDFBDCCommand }
+
+class function TPDFBDCCommand.RegisterCommandName: String;
+begin
+  Result:='BDC';
+end;
+
+{ TPDFBMCCommand }
+
+class function TPDFBMCCommand.RegisterCommandName: String;
+begin
+  Result:='BMC';
+end;
+
+{ TPDFBXCommand }
+
+class function TPDFBXCommand.RegisterCommandName: String;
+begin
+  Result:='BX';
+end;
+
+{ TPDFEXCommand }
+
+class function TPDFEXCommand.RegisterCommandName: String;
+begin
+  Result:='EX';
+end;
+
+{ TPDFcmCommand }
+
+class function TPDFcmCommand.RegisterCommandName: String;
+begin
+  Result:='cm';
+end;
+
+{ TPDFDCommand }
+
+class function TPDFDoCommand.RegisterCommandName: String;
+begin
+  Result:='Do';
+end;
+
+
+initialization
+  RegisterStandardCommands;
+end.
+