source/texttypes.h

   1 /* This file is part of Shapes.
   2  *
   3  * Shapes is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * any later version.
   7  *
   8  * Shapes is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with Shapes.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  * Copyright 2008 Henrik Tidefelt
  17  */
  18
  19 #pragma once
  20
  21 #include "Shapes_Ast_decls.h"
  22 #include "Shapes_Kernel_decls.h"
  23 #include "Shapes_Lang_decls.h"
  24 #include "Shapes_Lang_decls.h"
  25
  26 #include "ptrowner.h"
  27 #include "refcount.h"
  28 #include "environment.h"
  29 #include "statetypes.h"
  30 #include "elementarylength.h"
  31 #include "concretecolors.h"
  32 #include "elementarycoords.h"
  33 #include "fontmetrics.h"
  34
  35 #include <list>
  36 #include <iostream>
  37 #include <stack>
  38 #include <set>
  39 #include <vector>
  40
  41
  42 namespace Shapes
  43 {
  44         namespace Lang
  45         {
  46
  47                 class Font : public Lang::NoOperatorOverloadValue
  48                 {
  49                 private:
  50                         static std::map< RefCountPtr< const char >, RefCountPtr< SimplePDF::PDF_Object >, charRefPtrLess > theFontResourceMap_;
  51                         static std::map< RefCountPtr< const char >, RefCountPtr< const FontMetrics::BaseFont >, charRefPtrLess > theFontMetricsMap_;
  52                         static std::list< std::string > theFontMetricsSearchPath_;
  53
  54                 public:
  55                         static void push_backFontMetricsPath( const std::string & path );
  56                         static std::string searchGlyphList( );
  57                         static std::string searchCharacterEncoding( const char * encodingName );
  58                 private:
  59                         static std::string searchFontMetrics( RefCountPtr< const char > fontName );
  60                         RefCountPtr< const char > fontName_;
  61                         mutable RefCountPtr< SimplePDF::PDF_Object > resource_;
  62                         mutable RefCountPtr< const FontMetrics::BaseFont > metrics_;
  63                 public:
  64                         Font( const RefCountPtr< const char > fontName, RefCountPtr< SimplePDF::PDF_Object > & resource, RefCountPtr< const FontMetrics::BaseFont > metrics = NullPtr< const FontMetrics::BaseFont >( ) );
  65                         Font( const RefCountPtr< const char > builtInFontName );        // It is important that this is not used with fonts that aren't built in.
  66                         virtual ~Font( );
  67                         virtual void gcMark( Kernel::GCMarkedSet & marked );
  68                         const RefCountPtr< SimplePDF::PDF_Object > & resource( ) const;
  69                         RefCountPtr< const char > fontName( ) const;
  70                         RefCountPtr< const FontMetrics::BaseFont > metrics( ) const;
  71                         TYPEINFODECL;
  72                 };
  73
  74                 class TextRenderingMode : public Lang::NoOperatorOverloadValue
  75                 {
  76                 public:
  77                         typedef enum { FILL = 0, STROKE, FILLSTROKE, INVISIBLE, FILLCLIP, STROKECLIP, FILLSTROKECLIP, CLIP, UNDEFINED } ValueType;
  78                         ValueType mode_;
  79                         TextRenderingMode( const ValueType & mode );
  80                         TextRenderingMode( bool fill, bool stroke, bool clip );
  81                         virtual ~TextRenderingMode( );
  82                         virtual void gcMark( Kernel::GCMarkedSet & marked ){ };
  83                         TYPEINFODECL;
  84
  85                         static ValueType clipMode( ValueType mode );
  86                 };
  87
  88                 class TextOperation : public Lang::NoOperatorOverloadValue
  89                 {
  90                 public:
  91                         TextOperation();
  92                         virtual ~TextOperation( );
  93
  94                         virtual void shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf, bool clip = false ) const = 0;
  95                         virtual void measure( Lang::Transform2D * textMatrix, Lang::Transform2D * textLineMatrix, Concrete::Length * xmin, Concrete::Length * ymin, Concrete::Length * xmax, Concrete::Length * ymax ) const = 0;
  96
  97                         TYPEINFODECL;
  98                 };
  99
 100                 class KernedText : public Lang::TextOperation
 101                 {
 102                         RefCountPtr< const Kernel::TextState > textState_;
 103                         RefCountPtr< const Kernel::GraphicsState > metaState_;
 104
 105                         // The representation is a bit artificial to be efficient:      NullPtr objects in
 106                         // strings_ mark where kerning values are to be taken from kernings_.   Hence,
 107                         // The number of NullPtr objects in strings_ must match the length of kernings_.
 108                         std::list< RefCountPtr< const Lang::String > > strings_;
 109                         std::list< double > kernings_;
 110                         size_t maxLength_;
 111                 public:
 112                         KernedText( const RefCountPtr< const Kernel::TextState > & textState, const RefCountPtr< const Kernel::GraphicsState > & metaState );
 113                         KernedText( const RefCountPtr< const Kernel::TextState > & textState, const RefCountPtr< const Kernel::GraphicsState > & metaState, const RefCountPtr< const Lang::String > & str);
 114                         virtual ~KernedText( );
 115                         virtual Kernel::VariableHandle getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const;
 116                         void pushString( const RefCountPtr< const Lang::String > & str );
 117                         void pushKerning( double kerning );
 118
 119                         virtual void show( std::ostream & os ) const;
 120                         virtual void shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf, bool clip ) const;
 121                         virtual void measure( Lang::Transform2D * textMatrix, Lang::Transform2D * textLineMatrix, Concrete::Length * xmin, Concrete::Length * ymin, Concrete::Length * xmax, Concrete::Length * ymax ) const;
 122
 123                         void push( Lang::KernedText * dst ) const;
 124
 125                         virtual void gcMark( Kernel::GCMarkedSet & marked );
 126
 127                 private:
 128                         RefCountPtr< const Lang::SingleList > makeList( ) const;
 129                         static RefCountPtr< const Lang::String > oneMacRomanToUTF8( const char c );
 130                 };
 131
 132                 class TextNewline : public Lang::TextOperation
 133                 {
 134                         Concrete::Coords2D t_;
 135                 public:
 136                         TextNewline( const Concrete::Length tx, const Concrete::Length ty );
 137                         virtual ~TextNewline( );
 138
 139                         virtual void show( std::ostream & os ) const;
 140                         virtual void shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf, bool clip ) const;
 141                         virtual void measure( Lang::Transform2D * textMatrix, Lang::Transform2D * textLineMatrix, Concrete::Length * xmin, Concrete::Length * ymin, Concrete::Length * xmax, Concrete::Length * ymax ) const;
 142
 143                         virtual void gcMark( Kernel::GCMarkedSet & marked );
 144                 };
 145
 146                 class TextMoveto : public Lang::TextOperation
 147                 {
 148                         RefCountPtr< const Lang::Transform2D > tf_;
 149                 public:
 150                         TextMoveto( const RefCountPtr< const Lang::Transform2D > & tf );
 151                         virtual ~TextMoveto( );
 152
 153                         virtual void show( std::ostream & os ) const;
 154                         virtual void shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf, bool clip ) const;
 155                         virtual void measure( Lang::Transform2D * textMatrix, Lang::Transform2D * textLineMatrix, Concrete::Length * xmin, Concrete::Length * ymin, Concrete::Length * xmax, Concrete::Length * ymax ) const;
 156
 157                         virtual void gcMark( Kernel::GCMarkedSet & marked );
 158                 };
 159
 160         }
 161
 162         namespace Lang
 163         {
 164
 165                 class CharacterSpacingBinding : public DynamicBindings
 166                 {
 167                         const Ast::DynamicBindingExpression * bindingExpr_;
 168                         Concrete::Length spacing_;
 169                         bool isRelative_;
 170                         const char * id_;
 171                 public:
 172                         CharacterSpacingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Concrete::Length spacing );
 173                         CharacterSpacingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const double r );
 174                         virtual ~CharacterSpacingBinding( );
 175                         virtual void bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const;
 176                         virtual void show( std::ostream & os ) const;
 177                         virtual void gcMark( Kernel::GCMarkedSet & marked );
 178                 };
 179
 180                 class WordSpacingBinding : public DynamicBindings
 181                 {
 182                         const Ast::DynamicBindingExpression * bindingExpr_;
 183                         Concrete::Length spacing_;
 184                         bool isRelative_;
 185                         const char * id_;
 186                 public:
 187                         WordSpacingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Concrete::Length spacing );
 188                         WordSpacingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const double r );
 189                         virtual ~WordSpacingBinding( );
 190                         virtual void bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const;
 191                         virtual void show( std::ostream & os ) const;
 192                         virtual void gcMark( Kernel::GCMarkedSet & marked );
 193                 };
 194
 195                 class HorizontalScalingBinding : public DynamicBindings
 196                 {
 197                         const Ast::DynamicBindingExpression * bindingExpr_;
 198                         double scaling_;
 199                         const char * id_;
 200                 public:
 201                         HorizontalScalingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const double scaling );
 202                         virtual ~HorizontalScalingBinding( );
 203                         virtual void bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const;
 204                         virtual void show( std::ostream & os ) const;
 205                         virtual void gcMark( Kernel::GCMarkedSet & marked );
 206                 };
 207
 208                 class LeadingBinding : public DynamicBindings
 209                 {
 210                         const Ast::DynamicBindingExpression * bindingExpr_;
 211                         Concrete::Length ty_;
 212                         bool isRelative_;
 213                         const char * id_;
 214                 public:
 215                         LeadingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Concrete::Length ty );
 216                         LeadingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const double r );
 217                         virtual ~LeadingBinding( );
 218                         virtual void bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const;
 219                         virtual void show( std::ostream & os ) const;
 220                         virtual void gcMark( Kernel::GCMarkedSet & marked );
 221                 };
 222
 223                 class FontBinding : public DynamicBindings
 224                 {
 225                         const Ast::DynamicBindingExpression * bindingExpr_;
 226                         RefCountPtr< const Lang::Font > font_;
 227                         const char * id_;
 228                 public:
 229                         FontBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const RefCountPtr< const Lang::Font > & font );
 230                         virtual ~FontBinding( );
 231                         virtual void bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const;
 232                         virtual void show( std::ostream & os ) const;
 233                         virtual void gcMark( Kernel::GCMarkedSet & marked );
 234                 };
 235
 236                 class TextSizeBinding : public DynamicBindings
 237                 {
 238                         const Ast::DynamicBindingExpression * bindingExpr_;
 239                         Concrete::Length size_;
 240                         const char * id_;
 241                 public:
 242                         TextSizeBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Concrete::Length size );
 243                         virtual ~TextSizeBinding( );
 244                         virtual void bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const;
 245                         virtual void show( std::ostream & os ) const;
 246                         virtual void gcMark( Kernel::GCMarkedSet & marked );
 247                 };
 248
 249                 class TextRenderingModeBinding : public DynamicBindings
 250                 {
 251                         const Ast::DynamicBindingExpression * bindingExpr_;
 252                         Lang::TextRenderingMode::ValueType mode_;
 253                         const char * id_;
 254                 public:
 255                         TextRenderingModeBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Lang::TextRenderingMode::ValueType mode );
 256                         virtual ~TextRenderingModeBinding( );
 257                         virtual void bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const;
 258                         virtual void show( std::ostream & os ) const;
 259                         virtual void gcMark( Kernel::GCMarkedSet & marked );
 260                 };
 261
 262                 class TextRiseBinding : public DynamicBindings
 263                 {
 264                         const Ast::DynamicBindingExpression * bindingExpr_;
 265                         Concrete::Length ty_;
 266                         bool isRelative_;
 267                         const char * id_;
 268                 public:
 269                         TextRiseBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Concrete::Length ty );
 270                         TextRiseBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const double r );
 271                         virtual ~TextRiseBinding( );
 272                         virtual void bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const;
 273                         virtual void show( std::ostream & os ) const;
 274                         virtual void gcMark( Kernel::GCMarkedSet & marked );
 275                 };
 276
 277                 class TextKnockoutBinding : public DynamicBindings
 278                 {
 279                         const Ast::DynamicBindingExpression * bindingExpr_;
 280                         bool knockout_;
 281                         const char * id_;
 282                 public:
 283                         TextKnockoutBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const bool knockout );
 284                         virtual ~TextKnockoutBinding( );
 285                         virtual void bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const;
 286                         virtual void show( std::ostream & os ) const;
 287                         virtual void gcMark( Kernel::GCMarkedSet & marked );
 288                 };
 289
 290         }
 291
 292         namespace Kernel
 293         {
 294
 295                 class CharacterSpacingDynamicVariableProperties : public Kernel::DynamicVariableProperties
 296                 {
 297                 public:
 298                         CharacterSpacingDynamicVariableProperties( const char * name );
 299                         virtual ~CharacterSpacingDynamicVariableProperties( );
 300                         virtual Kernel::VariableHandle fetch( const Kernel::PassedDyn & dyn ) const;
 301                         virtual void makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const;
 302                 };
 303
 304                 class WordSpacingDynamicVariableProperties : public Kernel::DynamicVariableProperties
 305                 {
 306                 public:
 307                         WordSpacingDynamicVariableProperties( const char * name );
 308                         virtual ~WordSpacingDynamicVariableProperties( );
 309                         virtual Kernel::VariableHandle fetch( const Kernel::PassedDyn & dyn ) const;
 310                         virtual void makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const;
 311                 };
 312
 313                 class HorizontalScalingDynamicVariableProperties : public Kernel::DynamicVariableProperties
 314                 {
 315                 public:
 316                         HorizontalScalingDynamicVariableProperties( const char * name );
 317                         virtual ~HorizontalScalingDynamicVariableProperties( );
 318                         virtual Kernel::VariableHandle fetch( const Kernel::PassedDyn & dyn ) const;
 319                         virtual void makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const;
 320                 };
 321
 322                 class LeadingDynamicVariableProperties : public Kernel::DynamicVariableProperties
 323                 {
 324                 public:
 325                         LeadingDynamicVariableProperties( const char * name );
 326                         virtual ~LeadingDynamicVariableProperties( );
 327                         virtual Kernel::VariableHandle fetch( const Kernel::PassedDyn & dyn ) const;
 328                         virtual void makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const;
 329                 };
 330
 331                 class FontDynamicVariableProperties : public Kernel::DynamicVariableProperties
 332                 {
 333                 public:
 334                         FontDynamicVariableProperties( const char * name );
 335                         virtual ~FontDynamicVariableProperties( );
 336                         virtual Kernel::VariableHandle fetch( const Kernel::PassedDyn & dyn ) const;
 337                         virtual void makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const;
 338                 };
 339
 340                 class TextSizeDynamicVariableProperties : public Kernel::DynamicVariableProperties
 341                 {
 342                 public:
 343                         TextSizeDynamicVariableProperties( const char * name );
 344                         virtual ~TextSizeDynamicVariableProperties( );
 345                         virtual Kernel::VariableHandle fetch( const Kernel::PassedDyn & dyn ) const;
 346                         virtual void makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const;
 347                 };
 348
 349                 class TextRenderingModeDynamicVariableProperties : public Kernel::DynamicVariableProperties
 350                 {
 351                 public:
 352                         TextRenderingModeDynamicVariableProperties( const char * name );
 353                         virtual ~TextRenderingModeDynamicVariableProperties( );
 354                         virtual Kernel::VariableHandle fetch( const Kernel::PassedDyn & dyn ) const;
 355                         virtual void makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const;
 356                 };
 357
 358                 class TextRiseDynamicVariableProperties : public Kernel::DynamicVariableProperties
 359                 {
 360                 public:
 361                         TextRiseDynamicVariableProperties( const char * name );
 362                         virtual ~TextRiseDynamicVariableProperties( );
 363                         virtual Kernel::VariableHandle fetch( const Kernel::PassedDyn & dyn ) const;
 364                         virtual void makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const;
 365                 };
 366
 367                 class TextKnockoutDynamicVariableProperties : public Kernel::DynamicVariableProperties
 368                 {
 369                 public:
 370                         TextKnockoutDynamicVariableProperties( const char * name );
 371                         virtual ~TextKnockoutDynamicVariableProperties( );
 372                         virtual Kernel::VariableHandle fetch( const Kernel::PassedDyn & dyn ) const;
 373                         virtual void makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const;
 374                 };
 375
 376                 class TextState
 377                 {
 378                 private:
 379                         static const char RELATIVE_LEADING = 0x01;
 380                         static const char RELATIVE_RISE = 0x02;
 381                         static const char RELATIVE_CHARACTER_SPACING = 0x04;
 382                         static const char RELATIVE_WORD_SPACING = 0x08;
 383                 public:
 384                         unsigned char relativeFlags_;
 385
 386                 public:
 387                         static const char KNOCKOUT_FLAG_BIT = 0x01;
 388                         static const char KNOCKOUT_UNDEFINED_BIT = 0x02;
 389                 public:
 390                         Concrete::Length characterSpacing_;                                                                                             // Use NaN for undefined.
 391                         Concrete::Length wordSpacing_;                                                                                                           // Use NaN for undefined.
 392                         double horizontalScaling_;                                                                                                                               // Use NaN for undefined.
 393                 private:
 394                         Concrete::Length leading_;                                                                                                                               // Use NaN for undefined.      Offtype in case leadingIsRelative_.
 395                         Concrete::Length rise_;                                                                                                                                         // Use NaN for undefined.       Offtype in case riseIsRelative_.
 396                 public:
 397                         RefCountPtr< const Lang::Font > font_;                                                                           // Use NullPtr for undefined.
 398                         Concrete::Length size_;                                                                                                                                         // Use NaN for undefined.
 399                         Lang::TextRenderingMode::ValueType mode_;                                                                       // Use UNDEFINED for undefined.
 400                         char knockout_;                                                                                                                                                                         // Set the bit KNOCKOUT_UNDEFINED for undefined.
 401                 public:
 402                         TextState( );
 403                         explicit TextState( const Kernel::TextState & orig );    // explicit, since reference counting shall be used in most cases
 404                         TextState( const Kernel::TextState & newValues, const Kernel::TextState & oldValues );
 405                         TextState( bool setDefaults );
 406                         ~TextState( );
 407
 408                         void setLeading( const Concrete::Length leading );
 409                         void setLeading( const double relativeLeading );
 410                         bool hasLeading( ) const;
 411                         inline bool leadingIsRelative( ) const;
 412                         Concrete::Length leadingConcrete( ) const;
 413                         RefCountPtr< const Lang::Value > leading( ) const;
 414
 415                         void setRise( const Concrete::Length rise );
 416                         void setRise( const double relativeRise );
 417                         bool hasRise( ) const;
 418                         bool riseIsRelative( ) const;
 419                         Concrete::Length riseConcrete( ) const;
 420                         RefCountPtr< const Lang::Value > rise( ) const;
 421
 422                         void setCharacterSpacing( const Concrete::Length spacing );
 423                         void setCharacterSpacing( const double relativeSpacing );
 424                         bool hasCharacterSpacing( ) const;
 425                         bool characterSpacingIsRelative( ) const;
 426                         Concrete::Length characterSpacingConcrete( ) const;
 427                         RefCountPtr< const Lang::Value > characterSpacing( ) const;
 428
 429                         void setWordSpacing( const Concrete::Length spacing );
 430                         void setWordSpacing( const double relativeSpacing );
 431                         bool hasWordSpacing( ) const;
 432                         bool wordSpacingIsRelative( ) const;
 433                         Concrete::Length wordSpacingConcrete( ) const;
 434                         RefCountPtr< const Lang::Value > wordSpacing( ) const;
 435
 436                         bool synchKnockout( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force = false );
 437                         bool synchAssertKnockout( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool clip, bool force = false );
 438
 439                         void print( std::ostream & os, const std::string & indentation ) const;
 440
 441                 private:
 442                         static std::map< bool, RefCountPtr< SimplePDF::PDF_Object > > knockoutNameMap_;
 443
 444                         bool synchCharacterSpacing( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force = false );
 445                         bool synchWordSpacing( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force = false );
 446                         bool synchHorizontalScaling( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force = false );
 447                         bool synchLeading( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force = false );
 448                         bool synchFontAndSize( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force = false );
 449                         bool synchMode( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool clip, bool force = false );
 450                         bool synchRise( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force = false );
 451
 452                         void assertKnockout( const Kernel::TextState * ref );
 453
 454                         bool synchButKnockout( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool clip, bool force = false );
 455
 456                 };
 457
 458         }
 459 }