?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updating the changelog in the VERSION file, and version_sync.
[shapes.git] / source / texttypes.cc
blobbce74797b03b33e2715a61df7d8e42c702505ef6
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 #include "Shapes_Helpers_decls.h"
20
21 #include "texttypes.h"
22 #include "dynamicenvironment.h"
23 #include "lighttypes.h"
24 #include "ast.h"
25 #include "astvar.h"
26 #include "isnan.h"
27 #include "globals.h"
28 #include "autoonoff.h"
29 #include "afmscanner.h"
30 #include "charconverters.h"
31 #include "constructorrepresentation.h"
32 #include "pagecontentstates.h"
33 #include "config.h"
34
35 #include <fstream>
36 #include <sys/types.h>
37 #include <sys/stat.h>
38
39 using namespace Shapes;
40
41 std::map< RefCountPtr< const char >, RefCountPtr< SimplePDF::PDF_Object >, charRefPtrLess > Lang::Font::theFontResourceMap_;
42 std::map< RefCountPtr< const char >, RefCountPtr< const FontMetrics::BaseFont >, charRefPtrLess > Lang::Font::theFontMetricsMap_;
43 std::list< std::string > Lang::Font::theFontMetricsSearchPath_;
44
45 void
46 Lang::Font::push_backFontMetricsPath( const std::string & path )
47 {
48 if( path.empty( ) ||
49 path[ path.size( ) - 1 ] == '/' )
50 {
51 theFontMetricsSearchPath_.push_back( path );
52 }
53 else
54 {
55 theFontMetricsSearchPath_.push_back( path + "/" );
56 }
57 }
58
59 std::string
60 Lang::Font::searchGlyphList( )
61 {
62 std::string res;
63
64 if( theFontMetricsSearchPath_.empty( ) )
65 {
66 throw Exceptions::ExternalError( strrefdup( "The font metrics path was not set up (needed for the glyph list). Consider defining the environment variable SHAPESFONTMETRICS." ) );
67 }
68
69 typedef typeof theFontMetricsSearchPath_ ListType;
70 for( ListType::const_iterator i = theFontMetricsSearchPath_.begin( ); i != theFontMetricsSearchPath_.end( ); ++i )
71 {
72 res = *i + "glyphlist.txt";
73 struct stat theStatDummy;
74 if( stat( res.c_str( ), & theStatDummy ) == 0 )
75 {
76 return res;
77 }
78 }
79 throw Exceptions::MiscellaneousRequirement( "A font operation required the glyph list, but it was not found. It should be named \"glyphlist.txt\" and reside in a directory on the font metrics path. Please refer to your environment variable SHAPESFONTMETRICS." );
80 }
81
82 std::string
83 Lang::Font::searchFontMetrics( RefCountPtr< const char > fontName )
84 {
85 std::string res;
86
87 if( strlen( fontName.getPtr( ) ) == 0 )
88 {
89 throw Exceptions::InternalError( strrefdup( "Lang::Font::searchFontMetrics called with empty argument." ) );
90 }
91
92 if( *fontName.getPtr( ) == '/' )
93 {
94 throw Exceptions::InternalError( "The font name cannot begin with \"/\", as if is was an absolute path to something." );
95 }
96
97 if( theFontMetricsSearchPath_.empty( ) )
98 {
99 throw Exceptions::ExternalError( strrefdup( "The font metrics path was not set up. Consider defining the environment variable SHAPESFONTMETRICS." ) );
100 }
101
102 typedef typeof theFontMetricsSearchPath_ ListType;
103 for( ListType::const_iterator i = theFontMetricsSearchPath_.begin( ); i != theFontMetricsSearchPath_.end( ); ++i )
104 {
105 res = *i + fontName.getPtr( ) + ".afm";
106 struct stat theStatDummy;
107 if( stat( res.c_str( ), & theStatDummy ) == 0 )
108 {
109 return res;
110 }
111 }
112 throw Exceptions::MissingFontMetrics( fontName, & theFontMetricsSearchPath_ );
113 }
114
115 std::string
116 Lang::Font::searchCharacterEncoding( const char * encodingName )
117 {
118 std::string res;
119
120 if( theFontMetricsSearchPath_.empty( ) )
121 {
122 throw Exceptions::ExternalError( strrefdup( "The font metrics path was not set up. Consider defining the environment variable SHAPESFONTMETRICS." ) );
123 }
124
125 typedef typeof theFontMetricsSearchPath_ ListType;
126 for( ListType::const_iterator i = theFontMetricsSearchPath_.begin( ); i != theFontMetricsSearchPath_.end( ); ++i )
127 {
128 res = *i + encodingName + ".enc";
129 struct stat theStatDummy;
130 if( stat( res.c_str( ), & theStatDummy ) == 0 )
131 {
132 return res;
133 }
134 }
135 std::ostringstream msg;
136 msg << "A font operation required a character encoding file for " << encodingName << ", but it was not found. It should be named \"" << encodingName << ".enc\" and reside in a directory on the font metrics path. Please refer to your environment variable SHAPESFONTMETRICS." ;
137 throw Exceptions::MiscellaneousRequirement( strrefdup( msg ) );
138 }
139
140
141 Lang::Font::Font( const RefCountPtr< const char > fontName, RefCountPtr< SimplePDF::PDF_Object > & resource, RefCountPtr< const FontMetrics::BaseFont > metrics )
142 : fontName_( fontName ), resource_( resource ), metrics_( metrics )
143 {
144 // If this font has been instantiated before, it is reused.
145 {
146 typedef typeof theFontResourceMap_ MapType;
147 MapType::const_iterator i = theFontResourceMap_.find( fontName_ );
148 if( i != theFontResourceMap_.end( ) )
149 {
150 resource_ = i->second;
151 }
152 else
153 {
154 theFontResourceMap_.insert( MapType::value_type( fontName_, resource_ ) );
155 }
156 }
157 {
158 typedef typeof theFontMetricsMap_ MapType;
159 MapType::const_iterator i = theFontMetricsMap_.find( fontName_ );
160 if( i != theFontMetricsMap_.end( ) )
161 {
162 metrics_ = i->second;
163 }
164 else if( metrics_ != NullPtr< const FontMetrics::BaseFont >( ) )
165 {
166 theFontMetricsMap_.insert( MapType::value_type( fontName_, metrics_ ) );
167 }
168 }
169 }
170
171 // Note that we must not initialize name_ with builtinFontMap_[ fontConst ] here, since builtinFontMap_ may not be
172 // initialized when this constructor is invoked from globals.cc.
173 Lang::Font::Font( const RefCountPtr< const char > fontName )
174 : fontName_( fontName ), resource_( NullPtr< SimplePDF::PDF_Object >( ) ), metrics_( NullPtr< const FontMetrics::BaseFont >( ) )
175 { }
176
177 Lang::Font::~Font( )
178 { }
179
180 const RefCountPtr< SimplePDF::PDF_Object > &
181 Lang::Font::resource( ) const
182 {
183 if( resource_ != NullPtr< SimplePDF::PDF_Object >( ) )
184 {
185 return resource_;
186 }
187
188 typedef typeof theFontResourceMap_ MapType;
189
190 {
191 MapType::const_iterator i = theFontResourceMap_.find( fontName_ );
192 if( i != theFontResourceMap_.end( ) )
193 {
194 resource_ = i->second;
195 return resource_;
196 }
197 }
198
199 {
200 RefCountPtr< SimplePDF::PDF_Dictionary > dic;
201 resource_ = SimplePDF::indirect( dic, & Kernel::theIndirectObjectCount );
202 (*dic)[ "Type" ] = SimplePDF::newName( "Font" );
203 (*dic)[ "Subtype" ] = SimplePDF::newName( "Type1" );
204 (*dic)[ "Encoding" ] = SimplePDF::newName( "MacRomanEncoding" );
205 (*dic)[ "BaseFont" ] = SimplePDF::newName( fontName_.getPtr( ) ); // Here, it is crucial that this is really a build-in font!
206 }
207 return resource_;
208 }
209
210 RefCountPtr< const char >
211 Lang::Font::fontName( ) const
212 {
213 return fontName_;
214 }
215
216 RefCountPtr< const FontMetrics::BaseFont >
217 Lang::Font::metrics( ) const
218 {
219 if( metrics_ != NullPtr< const FontMetrics::BaseFont >( ) )
220 {
221 return metrics_;
222 }
223
224 // Otherwise, we hope that we can find an Adobe Font Metrics file.
225 std::string filename = searchFontMetrics( fontName_ );
226 std::ifstream afmFile( filename.c_str( ) );
227 if( ! afmFile.is_open( ) )
228 {
229 std::ostringstream oss;
230 oss << "File has been located but couldn't be opened: " << filename ;
231 throw Exceptions::ExternalError( strrefdup( oss ) );
232 }
233
234 // I fiddle a little with the consts here...
235 FontMetrics::BaseFont * newMetrics = new FontMetrics::BaseFont;
236 metrics_ = RefCountPtr< const FontMetrics::BaseFont >( newMetrics );
237
238 AfmScanner scanner( newMetrics, & afmFile );
239 scanner.setTellQue( Interaction::fontMetricMessages ); // We want to know about things that are not recognized and this ignored.
240 if( Interaction::fontMetricDebug )
241 {
242 scanner.set_debug( 1 );
243 }
244 try
245 {
246 int status = scanner.yylex( );
247 if( status != 0 )
248 {
249 std::ostringstream oss;
250 oss << "Font metrics parser returned with non-zero status: " << status ;
251 throw Exceptions::InternalError( strrefdup( oss ) );
252 }
253 }
254 catch( const char * ball )
255 {
256 std::ostringstream oss;
257 oss << "Font metrics parser failed with message: " << ball ;
258 throw Exceptions::InternalError( strrefdup( oss ) );
259 }
260 catch( const RefCountPtr< const char > ball )
261 {
262 std::ostringstream oss;
263 oss << "Font metrics parser failed with message: " << ball ;
264 throw Exceptions::InternalError( strrefdup( oss ) );
265 }
266
267 return metrics_;
268 }
269
270 void
271 Lang::Font::gcMark( Kernel::GCMarkedSet & marked )
272 { }
273
274 RefCountPtr< const Lang::Class > Lang::Font::TypeID( new Lang::SystemFinalClass( strrefdup( "Font" ) ) );
275 TYPEINFOIMPL( Font );
276
277 Lang::TextOperation::TextOperation( )
278 { }
279
280 Lang::TextOperation::~TextOperation( )
281 { }
282
283 RefCountPtr< const Lang::Class > Lang::TextOperation::TypeID( new Lang::SystemFinalClass( strrefdup( "TextOperation" ) ) );
284 TYPEINFOIMPL( TextOperation );
285
286
287 Lang::KernedText::KernedText( const RefCountPtr< const Kernel::TextState > & textState, const RefCountPtr< const Kernel::GraphicsState > & metaState )
288 : textState_( textState ), metaState_( metaState ), maxLength_( 0 )
289 { }
290
291 Lang::KernedText::KernedText( const RefCountPtr< const Kernel::TextState > & textState, const RefCountPtr< const Kernel::GraphicsState > & metaState, const RefCountPtr< const Lang::String > & str)
292 : textState_( textState ), metaState_( metaState ), maxLength_( 0 )
293 {
294 pushString( str );
295 }
296
297 Lang::KernedText::~KernedText( )
298 { }
299
300 Kernel::VariableHandle
301 Lang::KernedText::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
302 {
303 if( strcmp( fieldID, "list" ) == 0 )
304 {
305 return Kernel::VariableHandle( new Kernel::Variable( makeList( ) ) );
306 }
307 throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
308 }
309
310 RefCountPtr< const Lang::SingleList >
311 Lang::KernedText::makeList( ) const
312 {
313 /* The list is first computed in a bidirectional list, and then we construct the stateless cons list.
314 */
315
316 /* I'm lazy today, so i use a cons pair to group the horizontal step with the glyph. The better solution
317 * would be to use a structure with nicely named fields...
318 */
319
320 std::list< RefCountPtr< const Lang::Value > > revlist;
321
322 iconv_t converter = Helpers::requireUTF8ToMacRomanConverter( );
323
324 RefCountPtr< FontMetrics::WritingDirectionMetrics > horizontalMetrics = textState_->font_->metrics( )->horizontalMetrics_;
325 if( horizontalMetrics == NullPtr< FontMetrics::WritingDirectionMetrics >( ) )
326 {
327 throw Exceptions::FontMetricsError( textState_->font_->fontName( ), strrefdup( "No horizontal metrics defined." ) );
328 }
329 const FontMetrics::CharacterMetrics * defaultCharMetrics = horizontalMetrics->charData_[ 0 ];
330
331 Concrete::Length ySize = textState_->size_;
332 Concrete::Length xSize = ySize * textState_->horizontalScaling_;
333 Concrete::Length characterTrackKern = textState_->horizontalScaling_ * textState_->characterSpacing_;
334 Concrete::Length wordTrackKern = textState_->horizontalScaling_ * textState_->wordSpacing_;
335
336 Concrete::Length xpos = 0;
337
338 size_t bufSize = maxLength_ + 1; // This will be enough if MacRoman coding is used, since this encoding uses only one byte per character.
339 // The extra one byte will be used to terminate the string.
340 char * buf = new char[ bufSize ];
341 DeleteOnExit< char > bufDeleter( buf );
342
343 typedef typeof strings_ ListType;
344 std::list< double >::const_iterator ki = kernings_.begin( );
345 for( ListType::const_iterator i = strings_.begin( ); i != strings_.end( ); ++i )
346 {
347 if( *i != NullPtr< const Lang::String >( ) )
348 {
349 const char * inbuf = (*i)->val_.getPtr( );
350 char * outbuf = buf;
351 size_t inbytesleft = strlen( inbuf );
352 size_t outbytesleft = bufSize - 1;
353 // The ICONV_CAST macro is defined in config.h.
354 size_t count = iconv( converter,
355 ICONV_CAST( & inbuf ), & inbytesleft,
356 & outbuf, & outbytesleft );
357 if( count == (size_t)(-1) )
358 {
359 if( errno == EILSEQ )
360 {
361 throw Exceptions::MiscellaneousRequirement( "It is suspected that one of the UFT-8 characters used in showed text has no MacRoman representation." );
362 }
363 else if( errno == EINVAL )
364 {
365 throw Exceptions::MiscellaneousRequirement( "It is suspected that showed text ended with an incomplete multibyte character." );
366 }
367 else if( errno == E2BIG )
368 {
369 throw Exceptions::InternalError( "The buffer allocated for UTF-8 to MacRoman conversion was too small." );
370 }
371 else
372 {
373 std::ostringstream msg;
374 msg << "iconv failed with an unrecognized error code: " << errno ;
375 throw Exceptions::InternalError( strrefdup( msg ) );
376 }
377 }
378 *outbuf = '\0';
379 for( const char * src = buf; *src != '\0'; ++src )
380 {
381 switch( *src )
382 {
383 case ' ':
384 {
385 // Observe textState_->wordSpacing_
386 const FontMetrics::CharacterMetrics * charMetrics = horizontalMetrics->charByCode( (unsigned char)( 32 ) );
387 xpos += xSize * charMetrics->horizontalCharWidthX_;
388 xpos += characterTrackKern;
389 xpos += wordTrackKern;
390 }
391 break;
392 case '\n':
393 {
394 throw Exceptions::MiscellaneousRequirement( "Newlines cannot be represented in the pos-character list." );
395 }
396 break;
397 default:
398 {
399 // Observe textState_->characterSpacing_
400 unsigned char currentChar = *reinterpret_cast< const unsigned char * >( src );
401 const FontMetrics::CharacterMetrics * charMetrics = horizontalMetrics->charByCode( currentChar );
402 if( Computation::fontMetricGuessIsError && charMetrics == defaultCharMetrics )
403 {
404 std::ostringstream msg;
405 msg << "Character at offset " << src - buf << " in \"" << buf << "\" was not found in font metrics (and according to your options, guessing is not OK)." ;
406 throw Exceptions::FontMetricsError( textState_->font_->fontName( ), strrefdup( msg ) );
407 }
408 revlist.push_back( RefCountPtr< const Lang::Value >
409 ( new Lang::ConsPair
410 ( Helpers::newValHandle( new Lang::Length( xpos ) ),
411 Helpers::newValHandle( new Lang::KernedText( textState_, metaState_, oneMacRomanToUTF8( *src ) ) ) ) ) );
412 /* Although not as efficient, it becomes easier to use the list if the distance is
413 * measured from the start of the text rather than from the previous character.
414 */
415 // xpos = 0;
416 xpos += xSize * charMetrics->horizontalCharWidthX_;
417 xpos += characterTrackKern;
418 }
419 }
420 }
421 }
422 else
423 {
424 if( ki == kernings_.end( ) )
425 {
426 throw Exceptions::InternalError( "Short of kerning values in KernedText::measure." );
427 }
428 xpos -= xSize * *ki;
429 ++ki;
430 }
431 }
432 if( ki != kernings_.end( ) )
433 {
434 throw Exceptions::InternalError( "Too many kerning values in KernedText::writePDFVectorTo." );
435 }
436
437 RefCountPtr< const Lang::SingleList > res = Lang::THE_CONS_NULL;
438 while( ! revlist.empty( ) )
439 {
440 res = RefCountPtr< const Lang::SingleList >( new Lang::SingleListPair( Kernel::VariableHandle( new Kernel::Variable( revlist.back( ) ) ),
441 res ) );
442 revlist.pop_back( );
443 }
444 return res;
445 }
446
447 RefCountPtr< const Lang::String >
448 Lang::KernedText::oneMacRomanToUTF8( const char c )
449 {
450 iconv_t converter = Helpers::requireMacRomanToUTF8Converter( );
451
452 const size_t BUF_SIZE = 9;
453 char buf[ BUF_SIZE ];
454
455 static char * charbuf = new char[ 2 ]; // This is a one time leak.
456 charbuf[0] = c;
457 charbuf[1] = '\0';
458
459 char * outbuf = buf;
460 const char * inbuf = charbuf;
461 size_t inbytesleft = 1;
462 size_t outbytesleft = BUF_SIZE - 1;
463 // The ICONV_CAST macro is defined in config.h.
464 size_t count = iconv( converter,
465 ICONV_CAST( & inbuf ), & inbytesleft,
466 & outbuf, & outbytesleft );
467 if( count == (size_t)(-1) )
468 {
469 throw Exceptions::ExternalError( "Conversion of one MacRoman character to UTF-8 failed." );
470 }
471 *outbuf = '\0';
472 return RefCountPtr< const Lang::String >( new Lang::String( strrefdup( buf ) ) );
473 }
474
475 void
476 Lang::KernedText::pushString( const RefCountPtr< const Lang::String > & str )
477 {
478 strings_.push_back( str );
479 maxLength_ = std::max( maxLength_, strlen( str->val_.getPtr( ) ) );
480 }
481
482 void
483 Lang::KernedText::pushKerning( double kerning )
484 {
485 strings_.push_back( NullPtr< const Lang::String >( ) );
486 kernings_.push_back( kerning );
487 }
488
489 void
490 Lang::KernedText::show( std::ostream & os ) const
491 {
492 typedef typeof strings_ ListType;
493 std::list< double >::const_iterator ki = kernings_.begin( );
494 for( ListType::const_iterator i = strings_.begin( ); i != strings_.end( ); ++i )
495 {
496 if( *i != NullPtr< const Lang::String >( ) )
497 {
498 os << "(" << (*i)->val_.getPtr( ) << ")" ;
499 }
500 else
501 {
502 if( ki == kernings_.end( ) )
503 {
504 throw Exceptions::InternalError( "Short of kerning values in KernedText::show." );
505 }
506 os << *ki ;
507 ++ki;
508 }
509 }
510 if( ki != kernings_.end( ) )
511 {
512 throw Exceptions::InternalError( "Too many kerning values in KernedText::show." );
513 }
514 }
515
516
517 void
518 Lang::KernedText::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf, bool clip ) const
519 {
520 iconv_t converter = Helpers::requireUTF8ToMacRomanConverter( );
521
522 pdfState->text_.synchAssertKnockout( os, textState_.getPtr( ), pdfState->resources_.getPtr( ), clip );
523 switch( textState_->mode_ )
524 {
525 case Lang::TextRenderingMode::FILL:
526 case Lang::TextRenderingMode::FILLCLIP:
527 pdfState->graphics_.synchForNonStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
528 break;
529 case Lang::TextRenderingMode::STROKE:
530 case Lang::TextRenderingMode::STROKECLIP:
531 pdfState->graphics_.synchForStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
532 break;
533 case Lang::TextRenderingMode::FILLSTROKE:
534 case Lang::TextRenderingMode::FILLSTROKECLIP:
535 pdfState->graphics_.synchForStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
536 pdfState->graphics_.synchForNonStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
537 break;
538 case Lang::TextRenderingMode::INVISIBLE:
539 case Lang::TextRenderingMode::CLIP:
540 break;
541 case Lang::TextRenderingMode::UNDEFINED:
542 pdfState->graphics_.synchForStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
543 pdfState->graphics_.synchForNonStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
544 default:
545 throw Exceptions::InternalError( "KernedText::writePDFVectorTo: Text rendering mode out of range." );
546 }
547
548
549 size_t bufSize = maxLength_ + 1; // This will be enough if MacRoman coding is used, since this encoding uses only one byte per character.
550 // The extra one byte will be used to terminate the string.
551 char * buf = new char[ bufSize ];
552 DeleteOnExit< char > bufDeleter( buf );
553
554 typedef typeof strings_ ListType;
555 std::list< double >::const_iterator ki = kernings_.begin( );
556 os << "[ " ;
557 for( ListType::const_iterator i = strings_.begin( ); i != strings_.end( ); ++i )
558 {
559 if( *i != NullPtr< const Lang::String >( ) )
560 {
561 const char * inbuf = (*i)->val_.getPtr( );
562 char * outbuf = buf;
563 size_t inbytesleft = strlen( inbuf );
564 size_t outbytesleft = bufSize - 1;
565 // The ICONV_CAST macro is defined in config.h.
566 size_t count = iconv( converter,
567 ICONV_CAST( & inbuf ), & inbytesleft,
568 & outbuf, & outbytesleft );
569 if( count == (size_t)(-1) )
570 {
571 if( errno == EILSEQ )
572 {
573 throw Exceptions::MiscellaneousRequirement( "It is suspected that one of the UFT-8 characters used in showed text has no MacRoman representation." );
574 }
575 else if( errno == EINVAL )
576 {
577 throw Exceptions::MiscellaneousRequirement( "It is suspected that showed text ended with an incomplete multibyte character." );
578 }
579 else if( errno == E2BIG )
580 {
581 throw Exceptions::InternalError( "The buffer allocated for UTF-8 to MacRoman conversion was too small." );
582 }
583 else
584 {
585 std::ostringstream msg;
586 msg << "iconv failed with an unrecognized error code: " << errno ;
587 throw Exceptions::InternalError( strrefdup( msg ) );
588 }
589 }
590 *outbuf = '\0';
591 os << "(" ;
592 for( const char * src = buf; *src != '\0'; ++src )
593 {
594 switch( *src )
595 {
596 case '(':
597 os << "\\(" ;
598 break;
599 case ')':
600 os << "\\)" ;
601 break;
602 case '\\':
603 os << "\\\\" ;
604 break;
605 case '\n':
606 os << ")] TJ T* [(" ;
607 break;
608 default:
609 os << *src ;
610 }
611 }
612 os << ") " ;
613 }
614 else
615 {
616 if( ki == kernings_.end( ) )
617 {
618 throw Exceptions::InternalError( "Short of kerning values in KernedText::writePDFVectorTo." );
619 }
620 os << 1000 * *ki << " " ;
621 ++ki;
622 }
623 }
624 if( ki != kernings_.end( ) )
625 {
626 throw Exceptions::InternalError( "Too many kerning values in KernedText::writePDFVectorTo." );
627 }
628
629 os << "] TJ " << std::endl ;
630 }
631
632 void
633 Lang::KernedText::measure( Lang::Transform2D * textMatrix, Lang::Transform2D * textLineMatrix, Concrete::Length * xmin, Concrete::Length * ymin, Concrete::Length * xmax, Concrete::Length * ymax ) const
634 {
635 iconv_t converter = Helpers::requireUTF8ToMacRomanConverter( );
636
637 RefCountPtr< FontMetrics::WritingDirectionMetrics > horizontalMetrics = textState_->font_->metrics( )->horizontalMetrics_;
638 if( horizontalMetrics == NullPtr< FontMetrics::WritingDirectionMetrics >( ) )
639 {
640 throw Exceptions::FontMetricsError( textState_->font_->fontName( ), strrefdup( "No horizontal metrics defined." ) );
641 }
642 const FontMetrics::CharacterMetrics * defaultCharMetrics = horizontalMetrics->charData_[ 0 ];
643
644 Concrete::Length ySize = textState_->size_;
645 Concrete::Length xSize = ySize * textState_->horizontalScaling_;
646 Concrete::Length characterTrackKern = textState_->horizontalScaling_ * textState_->characterSpacing_;
647 Concrete::Length wordTrackKern = textState_->horizontalScaling_ * textState_->wordSpacing_;
648
649 size_t bufSize = maxLength_ + 1; // This will be enough if MacRoman coding is used, since this encoding uses only one byte per character.
650 // The extra one byte will be used to terminate the string.
651 char * buf = new char[ bufSize ];
652 DeleteOnExit< char > bufDeleter( buf );
653
654 if( textLineMatrix->isTranslation( ) )
655 {
656 Concrete::Length x0 = textLineMatrix->xt_;
657 Concrete::Length y0 = textLineMatrix->yt_ + textState_->riseConcrete( );
658 Concrete::Length xpos = 0;
659
660 typedef typeof strings_ ListType;
661 std::list< double >::const_iterator ki = kernings_.begin( );
662 for( ListType::const_iterator i = strings_.begin( ); i != strings_.end( ); ++i )
663 {
664 if( *i != NullPtr< const Lang::String >( ) )
665 {
666 const char * inbuf = (*i)->val_.getPtr( );
667 char * outbuf = buf;
668 size_t inbytesleft = strlen( inbuf );
669 size_t outbytesleft = bufSize - 1;
670 // The ICONV_CAST macro is defined in config.h.
671 size_t count = iconv( converter,
672 ICONV_CAST( & inbuf ), & inbytesleft,
673 & outbuf, & outbytesleft );
674 if( count == (size_t)(-1) )
675 {
676 if( errno == EILSEQ )
677 {
678 throw Exceptions::MiscellaneousRequirement( "It is suspected that one of the UFT-8 characters used in showed text has no MacRoman representation." );
679 }
680 else if( errno == EINVAL )
681 {
682 throw Exceptions::MiscellaneousRequirement( "It is suspected that showed text ended with an incomplete multibyte character." );
683 }
684 else if( errno == E2BIG )
685 {
686 throw Exceptions::InternalError( "The buffer allocated for UTF-8 to MacRoman conversion was too small." );
687 }
688 else
689 {
690 std::ostringstream msg;
691 msg << "iconv failed with an unrecognized error code: " << errno ;
692 throw Exceptions::InternalError( strrefdup( msg ) );
693 }
694 }
695 *outbuf = '\0';
696 for( const char * src = buf; *src != '\0'; ++src )
697 {
698 switch( *src )
699 {
700 case ' ':
701 {
702 // Observe textState_->wordSpacing_
703 // In addition, it seems reasonable to not let the space character affect the bounding box.
704 const FontMetrics::CharacterMetrics * charMetrics = horizontalMetrics->charByCode( (unsigned char)( 32 ) );
705 xpos += xSize * charMetrics->horizontalCharWidthX_;
706 xpos += characterTrackKern;
707 xpos += wordTrackKern;
708 }
709 break;
710 case '\n':
711 {
712 textMatrix->prependShift( Concrete::Coords2D( 0, - textState_->leadingConcrete( ) ) );
713 textLineMatrix->replaceBy( *textMatrix );
714 x0 = textLineMatrix->xt_;
715 y0 = textLineMatrix->yt_ + textState_->riseConcrete( );
716 xpos = 0;
717 }
718 break;
719 default:
720 {
721 // Observe textState_->characterSpacing_
722 unsigned char currentChar = *reinterpret_cast< const unsigned char * >( src );
723 const FontMetrics::CharacterMetrics * charMetrics = horizontalMetrics->charByCode( currentChar );
724 if( Computation::fontMetricGuessIsError && charMetrics == defaultCharMetrics )
725 {
726 std::ostringstream msg;
727 msg << "Character at offset " << src - buf << " in \"" << buf << "\" was not found in font metrics (and according to your options, guessing is not OK)." ;
728 throw Exceptions::FontMetricsError( textState_->font_->fontName( ), strrefdup( msg ) );
729 }
730 *xmin = std::min( *xmin, x0 + xpos + xSize * charMetrics->xmin_ );
731 *ymin = std::min( *ymin, y0 + ySize * charMetrics->ymin_ );
732 *xmax = std::max( *xmax, x0 + xpos + xSize * charMetrics->xmax_ );
733 *ymax = std::max( *ymax, y0 + ySize * charMetrics->ymax_ );
734 xpos += xSize * charMetrics->horizontalCharWidthX_;
735 xpos += characterTrackKern;
736 }
737 }
738 }
739 }
740 else
741 {
742 if( ki == kernings_.end( ) )
743 {
744 throw Exceptions::InternalError( "Short of kerning values in KernedText::measure." );
745 }
746 xpos -= xSize * *ki;
747 ++ki;
748 }
749 }
750 if( ki != kernings_.end( ) )
751 {
752 throw Exceptions::InternalError( "Too many kerning values in KernedText::writePDFVectorTo." );
753 }
754
755 textLineMatrix->prependXShift( xpos );
756 }
757 else
758 {
759 Concrete::Length rise = textState_->riseConcrete( );
760 // std::cerr << "@<< @stroking:RGB_RED | [stroke [shift " << Helpers::shapesFormat( Concrete::Coords2D( 0, 0 ).transformed( *textLineMatrix ) ) << "] [] [circle 2bp]]" << std::endl ;
761
762 typedef typeof strings_ ListType;
763 std::list< double >::const_iterator ki = kernings_.begin( );
764 for( ListType::const_iterator i = strings_.begin( ); i != strings_.end( ); ++i )
765 {
766 if( *i != NullPtr< const Lang::String >( ) )
767 {
768 const char * inbuf = (*i)->val_.getPtr( );
769 char * outbuf = buf;
770 size_t inbytesleft = strlen( inbuf );
771 size_t outbytesleft = bufSize - 1;
772 // The ICONV_CAST macro is defined in config.h.
773 size_t count = iconv( converter,
774 ICONV_CAST( & inbuf ), & inbytesleft,
775 & outbuf, & outbytesleft );
776 if( count == (size_t)(-1) )
777 {
778 if( errno == EILSEQ )
779 {
780 throw Exceptions::MiscellaneousRequirement( "It is suspected that one of the UFT-8 characters used in showed text has no MacRoman representation." );
781 }
782 else if( errno == EINVAL )
783 {
784 throw Exceptions::MiscellaneousRequirement( "It is suspected that showed text ended with an incomplete multibyte character." );
785 }
786 else if( errno == E2BIG )
787 {
788 throw Exceptions::InternalError( "The buffer allocated for UTF-8 to MacRoman conversion was too small." );
789 }
790 else
791 {
792 std::ostringstream msg;
793 msg << "iconv failed with an unrecognized error code: " << errno ;
794 throw Exceptions::InternalError( strrefdup( msg ) );
795 }
796 }
797 *outbuf = '\0';
798 for( const char * src = buf; *src != '\0'; ++src )
799 {
800 switch( *src )
801 {
802 case ' ':
803 {
804 // Observe textState_->wordSpacing_
805 // In addition, it seems reasonable to not let the space character affect the bounding box.
806 const FontMetrics::CharacterMetrics * charMetrics = horizontalMetrics->charByCode( (unsigned char)( 32 ) );
807 textLineMatrix->prependXShift( xSize * charMetrics->horizontalCharWidthX_ + characterTrackKern + wordTrackKern );
808 // std::cerr << "@<< @stroking:RGB_BLUE | [stroke [shift " << Helpers::shapesFormat( Concrete::Coords2D( 0, 0 ).transformed( *textLineMatrix ) ) << "] [] [circle 2bp]]" << std::endl ;
809 }
810 break;
811 case '\n':
812 {
813 textMatrix->prependShift( Concrete::Coords2D( 0, - textState_->leadingConcrete( ) ) );
814 textLineMatrix->replaceBy( *textMatrix );
815 // std::cerr << "@<< @stroking:RGB_RED | [stroke [shift " << Helpers::shapesFormat( Concrete::Coords2D( 0, 0 ).transformed( *textLineMatrix ) ) << "] [] [circle 2bp]]" << std::endl ;
816 }
817 break;
818 default:
819 {
820 // Observe textState_->characterSpacing_
821 unsigned char currentChar = *reinterpret_cast< const unsigned char * >( src );
822 const FontMetrics::CharacterMetrics * charMetrics = horizontalMetrics->charByCode( currentChar );
823 if( Computation::fontMetricGuessIsError && charMetrics == defaultCharMetrics )
824 {
825 std::ostringstream msg;
826 msg << "Character at offset " << src - buf << " in \"" << buf << "\" was not found in the font metrics (and according to your options, guessing is not OK)." ;
827 throw Exceptions::FontMetricsError( textState_->font_->fontName( ), strrefdup( msg ) );
828 }
829
830 Concrete::Coords2D x0y0 = Concrete::Coords2D( xSize * charMetrics->xmin_, ySize * charMetrics->ymin_ + rise ).transformed( *textLineMatrix );
831 Concrete::Coords2D x0y1 = Concrete::Coords2D( xSize * charMetrics->xmin_, ySize * charMetrics->ymax_ + rise ).transformed( *textLineMatrix );
832 Concrete::Coords2D x1y0 = Concrete::Coords2D( xSize * charMetrics->xmax_, ySize * charMetrics->ymin_ + rise ).transformed( *textLineMatrix );
833 Concrete::Coords2D x1y1 = Concrete::Coords2D( xSize * charMetrics->xmax_, ySize * charMetrics->ymax_ + rise ).transformed( *textLineMatrix );
834 // std::cerr << "@<< @width:0.3bp | [stroke "<< Helpers::shapesFormat( x0y0 ) << "--" << Helpers::shapesFormat( x0y1 ) << "--" << Helpers::shapesFormat( x1y1 ) << "--" << Helpers::shapesFormat( x1y0 ) << "--cycle]" << std::endl ;
835
836 *xmin = std::min( *xmin, x0y0.x_ );
837 *ymin = std::min( *ymin, x0y0.y_ );
838 *xmax = std::max( *xmax, x0y0.x_ );
839 *ymax = std::max( *ymax, x0y0.y_ );
840
841 *xmin = std::min( *xmin, x0y1.x_ );
842 *ymin = std::min( *ymin, x0y1.y_ );
843 *xmax = std::max( *xmax, x0y1.x_ );
844 *ymax = std::max( *ymax, x0y1.y_ );
845
846 *xmin = std::min( *xmin, x1y0.x_ );
847 *ymin = std::min( *ymin, x1y0.y_ );
848 *xmax = std::max( *xmax, x1y0.x_ );
849 *ymax = std::max( *ymax, x1y0.y_ );
850
851 *xmin = std::min( *xmin, x1y1.x_ );
852 *ymin = std::min( *ymin, x1y1.y_ );
853 *xmax = std::max( *xmax, x1y1.x_ );
854 *ymax = std::max( *ymax, x1y1.y_ );
855
856 textLineMatrix->prependXShift( xSize * charMetrics->horizontalCharWidthX_ + characterTrackKern );
857 // std::cerr << "@<< [stroke [shift " << Helpers::shapesFormat( Concrete::Coords2D( 0, 0 ).transformed( *textLineMatrix ) ) << "] [] [circle 2bp]]" << std::endl ;
858 }
859 }
860 }
861 }
862 else
863 {
864 if( ki == kernings_.end( ) )
865 {
866 throw Exceptions::InternalError( "Short of kerning values in KernedText::measure." );
867 }
868 textLineMatrix->prependXShift( - xSize * *ki );
869 ++ki;
870 }
871 }
872 if( ki != kernings_.end( ) )
873 {
874 throw Exceptions::InternalError( "Too many kerning values in KernedText::writePDFVectorTo." );
875 }
876 }
877 }
878
879 void
880 Lang::KernedText::push( Lang::KernedText * dst ) const
881 {
882 typedef typeof strings_ ListType;
883 std::list< double >::const_iterator ki = kernings_.begin( );
884 for( ListType::const_iterator i = strings_.begin( ); i != strings_.end( ); ++i )
885 {
886 if( *i != NullPtr< const Lang::String >( ) )
887 {
888 dst->pushString( *i );
889 }
890 else
891 {
892 dst->pushKerning( *ki );
893 ++ki;
894 }
895 }
896 }
897
898
899 void
900 Lang::KernedText::gcMark( Kernel::GCMarkedSet & marked )
901 {
902 typedef typeof strings_ ListType;
903 for( ListType::const_iterator i = strings_.begin( ); i != strings_.end( ); ++i )
904 {
905 if( *i != NullPtr< const Lang::String >( ) )
906 {
907 const_cast< Lang::String * >( i->getPtr( ) )->gcMark( marked );
908 }
909 }
910 }
911
912 Lang::TextNewline::TextNewline( const Concrete::Length tx, const Concrete::Length ty )
913 : t_( tx, ty )
914 { }
915
916 Lang::TextNewline::~TextNewline( )
917 { }
918
919 void
920 Lang::TextNewline::show( std::ostream & os ) const
921 {
922 os << "Newline with offset in bp: " << t_ ;
923 }
924
925 void
926 Lang::TextNewline::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf, bool clip ) const
927 {
928 os << t_ << " Td " ;
929 }
930
931 void
932 Lang::TextNewline::measure( Lang::Transform2D * textMatrix, Lang::Transform2D * textLineMatrix, Concrete::Length * xmin, Concrete::Length * ymin, Concrete::Length * xmax, Concrete::Length * ymax ) const
933 {
934 textMatrix->prependShift( t_ );
935 textLineMatrix->replaceBy( *textMatrix );
936 }
937
938 void
939 Lang::TextNewline::gcMark( Kernel::GCMarkedSet & marked )
940 { }
941
942 Lang::TextMoveto::TextMoveto( const RefCountPtr< const Lang::Transform2D > & tf )
943 : tf_( tf )
944 { }
945
946 Lang::TextMoveto::~TextMoveto( )
947 { }
948
949 void
950 Lang::TextMoveto::show( std::ostream & os ) const
951 {
952 os << "Moveto command" ;
953 }
954
955 void
956 Lang::TextMoveto::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf, bool clip ) const
957 {
958 Lang::Transform2D( tf, *tf_ ).shipout( os );
959 os << " Tm" << std::endl ;
960 }
961
962 void
963 Lang::TextMoveto::measure( Lang::Transform2D * textMatrix, Lang::Transform2D * textLineMatrix, Concrete::Length * xmin, Concrete::Length * ymin, Concrete::Length * xmax, Concrete::Length * ymax ) const
964 {
965 textMatrix->replaceBy( *tf_ );
966 textLineMatrix->replaceBy( *textMatrix );
967 }
968
969 void
970 Lang::TextMoveto::gcMark( Kernel::GCMarkedSet & marked )
971 {
972 const_cast< Lang::Transform2D * >( tf_.getPtr( ) )->gcMark( marked );
973 }
974
975
976
977 typedef enum { FILL = 0, STROKE, FILLSTROKE, INVISIBLE, FILLCLIP, STROKECLIP, FILLSTROKECLIP, CLIP, UNDEFINED } ValueType;
978 ValueType mode_;
979
980 Lang::TextRenderingMode::TextRenderingMode( const ValueType & mode )
981 : mode_( mode )
982 { }
983
984 Lang::TextRenderingMode::TextRenderingMode( bool fill, bool stroke, bool clip )
985 {
986 switch( ( fill ? 0x01 : 0x00 ) +
987 ( stroke ? 0x02 : 0x00 ) +
988 ( clip ? 0x04 : 0x00 ) )
989 {
990 case 0x00:
991 mode_ = INVISIBLE;
992 break;
993 case 0x01:
994 mode_ = FILL;
995 break;
996 case 0x02:
997 mode_ = STROKE;
998 break;
999 case 0x03:
1000 mode_ = FILLSTROKE;
1001 break;
1002 case 0x04:
1003 mode_ = CLIP;
1004 break;
1005 case 0x05:
1006 mode_ = FILLCLIP;
1007 break;
1008 case 0x06:
1009 mode_ = STROKECLIP;
1010 break;
1011 case 0x07:
1012 mode_ = FILLSTROKECLIP;
1013 break;
1014 default:
1015 throw Exceptions::InternalError( "Semi-static switch out of range in TextRenderingMode::TextRenderingMode." );
1016 }
1017 }
1018
1019 Lang::TextRenderingMode::ValueType
1020 Lang::TextRenderingMode::clipMode( ValueType mode )
1021 {
1022 switch( mode )
1023 {
1024 case INVISIBLE:
1025 return CLIP;
1026 case FILL:
1027 return FILLCLIP;
1028 case STROKE:
1029 return STROKECLIP;
1030 case FILLSTROKE:
1031 return FILLSTROKECLIP;
1032 default:
1033 return UNDEFINED;
1034 }
1035 }
1036
1037 Lang::TextRenderingMode::~TextRenderingMode( )
1038 { }
1039
1040 RefCountPtr< const Lang::Class > Lang::TextRenderingMode::TypeID( new Lang::SystemFinalClass( strrefdup( "TextRenderingMode" ) ) );
1041 TYPEINFOIMPL( TextRenderingMode );
1042
1043
1044 Lang::CharacterSpacingBinding::CharacterSpacingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Concrete::Length spacing )
1045 : bindingExpr_( bindingExpr ), spacing_( spacing ), isRelative_( false ), id_( id )
1046 { }
1047
1048 Lang::CharacterSpacingBinding::CharacterSpacingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const double r )
1049 : bindingExpr_( bindingExpr ), spacing_( r ), isRelative_( true ), id_( id )
1050 { }
1051
1052 Lang::CharacterSpacingBinding::~CharacterSpacingBinding( )
1053 { }
1054
1055 void
1056 Lang::CharacterSpacingBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
1057 {
1058 if( *sysBindings == 0 )
1059 {
1060 *sysBindings = new Kernel::SystemDynamicVariables( );
1061 Kernel::TextState * newState = new Kernel::TextState( );
1062 if( isRelative_ )
1063 {
1064 newState->setCharacterSpacing( Concrete::Length::offtype( spacing_ ) );
1065 }
1066 else
1067 {
1068 newState->setCharacterSpacing( spacing_ );
1069 }
1070 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1071 return;
1072 }
1073
1074 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
1075 {
1076 Kernel::TextState * newState = new Kernel::TextState( );
1077 if( isRelative_ )
1078 {
1079 newState->setCharacterSpacing( Concrete::Length::offtype( spacing_ ) );
1080 }
1081 else
1082 {
1083 newState->setCharacterSpacing( spacing_ );
1084 }
1085 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1086 return;
1087 }
1088
1089 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
1090
1091 if( newState->hasCharacterSpacing( ) )
1092 {
1093 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
1094 }
1095
1096 if( isRelative_ )
1097 {
1098 newState->setCharacterSpacing( Concrete::Length::offtype( spacing_ ) );
1099 }
1100 else
1101 {
1102 newState->setCharacterSpacing( spacing_ );
1103 }
1104 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1105 }
1106
1107 void
1108 Lang::CharacterSpacingBinding::show( std::ostream & os ) const
1109 {
1110 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":" ;
1111 if( isRelative_ )
1112 {
1113 os << Concrete::Length::offtype( spacing_ ) ;
1114 }
1115 else
1116 {
1117 os << spacing_ / Interaction::displayUnit << Interaction::displayUnitName ;
1118 }
1119 }
1120
1121 void
1122 Lang::CharacterSpacingBinding::gcMark( Kernel::GCMarkedSet & marked )
1123 { }
1124
1125
1126 Lang::WordSpacingBinding::WordSpacingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Concrete::Length spacing )
1127 : bindingExpr_( bindingExpr ), spacing_( spacing ), isRelative_( false ), id_( id )
1128 { }
1129
1130 Lang::WordSpacingBinding::WordSpacingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const double r )
1131 : bindingExpr_( bindingExpr ), spacing_( r ), isRelative_( true ), id_( id )
1132 { }
1133
1134 Lang::WordSpacingBinding::~WordSpacingBinding( )
1135 { }
1136
1137 void
1138 Lang::WordSpacingBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
1139 {
1140 if( *sysBindings == 0 )
1141 {
1142 *sysBindings = new Kernel::SystemDynamicVariables( );
1143 Kernel::TextState * newState = new Kernel::TextState( );
1144 if( isRelative_ )
1145 {
1146 newState->setWordSpacing( Concrete::Length::offtype( spacing_ ) );
1147 }
1148 else
1149 {
1150 newState->setWordSpacing( spacing_ );
1151 }
1152 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1153 return;
1154 }
1155
1156 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
1157 {
1158 Kernel::TextState * newState = new Kernel::TextState( );
1159 if( isRelative_ )
1160 {
1161 newState->setWordSpacing( Concrete::Length::offtype( spacing_ ) );
1162 }
1163 else
1164 {
1165 newState->setWordSpacing( spacing_ );
1166 }
1167 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1168 return;
1169 }
1170
1171 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
1172
1173 if( newState->hasWordSpacing( ) )
1174 {
1175 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
1176 }
1177
1178 if( isRelative_ )
1179 {
1180 newState->setWordSpacing( Concrete::Length::offtype( spacing_ ) );
1181 }
1182 else
1183 {
1184 newState->setWordSpacing( spacing_ );
1185 }
1186 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1187 }
1188
1189 void
1190 Lang::WordSpacingBinding::show( std::ostream & os ) const
1191 {
1192 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":" ;
1193 if( isRelative_ )
1194 {
1195 os << Concrete::Length::offtype( spacing_ ) ;
1196 }
1197 else
1198 {
1199 os << spacing_ / Interaction::displayUnit << Interaction::displayUnitName ;
1200 }
1201 }
1202
1203 void
1204 Lang::WordSpacingBinding::gcMark( Kernel::GCMarkedSet & marked )
1205 { }
1206
1207
1208 Lang::HorizontalScalingBinding::HorizontalScalingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, double scaling )
1209 : bindingExpr_( bindingExpr ), scaling_( scaling ), id_( id )
1210 { }
1211
1212 Lang::HorizontalScalingBinding::~HorizontalScalingBinding( )
1213 { }
1214
1215 void
1216 Lang::HorizontalScalingBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
1217 {
1218 if( *sysBindings == 0 )
1219 {
1220 *sysBindings = new Kernel::SystemDynamicVariables( );
1221 Kernel::TextState * newState = new Kernel::TextState( );
1222 newState->horizontalScaling_ = scaling_;
1223 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1224 return;
1225 }
1226
1227 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
1228 {
1229 Kernel::TextState * newState = new Kernel::TextState( );
1230 newState->horizontalScaling_ = scaling_;
1231 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1232 return;
1233 }
1234
1235 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
1236
1237 if( ! IS_NAN( newState->horizontalScaling_ ) )
1238 {
1239 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
1240 }
1241
1242 newState->horizontalScaling_ = scaling_;
1243 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1244 }
1245
1246 void
1247 Lang::HorizontalScalingBinding::show( std::ostream & os ) const
1248 {
1249 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":"
1250 << scaling_ ;
1251 }
1252
1253 void
1254 Lang::HorizontalScalingBinding::gcMark( Kernel::GCMarkedSet & marked )
1255 { }
1256
1257
1258 Lang::LeadingBinding::LeadingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Concrete::Length ty )
1259 : bindingExpr_( bindingExpr ), ty_( ty ), isRelative_( false ), id_( id )
1260 { }
1261
1262 Lang::LeadingBinding::LeadingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const double r )
1263 : bindingExpr_( bindingExpr ), ty_( r ), isRelative_( true ), id_( id )
1264 { }
1265
1266 Lang::LeadingBinding::~LeadingBinding( )
1267 { }
1268
1269 void
1270 Lang::LeadingBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
1271 {
1272 if( *sysBindings == 0 )
1273 {
1274 *sysBindings = new Kernel::SystemDynamicVariables( );
1275 Kernel::TextState * newState = new Kernel::TextState( );
1276 if( isRelative_ )
1277 {
1278 newState->setLeading( Concrete::Length::offtype( ty_ ) );
1279 }
1280 else
1281 {
1282 newState->setLeading( ty_ );
1283 }
1284 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1285 return;
1286 }
1287
1288 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
1289 {
1290 Kernel::TextState * newState = new Kernel::TextState( );
1291 if( isRelative_ )
1292 {
1293 newState->setLeading( Concrete::Length::offtype( ty_ ) );
1294 }
1295 else
1296 {
1297 newState->setLeading( ty_ );
1298 }
1299 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1300 return;
1301 }
1302
1303 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
1304
1305 if( newState->hasLeading( ) )
1306 {
1307 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
1308 }
1309
1310 if( isRelative_ )
1311 {
1312 newState->setLeading( Concrete::Length::offtype( ty_ ) );
1313 }
1314 else
1315 {
1316 newState->setLeading( ty_ );
1317 }
1318 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1319 }
1320
1321 void
1322 Lang::LeadingBinding::show( std::ostream & os ) const
1323 {
1324 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":" ;
1325 if( isRelative_ )
1326 {
1327 os << Concrete::Length::offtype( ty_ ) ;
1328 }
1329 else
1330 {
1331 os << ty_ / Interaction::displayUnit << Interaction::displayUnitName ;
1332 }
1333 }
1334
1335 void
1336 Lang::LeadingBinding::gcMark( Kernel::GCMarkedSet & marked )
1337 { }
1338
1339
1340 Lang::FontBinding::FontBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const RefCountPtr< const Lang::Font > & font )
1341 : bindingExpr_( bindingExpr ), font_( font ), id_( id )
1342 { }
1343
1344 Lang::FontBinding::~FontBinding( )
1345 { }
1346
1347 void
1348 Lang::FontBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
1349 {
1350 if( *sysBindings == 0 )
1351 {
1352 *sysBindings = new Kernel::SystemDynamicVariables( );
1353 Kernel::TextState * newState = new Kernel::TextState( );
1354 newState->font_ = font_;
1355 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1356 return;
1357 }
1358
1359 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
1360 {
1361 Kernel::TextState * newState = new Kernel::TextState( );
1362 newState->font_ = font_;
1363 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1364 return;
1365 }
1366
1367 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
1368
1369 if( newState->font_ != NullPtr< const Lang::Font >( ) )
1370 {
1371 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
1372 }
1373
1374 newState->font_ = font_;
1375 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1376 }
1377
1378 void
1379 Lang::FontBinding::show( std::ostream & os ) const
1380 {
1381 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":" ;
1382 font_->show( os );
1383 }
1384
1385 void
1386 Lang::FontBinding::gcMark( Kernel::GCMarkedSet & marked )
1387 {
1388 const_cast< Lang::Font * >( font_.getPtr( ) )->gcMark( marked );
1389 }
1390
1391
1392 Lang::TextSizeBinding::TextSizeBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Concrete::Length size )
1393 : bindingExpr_( bindingExpr ), size_( size ), id_( id )
1394 { }
1395
1396 Lang::TextSizeBinding::~TextSizeBinding( )
1397 { }
1398
1399 void
1400 Lang::TextSizeBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
1401 {
1402 if( *sysBindings == 0 )
1403 {
1404 *sysBindings = new Kernel::SystemDynamicVariables( );
1405 Kernel::TextState * newState = new Kernel::TextState( );
1406 newState->size_ = size_;
1407 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1408 return;
1409 }
1410
1411 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
1412 {
1413 Kernel::TextState * newState = new Kernel::TextState( );
1414 newState->size_ = size_;
1415 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1416 return;
1417 }
1418
1419 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
1420
1421 if( ! IS_NAN( newState->size_ ) )
1422 {
1423 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
1424 }
1425
1426 newState->size_ = size_;
1427 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1428 }
1429
1430 void
1431 Lang::TextSizeBinding::show( std::ostream & os ) const
1432 {
1433 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":"
1434 << size_ / Interaction::displayUnit << Interaction::displayUnitName ;
1435 }
1436
1437 void
1438 Lang::TextSizeBinding::gcMark( Kernel::GCMarkedSet & marked )
1439 { }
1440
1441
1442 Lang::TextRenderingModeBinding::TextRenderingModeBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Lang::TextRenderingMode::ValueType mode )
1443 : bindingExpr_( bindingExpr ), mode_( mode ), id_( id )
1444 { }
1445
1446 Lang::TextRenderingModeBinding::~TextRenderingModeBinding( )
1447 { }
1448
1449 void
1450 Lang::TextRenderingModeBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
1451 {
1452 if( *sysBindings == 0 )
1453 {
1454 *sysBindings = new Kernel::SystemDynamicVariables( );
1455 Kernel::TextState * newState = new Kernel::TextState( );
1456 newState->mode_ = mode_;
1457 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1458 return;
1459 }
1460
1461 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
1462 {
1463 Kernel::TextState * newState = new Kernel::TextState( );
1464 newState->mode_ = mode_;
1465 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1466 return;
1467 }
1468
1469 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
1470
1471 if( newState->mode_ != Lang::TextRenderingMode::UNDEFINED )
1472 {
1473 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
1474 }
1475
1476 newState->mode_ = mode_;
1477 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1478 }
1479
1480 void
1481 Lang::TextRenderingModeBinding::show( std::ostream & os ) const
1482 {
1483 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":"
1484 << "<internal-enum>" ;
1485 }
1486
1487 void
1488 Lang::TextRenderingModeBinding::gcMark( Kernel::GCMarkedSet & marked )
1489 { }
1490
1491
1492 Lang::TextRiseBinding::TextRiseBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Concrete::Length ty )
1493 : bindingExpr_( bindingExpr ), ty_( ty ), isRelative_( false ), id_( id )
1494 { }
1495
1496 Lang::TextRiseBinding::TextRiseBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const double r )
1497 : bindingExpr_( bindingExpr ), ty_( r ), isRelative_( true ), id_( id )
1498 { }
1499
1500 Lang::TextRiseBinding::~TextRiseBinding( )
1501 { }
1502
1503 void
1504 Lang::TextRiseBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
1505 {
1506 if( *sysBindings == 0 )
1507 {
1508 *sysBindings = new Kernel::SystemDynamicVariables( );
1509 Kernel::TextState * newState = new Kernel::TextState( );
1510 if( isRelative_ )
1511 {
1512 newState->setRise( Concrete::Length::offtype( ty_ ) );
1513 }
1514 else
1515 {
1516 newState->setRise( ty_ );
1517 }
1518 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1519 return;
1520 }
1521
1522 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
1523 {
1524 Kernel::TextState * newState = new Kernel::TextState( );
1525 if( isRelative_ )
1526 {
1527 newState->setRise( Concrete::Length::offtype( ty_ ) );
1528 }
1529 else
1530 {
1531 newState->setRise( ty_ );
1532 }
1533 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1534 return;
1535 }
1536
1537 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
1538
1539 if( newState->hasRise( ) )
1540 {
1541 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
1542 }
1543
1544 if( isRelative_ )
1545 {
1546 newState->setRise( Concrete::Length::offtype( ty_ ) );
1547 }
1548 else
1549 {
1550 newState->setRise( ty_ );
1551 }
1552 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1553 }
1554
1555 void
1556 Lang::TextRiseBinding::show( std::ostream & os ) const
1557 {
1558 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":" ;
1559 if( isRelative_ )
1560 {
1561 os << Concrete::Length::offtype( ty_ ) ;
1562 }
1563 else
1564 {
1565 os << ty_ / Interaction::displayUnit << Interaction::displayUnitName ;
1566 }
1567 }
1568
1569 void
1570 Lang::TextRiseBinding::gcMark( Kernel::GCMarkedSet & marked )
1571 { }
1572
1573
1574 Lang::TextKnockoutBinding::TextKnockoutBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, bool knockout )
1575 : bindingExpr_( bindingExpr ), knockout_( knockout ), id_( id )
1576 { }
1577
1578 Lang::TextKnockoutBinding::~TextKnockoutBinding( )
1579 { }
1580
1581 void
1582 Lang::TextKnockoutBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
1583 {
1584 if( *sysBindings == 0 )
1585 {
1586 *sysBindings = new Kernel::SystemDynamicVariables( );
1587 Kernel::TextState * newState = new Kernel::TextState( );
1588 newState->knockout_ = knockout_;
1589 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1590 return;
1591 }
1592
1593 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
1594 {
1595 Kernel::TextState * newState = new Kernel::TextState( );
1596 newState->knockout_ = knockout_;
1597 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1598 return;
1599 }
1600
1601 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
1602
1603 if( ( newState->knockout_ & Kernel::TextState::KNOCKOUT_UNDEFINED_BIT ) != 0 )
1604 {
1605 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
1606 }
1607
1608 newState->knockout_ = ( knockout_ ? Kernel::TextState::KNOCKOUT_FLAG_BIT : 0 );
1609 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1610 }
1611
1612 void
1613 Lang::TextKnockoutBinding::show( std::ostream & os ) const
1614 {
1615 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":"
1616 << ( knockout_ ? "true" : "false" ) ;
1617 }
1618
1619 void
1620 Lang::TextKnockoutBinding::gcMark( Kernel::GCMarkedSet & marked )
1621 { }
1622
1623
1624 Kernel::CharacterSpacingDynamicVariableProperties::CharacterSpacingDynamicVariableProperties( const char * name )
1625 : Kernel::DynamicVariableProperties( name )
1626 { }
1627
1628 Kernel::CharacterSpacingDynamicVariableProperties::~CharacterSpacingDynamicVariableProperties( )
1629 { }
1630
1631 Kernel::VariableHandle
1632 Kernel::CharacterSpacingDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
1633 {
1634 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
1635 return Kernel::VariableHandle( new Kernel::Variable( textState->characterSpacing( ) ) );
1636 }
1637
1638 void
1639 Kernel::CharacterSpacingDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
1640 {
1641 RefCountPtr< const Lang::Value > valUntyped = val->getUntyped( );
1642
1643 Kernel::ContRef cont = evalState->cont_;
1644
1645 try
1646 {
1647 typedef const Lang::Length ArgType;
1648 RefCountPtr< ArgType > spacing = Helpers::try_cast_CoreArgument< ArgType >( valUntyped );
1649 cont->takeValue( Kernel::ValueRef( new Lang::CharacterSpacingBinding( name_, bindingExpr, spacing->get( ) ) ),
1650 evalState );
1651 return;
1652 }
1653 catch( const NonLocalExit::NotThisType & ball )
1654 {
1655 /* Wrong type; never mind!.. but see below!
1656 */
1657 }
1658
1659 try
1660 {
1661 typedef const Lang::Float ArgType;
1662 RefCountPtr< ArgType > spacing = Helpers::try_cast_CoreArgument< ArgType >( valUntyped );
1663 cont->takeValue( Kernel::ValueRef( new Lang::CharacterSpacingBinding( name_, bindingExpr, spacing->val_ ) ),
1664 evalState );
1665 return;
1666 }
1667 catch( const NonLocalExit::NotThisType & ball )
1668 {
1669 /* Wrong type; never mind!.. but see below!
1670 */
1671 }
1672
1673 throw Exceptions::TypeMismatch( bindingExpr->exprLoc( ), valUntyped->getTypeName( ), Helpers::typeSetString( Lang::Length::staticTypeName( ), Lang::Float::staticTypeName( ) ) );
1674 }
1675
1676
1677 Kernel::WordSpacingDynamicVariableProperties::WordSpacingDynamicVariableProperties( const char * name )
1678 : Kernel::DynamicVariableProperties( name )
1679 { }
1680
1681 Kernel::WordSpacingDynamicVariableProperties::~WordSpacingDynamicVariableProperties( )
1682 { }
1683
1684 Kernel::VariableHandle
1685 Kernel::WordSpacingDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
1686 {
1687 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
1688 return Kernel::VariableHandle( new Kernel::Variable( textState->wordSpacing( ) ) );
1689 }
1690
1691 void
1692 Kernel::WordSpacingDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
1693 {
1694 RefCountPtr< const Lang::Value > valUntyped = val->getUntyped( );
1695
1696 Kernel::ContRef cont = evalState->cont_;
1697
1698 try
1699 {
1700 typedef const Lang::Length ArgType;
1701 RefCountPtr< ArgType > spacing = Helpers::try_cast_CoreArgument< ArgType >( valUntyped );
1702 cont->takeValue( Kernel::ValueRef( new Lang::WordSpacingBinding( name_, bindingExpr, spacing->get( ) ) ),
1703 evalState );
1704 return;
1705 }
1706 catch( const NonLocalExit::NotThisType & ball )
1707 {
1708 /* Wrong type; never mind!.. but see below!
1709 */
1710 }
1711
1712 try
1713 {
1714 typedef const Lang::Float ArgType;
1715 RefCountPtr< ArgType > spacing = Helpers::try_cast_CoreArgument< ArgType >( valUntyped );
1716 cont->takeValue( Kernel::ValueRef( new Lang::WordSpacingBinding( name_, bindingExpr, spacing->val_ ) ),
1717 evalState );
1718 return;
1719 }
1720 catch( const NonLocalExit::NotThisType & ball )
1721 {
1722 /* Wrong type; never mind!.. but see below!
1723 */
1724 }
1725
1726 throw Exceptions::TypeMismatch( bindingExpr->exprLoc( ), valUntyped->getTypeName( ), Helpers::typeSetString( Lang::Length::staticTypeName( ), Lang::Float::staticTypeName( ) ) );
1727 }
1728
1729
1730 Kernel::HorizontalScalingDynamicVariableProperties::HorizontalScalingDynamicVariableProperties( const char * name )
1731 : Kernel::DynamicVariableProperties( name )
1732 { }
1733
1734 Kernel::HorizontalScalingDynamicVariableProperties::~HorizontalScalingDynamicVariableProperties( )
1735 { }
1736
1737 Kernel::VariableHandle
1738 Kernel::HorizontalScalingDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
1739 {
1740 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
1741 return Kernel::VariableHandle( Shapes::Helpers::newValHandle( new Lang::Float( textState->horizontalScaling_ ) ) );
1742 }
1743
1744 void
1745 Kernel::HorizontalScalingDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
1746 {
1747 RefCountPtr< const Lang::Float > scaling = val->getVal< const Lang::Float >( bindingExpr->exprLoc( ) );
1748 Kernel::ContRef cont = evalState->cont_;
1749 cont->takeValue( Kernel::ValueRef( new Lang::HorizontalScalingBinding( name_, bindingExpr, scaling->val_ ) ),
1750 evalState );
1751 }
1752
1753
1754 Kernel::LeadingDynamicVariableProperties::LeadingDynamicVariableProperties( const char * name )
1755 : Kernel::DynamicVariableProperties( name )
1756 { }
1757
1758 Kernel::LeadingDynamicVariableProperties::~LeadingDynamicVariableProperties( )
1759 { }
1760
1761 Kernel::VariableHandle
1762 Kernel::LeadingDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
1763 {
1764 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
1765 return Kernel::VariableHandle( new Kernel::Variable( textState->leading( ) ) );
1766 }
1767
1768 void
1769 Kernel::LeadingDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
1770 {
1771 RefCountPtr< const Lang::Value > valUntyped = val->getUntyped( );
1772
1773 Kernel::ContRef cont = evalState->cont_;
1774
1775 try
1776 {
1777 typedef const Lang::Length ArgType;
1778 RefCountPtr< ArgType > ty = Helpers::try_cast_CoreArgument< ArgType >( valUntyped );
1779 cont->takeValue( Kernel::ValueRef( new Lang::LeadingBinding( name_, bindingExpr, ty->get( ) ) ),
1780 evalState );
1781 return;
1782 }
1783 catch( const NonLocalExit::NotThisType & ball )
1784 {
1785 /* Wrong type; never mind!.. but see below!
1786 */
1787 }
1788
1789 try
1790 {
1791 typedef const Lang::Float ArgType;
1792 RefCountPtr< ArgType > ty = Helpers::try_cast_CoreArgument< ArgType >( valUntyped );
1793 cont->takeValue( Kernel::ValueRef( new Lang::LeadingBinding( name_, bindingExpr, ty->val_ ) ),
1794 evalState );
1795 return;
1796 }
1797 catch( const NonLocalExit::NotThisType & ball )
1798 {
1799 /* Wrong type; never mind!.. but see below!
1800 */
1801 }
1802
1803 throw Exceptions::TypeMismatch( bindingExpr->exprLoc( ), valUntyped->getTypeName( ), Helpers::typeSetString( Lang::Length::staticTypeName( ), Lang::Float::staticTypeName( ) ) );
1804 }
1805
1806
1807 Kernel::FontDynamicVariableProperties::FontDynamicVariableProperties( const char * name )
1808 : Kernel::DynamicVariableProperties( name )
1809 { }
1810
1811 Kernel::FontDynamicVariableProperties::~FontDynamicVariableProperties( )
1812 { }
1813
1814 Kernel::VariableHandle
1815 Kernel::FontDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
1816 {
1817 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
1818 return Kernel::VariableHandle( new Kernel::Variable( textState->font_ ) );
1819 }
1820
1821 void
1822 Kernel::FontDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
1823 {
1824 Kernel::ContRef cont = evalState->cont_;
1825 cont->takeValue( Kernel::ValueRef( new Lang::FontBinding( name_, bindingExpr, val->getVal< const Lang::Font >( bindingExpr->exprLoc( ) ) ) ),
1826 evalState );
1827 }
1828
1829
1830 Kernel::TextSizeDynamicVariableProperties::TextSizeDynamicVariableProperties( const char * name )
1831 : Kernel::DynamicVariableProperties( name )
1832 { }
1833
1834 Kernel::TextSizeDynamicVariableProperties::~TextSizeDynamicVariableProperties( )
1835 { }
1836
1837 Kernel::VariableHandle
1838 Kernel::TextSizeDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
1839 {
1840 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
1841 return Kernel::VariableHandle( Shapes::Helpers::newValHandle( new Lang::Length( textState->size_ ) ) );
1842 }
1843
1844 void
1845 Kernel::TextSizeDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
1846 {
1847 RefCountPtr< const Lang::Length > size = val->getVal< const Lang::Length >( bindingExpr->exprLoc( ) );
1848 Kernel::ContRef cont = evalState->cont_;
1849 cont->takeValue( Kernel::ValueRef( new Lang::TextSizeBinding( name_, bindingExpr, size->get( ) ) ),
1850 evalState );
1851 }
1852
1853
1854 Kernel::TextRenderingModeDynamicVariableProperties::TextRenderingModeDynamicVariableProperties( const char * name )
1855 : Kernel::DynamicVariableProperties( name )
1856 { }
1857
1858 Kernel::TextRenderingModeDynamicVariableProperties::~TextRenderingModeDynamicVariableProperties( )
1859 { }
1860
1861 Kernel::VariableHandle
1862 Kernel::TextRenderingModeDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
1863 {
1864 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
1865 return Kernel::VariableHandle( Shapes::Helpers::newValHandle( new Lang::TextRenderingMode( textState->mode_ ) ) );
1866 }
1867
1868 void
1869 Kernel::TextRenderingModeDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
1870 {
1871 RefCountPtr< const Lang::TextRenderingMode > mode = val->getVal< const Lang::TextRenderingMode >( bindingExpr->exprLoc( ) );
1872 Kernel::ContRef cont = evalState->cont_;
1873 cont->takeValue( Kernel::ValueRef( new Lang::TextRenderingModeBinding( name_, bindingExpr, mode->mode_ ) ),
1874 evalState );
1875 }
1876
1877
1878 Kernel::TextRiseDynamicVariableProperties::TextRiseDynamicVariableProperties( const char * name )
1879 : Kernel::DynamicVariableProperties( name )
1880 { }
1881
1882 Kernel::TextRiseDynamicVariableProperties::~TextRiseDynamicVariableProperties( )
1883 { }
1884
1885 Kernel::VariableHandle
1886 Kernel::TextRiseDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
1887 {
1888 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
1889 return Kernel::VariableHandle( new Kernel::Variable( textState->rise( ) ) );
1890 }
1891
1892 void
1893 Kernel::TextRiseDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
1894 {
1895 RefCountPtr< const Lang::Value > valUntyped = val->getUntyped( );
1896
1897 Kernel::ContRef cont = evalState->cont_;
1898
1899 try
1900 {
1901 typedef const Lang::Length ArgType;
1902 RefCountPtr< ArgType > ty = Helpers::try_cast_CoreArgument< ArgType >( valUntyped );
1903 cont->takeValue( Kernel::ValueRef( new Lang::TextRiseBinding( name_, bindingExpr, ty->get( ) ) ),
1904 evalState );
1905 return;
1906 }
1907 catch( const NonLocalExit::NotThisType & ball )
1908 {
1909 /* Wrong type; never mind!.. but see below!
1910 */
1911 }
1912
1913 try
1914 {
1915 typedef const Lang::Float ArgType;
1916 RefCountPtr< ArgType > ty = Helpers::try_cast_CoreArgument< ArgType >( valUntyped );
1917 cont->takeValue( Kernel::ValueRef( new Lang::TextRiseBinding( name_, bindingExpr, ty->val_ ) ),
1918 evalState );
1919 return;
1920 }
1921 catch( const NonLocalExit::NotThisType & ball )
1922 {
1923 /* Wrong type; never mind!.. but see below!
1924 */
1925 }
1926
1927 throw Exceptions::TypeMismatch( bindingExpr->exprLoc( ), valUntyped->getTypeName( ), Helpers::typeSetString( Lang::Length::staticTypeName( ), Lang::Float::staticTypeName( ) ) );
1928 }
1929
1930
1931 Kernel::TextKnockoutDynamicVariableProperties::TextKnockoutDynamicVariableProperties( const char * name )
1932 : Kernel::DynamicVariableProperties( name )
1933 { }
1934
1935 Kernel::TextKnockoutDynamicVariableProperties::~TextKnockoutDynamicVariableProperties( )
1936 { }
1937
1938 Kernel::VariableHandle
1939 Kernel::TextKnockoutDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
1940 {
1941 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
1942 return Kernel::VariableHandle( Shapes::Helpers::newValHandle( new Lang::Boolean( ( textState->knockout_ & Kernel::TextState::KNOCKOUT_FLAG_BIT ) != 0 ) ) );
1943 }
1944
1945 void
1946 Kernel::TextKnockoutDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
1947 {
1948 RefCountPtr< const Lang::Boolean > mode = val->getVal< const Lang::Boolean >( bindingExpr->exprLoc( ) );
1949 Kernel::ContRef cont = evalState->cont_;
1950 cont->takeValue( Kernel::ValueRef( new Lang::TextKnockoutBinding( name_, bindingExpr, mode->val_ ) ),
1951 evalState );
1952 }
1953
1954
1955
1956 Kernel::TextState::TextState( )
1957 : relativeFlags_( 0 ),
1958 characterSpacing_( Concrete::Length( std::numeric_limits< double >::signaling_NaN( ) ) ),
1959 wordSpacing_( Concrete::Length( std::numeric_limits< double >::signaling_NaN( ) ) ),
1960 horizontalScaling_( std::numeric_limits< double >::signaling_NaN( ) ),
1961 leading_( Concrete::Length( std::numeric_limits< double >::signaling_NaN( ) ) ),
1962 rise_( Concrete::Length( std::numeric_limits< double >::signaling_NaN( ) ) ),
1963 font_( NullPtr< const Lang::Font >( ) ),
1964 size_( Concrete::Length( std::numeric_limits< double >::signaling_NaN( ) ) ),
1965 mode_( Lang::TextRenderingMode::UNDEFINED ),
1966 knockout_( KNOCKOUT_UNDEFINED_BIT )
1967 { }
1968
1969 Kernel::TextState::TextState( const Kernel::TextState & orig )
1970 : relativeFlags_( orig.relativeFlags_ ),
1971 characterSpacing_( orig.characterSpacing_ ),
1972 wordSpacing_( orig.wordSpacing_ ),
1973 horizontalScaling_( orig.horizontalScaling_ ),
1974 leading_( orig.leading_ ),
1975 rise_( orig.rise_ ),
1976 font_( orig.font_ ),
1977 size_( orig.size_ ),
1978 mode_( orig.mode_ ),
1979 knockout_( orig.knockout_ )
1980 { }
1981
1982 Kernel::TextState::TextState( const Kernel::TextState & newValues, const Kernel::TextState & oldValues )
1983 : relativeFlags_( oldValues.relativeFlags_ ),
1984 characterSpacing_( oldValues.characterSpacing_ ),
1985 wordSpacing_( oldValues.wordSpacing_ ),
1986 horizontalScaling_( oldValues.horizontalScaling_ ),
1987 leading_( oldValues.leading_ ),
1988 rise_( oldValues.rise_ ),
1989 font_( oldValues.font_ ),
1990 size_( oldValues.size_ ),
1991 mode_( oldValues.mode_ ),
1992 knockout_( oldValues.knockout_ )
1993 {
1994 if( newValues.hasCharacterSpacing( ) )
1995 {
1996 characterSpacing_ = newValues.characterSpacing_;
1997 relativeFlags_ = ( newValues.characterSpacingIsRelative( ) ? ( relativeFlags_ | RELATIVE_CHARACTER_SPACING ) : ( relativeFlags_ & ~RELATIVE_CHARACTER_SPACING ) );
1998 }
1999 if( newValues.hasWordSpacing( ) )
2000 {
2001 wordSpacing_ = newValues.wordSpacing_;
2002 relativeFlags_ = ( newValues.wordSpacingIsRelative( ) ? ( relativeFlags_ | RELATIVE_WORD_SPACING ) : ( relativeFlags_ & ~RELATIVE_WORD_SPACING ) );
2003 }
2004 if( ! IS_NAN( newValues.horizontalScaling_ ) )
2005 {
2006 horizontalScaling_ = newValues.horizontalScaling_;
2007 }
2008 if( newValues.hasLeading( ) )
2009 {
2010 leading_ = newValues.leading_;
2011 relativeFlags_ = ( newValues.leadingIsRelative( ) ? ( relativeFlags_ | RELATIVE_LEADING ) : ( relativeFlags_ & ~RELATIVE_LEADING ) );
2012 }
2013 if( newValues.hasRise( ) )
2014 {
2015 rise_ = newValues.rise_;
2016 relativeFlags_ = ( newValues.riseIsRelative( ) ? ( relativeFlags_ | RELATIVE_RISE ) : ( relativeFlags_ & ~RELATIVE_RISE ) );
2017 }
2018 if( newValues.font_ != NullPtr< const Lang::Font >( ) )
2019 {
2020 font_ = newValues.font_;
2021 }
2022 if( ! IS_NAN( newValues.size_ ) )
2023 {
2024 size_ = newValues.size_;
2025 }
2026 if( newValues.mode_ != Lang::TextRenderingMode::UNDEFINED )
2027 {
2028 mode_ = newValues.mode_;
2029 }
2030 if( ! ( newValues.knockout_ & KNOCKOUT_UNDEFINED_BIT ) )
2031 {
2032 knockout_ = newValues.knockout_;
2033 }
2034 }
2035
2036 std::map< bool, RefCountPtr< SimplePDF::PDF_Object > > Kernel::TextState::knockoutNameMap_;
2037
2038 Kernel::TextState::TextState( bool setDefaults )
2039 : relativeFlags_( RELATIVE_LEADING ),
2040 characterSpacing_( 0 ),
2041 wordSpacing_( 0 ),
2042 horizontalScaling_( 1 ),
2043 leading_( 1 ),
2044 rise_( 0 ),
2045 font_( Lang::THE_FONT_HELVETICA ),
2046 size_( Concrete::Length( 10 ) ),
2047 mode_( Lang::TextRenderingMode::FILL ),
2048 knockout_( 0 ) // this means false
2049 {
2050 if( ! setDefaults )
2051 {
2052 throw Exceptions::InternalError( strrefdup( "setDefaults must be true in TextState::TextState." ) );
2053 }
2054 }
2055
2056 Kernel::TextState::~TextState( )
2057 { }
2058
2059 void
2060 Kernel::TextState::print( std::ostream & os, const std::string & indentation ) const
2061 {
2062 if( font_ != NullPtr< const Lang::Font >( ) )
2063 {
2064 os << indentation << Interaction::DYNAMIC_VARIABLE_PREFIX << Lang::DYNAMIC_VARIABLE_ID_TEXT_FONT << ": " << font_->fontName( ) << std::endl ;
2065 }
2066 if( ! IS_NAN( size_ ) )
2067 {
2068 os << indentation << Interaction::DYNAMIC_VARIABLE_PREFIX << Lang::DYNAMIC_VARIABLE_ID_TEXT_SIZE << ": " << size_ / Interaction::displayUnit << Interaction::displayUnitName << std::endl ;
2069 }
2070 os << "(and a bunch of other variables...)" << std::endl ;
2071 }
2072
2073
2074 void
2075 Kernel::TextState::setLeading( const Concrete::Length leading )
2076 {
2077 relativeFlags_ &= ~ RELATIVE_LEADING;
2078 leading_ = leading;
2079 }
2080
2081 void
2082 Kernel::TextState::setLeading( const double relativeLeading )
2083 {
2084 relativeFlags_ |= RELATIVE_LEADING;
2085 leading_ = Concrete::Length( relativeLeading ); // We must keep track of this type trick by always looking at relativeFlags_ & RELATIVE_LEADING.
2086 }
2087
2088 RefCountPtr< const Lang::Value >
2089 Kernel::TextState::leading( ) const
2090 {
2091 if( leadingIsRelative( ) )
2092 {
2093 return RefCountPtr< const Lang::Value >( new Lang::Float( Concrete::Length::offtype( leading_ ) ) );
2094 }
2095 return RefCountPtr< const Lang::Value >( new Lang::Length( leading_ ) );
2096 }
2097
2098 Concrete::Length
2099 Kernel::TextState::leadingConcrete( ) const
2100 {
2101 if( leadingIsRelative( ) )
2102 {
2103 return Concrete::Length::offtype( leading_ ) * size_;
2104 }
2105 return leading_;
2106 }
2107
2108 bool
2109 Kernel::TextState::hasLeading( ) const
2110 {
2111 return ! IS_NAN( leading_ );
2112 }
2113
2114 bool
2115 Kernel::TextState::leadingIsRelative( ) const
2116 {
2117 return ( relativeFlags_ & RELATIVE_LEADING ) != 0;
2118 }
2119
2120
2121 void
2122 Kernel::TextState::setRise( const Concrete::Length rise )
2123 {
2124 relativeFlags_ &= ~ RELATIVE_RISE;
2125 rise_ = rise;
2126 }
2127
2128 void
2129 Kernel::TextState::setRise( const double relativeRise )
2130 {
2131 relativeFlags_ |= RELATIVE_RISE;
2132 rise_ = Concrete::Length( relativeRise ); // We must keep track of this type trick by always looking at relativeFlags_ & RELATIVE_RISE.
2133 }
2134
2135 RefCountPtr< const Lang::Value >
2136 Kernel::TextState::rise( ) const
2137 {
2138 if( riseIsRelative( ) )
2139 {
2140 return RefCountPtr< const Lang::Value >( new Lang::Float( Concrete::Length::offtype( rise_ ) ) );
2141 }
2142 return RefCountPtr< const Lang::Value >( new Lang::Length( rise_ ) );
2143 }
2144
2145 Concrete::Length
2146 Kernel::TextState::riseConcrete( ) const
2147 {
2148 if( riseIsRelative( ) )
2149 {
2150 return Concrete::Length::offtype( rise_ ) * size_;
2151 }
2152 return rise_;
2153 }
2154
2155 bool
2156 Kernel::TextState::hasRise( ) const
2157 {
2158 return ! IS_NAN( rise_ );
2159 }
2160
2161 bool
2162 Kernel::TextState::riseIsRelative( ) const
2163 {
2164 return ( relativeFlags_ & RELATIVE_RISE ) != 0;
2165 }
2166
2167
2168 void
2169 Kernel::TextState::setCharacterSpacing( const Concrete::Length spacing )
2170 {
2171 relativeFlags_ &= ~ RELATIVE_CHARACTER_SPACING;
2172 characterSpacing_ = spacing;
2173 }
2174
2175 void
2176 Kernel::TextState::setCharacterSpacing( const double relativeSpacing )
2177 {
2178 relativeFlags_ |= RELATIVE_CHARACTER_SPACING;
2179 characterSpacing_ = Concrete::Length( relativeSpacing ); // We must keep track of this type trick by always looking at the relevant bit in relativeFlags_.
2180 }
2181
2182 RefCountPtr< const Lang::Value >
2183 Kernel::TextState::characterSpacing( ) const
2184 {
2185 if( characterSpacingIsRelative( ) )
2186 {
2187 return RefCountPtr< const Lang::Value >( new Lang::Float( Concrete::Length::offtype( characterSpacing_ ) ) );
2188 }
2189 return RefCountPtr< const Lang::Value >( new Lang::Length( characterSpacing_ ) );
2190 }
2191
2192 Concrete::Length
2193 Kernel::TextState::characterSpacingConcrete( ) const
2194 {
2195 if( characterSpacingIsRelative( ) )
2196 {
2197 return Concrete::Length::offtype( characterSpacing_ ) * size_;
2198 }
2199 return characterSpacing_;
2200 }
2201
2202 bool
2203 Kernel::TextState::hasCharacterSpacing( ) const
2204 {
2205 return ! IS_NAN( characterSpacing_ );
2206 }
2207
2208 bool
2209 Kernel::TextState::characterSpacingIsRelative( ) const
2210 {
2211 return ( relativeFlags_ & RELATIVE_CHARACTER_SPACING ) != 0;
2212 }
2213
2214
2215 void
2216 Kernel::TextState::setWordSpacing( const Concrete::Length spacing )
2217 {
2218 relativeFlags_ &= ~ RELATIVE_WORD_SPACING;
2219 wordSpacing_ = spacing;
2220 }
2221
2222 void
2223 Kernel::TextState::setWordSpacing( const double relativeSpacing )
2224 {
2225 relativeFlags_ |= RELATIVE_WORD_SPACING;
2226 wordSpacing_ = Concrete::Length( relativeSpacing ); // We must keep track of this type trick by always looking at the relevant bit in relativeFlags_.
2227 }
2228
2229 RefCountPtr< const Lang::Value >
2230 Kernel::TextState::wordSpacing( ) const
2231 {
2232 if( wordSpacingIsRelative( ) )
2233 {
2234 return RefCountPtr< const Lang::Value >( new Lang::Float( Concrete::Length::offtype( wordSpacing_ ) ) );
2235 }
2236 return RefCountPtr< const Lang::Value >( new Lang::Length( wordSpacing_ ) );
2237 }
2238
2239 Concrete::Length
2240 Kernel::TextState::wordSpacingConcrete( ) const
2241 {
2242 if( wordSpacingIsRelative( ) )
2243 {
2244 return Concrete::Length::offtype( wordSpacing_ ) * size_;
2245 }
2246 return wordSpacing_;
2247 }
2248
2249 bool
2250 Kernel::TextState::hasWordSpacing( ) const
2251 {
2252 return ! IS_NAN( wordSpacing_ );
2253 }
2254
2255 bool
2256 Kernel::TextState::wordSpacingIsRelative( ) const
2257 {
2258 return ( relativeFlags_ & RELATIVE_WORD_SPACING ) != 0;
2259 }
2260
2261
2262 bool
2263 Kernel::TextState::synchAssertKnockout( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool clip, bool force )
2264 {
2265 assertKnockout( ref );
2266 return synchButKnockout( os, ref, resources, clip, force );
2267 }
2268
2269 bool
2270 Kernel::TextState::synchCharacterSpacing( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force )
2271 {
2272 if( force ||
2273 characterSpacing_ != ref->characterSpacing_ ||
2274 characterSpacingIsRelative( ) != ref->characterSpacingIsRelative( ) )
2275 {
2276 if( ! ref->hasCharacterSpacing( ) )
2277 {
2278 return false;
2279 }
2280 relativeFlags_ = ( ref->characterSpacingIsRelative( ) ? ( relativeFlags_ | RELATIVE_CHARACTER_SPACING ) : ( relativeFlags_ & ~RELATIVE_CHARACTER_SPACING ) );
2281 characterSpacing_ = ref->characterSpacing_;
2282 if( characterSpacingIsRelative( ) )
2283 {
2284 os << Concrete::Length::offtype( characterSpacing_ ) * Concrete::Length::offtype( ref->size_ ) << " Tc " ;
2285 }
2286 else
2287 {
2288 os << Concrete::Length::offtype( characterSpacing_ ) << " Tc " ;
2289 }
2290 return true;
2291 }
2292 return false;
2293 }
2294
2295 bool
2296 Kernel::TextState::synchWordSpacing( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force )
2297 {
2298 if( force ||
2299 wordSpacing_ != ref->wordSpacing_ ||
2300 wordSpacingIsRelative( ) != ref->wordSpacingIsRelative( ) )
2301 {
2302 if( ! ref->hasWordSpacing( ) )
2303 {
2304 return false;
2305 }
2306 relativeFlags_ = ( ref->wordSpacingIsRelative( ) ? ( relativeFlags_ | RELATIVE_WORD_SPACING ) : ( relativeFlags_ & ~RELATIVE_WORD_SPACING ) );
2307 wordSpacing_ = ref->wordSpacing_;
2308 if( wordSpacingIsRelative( ) )
2309 {
2310 os << Concrete::Length::offtype( wordSpacing_ ) * Concrete::Length::offtype( ref->size_ ) << " Tw " ;
2311 }
2312 else
2313 {
2314 os << Concrete::Length::offtype( wordSpacing_ ) << " Tw " ;
2315 }
2316 return true;
2317 }
2318 return false;
2319 }
2320
2321 bool
2322 Kernel::TextState::synchHorizontalScaling( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force )
2323 {
2324 if( force || horizontalScaling_ != ref->horizontalScaling_ )
2325 {
2326 if( IS_NAN( ref->horizontalScaling_ ) )
2327 {
2328 return false;
2329 }
2330 horizontalScaling_ = ref->horizontalScaling_;
2331 os << 100 * horizontalScaling_ << " Tz " ;
2332 return true;
2333 }
2334 return false;
2335 }
2336
2337 bool
2338 Kernel::TextState::synchLeading( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force )
2339 {
2340 if( force ||
2341 leading_ != ref->leading_ ||
2342 leadingIsRelative( ) != ref->leadingIsRelative( ) )
2343 {
2344 if( ! ref->hasLeading( ) )
2345 {
2346 return false;
2347 }
2348 relativeFlags_ = ( ref->leadingIsRelative( ) ? ( relativeFlags_ | RELATIVE_LEADING ) : ( relativeFlags_ & ~RELATIVE_LEADING ) );
2349 leading_ = ref->leading_;
2350 if( leadingIsRelative( ) )
2351 {
2352 os << Concrete::Length::offtype( leading_ ) * Concrete::Length::offtype( ref->size_ ) << " TL " ;
2353 }
2354 else
2355 {
2356 os << Concrete::Length::offtype( leading_ ) << " TL " ;
2357 }
2358 return true;
2359 }
2360 return false;
2361 }
2362
2363 bool
2364 Kernel::TextState::synchFontAndSize( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force )
2365 {
2366 if( force ||
2367 font_ != ref->font_ ||
2368 size_ != ref->size_ )
2369 {
2370 if( ref->font_ == NullPtr< const Lang::Font >( ) &&
2371 IS_NAN( ref->size_ ) )
2372 {
2373 return false;
2374 }
2375 if( ref->font_ == NullPtr< const Lang::Font >( ) ||
2376 IS_NAN( ref->size_ ) )
2377 {
2378 throw Exceptions::MiscellaneousRequirement( "It is impossible to leave unspecified only one of font and size." );
2379 }
2380 bool sizeChanged = ( size_ != ref->size_ );
2381 font_ = ref->font_;
2382 size_ = ref->size_;
2383 os << resources->nameofFont( font_->resource( ) ) << " " << Concrete::Length::offtype( size_ ) << " Tf " ;
2384 if( sizeChanged )
2385 {
2386 if( ref->hasLeading( ) && ref->leadingIsRelative( ) )
2387 {
2388 synchLeading( os, ref, resources, true );
2389 }
2390 if( ref->hasRise( ) && ref->riseIsRelative( ) )
2391 {
2392 synchRise( os, ref, resources, true );
2393 }
2394 if( ref->hasCharacterSpacing( ) && ref->characterSpacingIsRelative( ) )
2395 {
2396 synchCharacterSpacing( os, ref, resources, true );
2397 }
2398 if( ref->hasWordSpacing( ) && ref->wordSpacingIsRelative( ) )
2399 {
2400 synchWordSpacing( os, ref, resources, true );
2401 }
2402 }
2403 return true;
2404 }
2405 return false;
2406 }
2407
2408 bool
2409 Kernel::TextState::synchMode( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool clip, bool force )
2410 {
2411 Lang::TextRenderingMode::ValueType refMode = clip ? Lang::TextRenderingMode::clipMode( ref->mode_ ) : ref->mode_ ;
2412 if( force || mode_ != refMode )
2413 {
2414 if( ref->mode_ == Lang::TextRenderingMode::UNDEFINED )
2415 {
2416 return false;
2417 }
2418 mode_ = refMode;
2419 os << mode_ << " Tr " ;
2420 return true;
2421 }
2422 return false;
2423 }
2424
2425 bool
2426 Kernel::TextState::synchRise( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force )
2427 {
2428 if( force ||
2429 rise_ != ref->rise_ ||
2430 riseIsRelative( ) != ref->riseIsRelative( ) )
2431 {
2432 if( ! ref->hasRise( ) )
2433 {
2434 return false;
2435 }
2436 relativeFlags_ = ( ref->riseIsRelative( ) ? ( relativeFlags_ | RELATIVE_RISE ) : ( relativeFlags_ & ~RELATIVE_RISE ) );
2437 rise_ = ref->rise_;
2438 if( riseIsRelative( ) )
2439 {
2440 os << Concrete::Length::offtype( rise_ ) * Concrete::Length::offtype( ref->size_ ) << " Ts " ;
2441 }
2442 else
2443 {
2444 os << Concrete::Length::offtype( rise_ ) << " Ts " ;
2445 }
2446 return true;
2447 }
2448 return false;
2449 }
2450
2451 bool
2452 Kernel::TextState::synchKnockout( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force )
2453 {
2454 if( force || knockout_ != ref->knockout_ )
2455 {
2456 if( ( ref->knockout_ & Kernel::TextState::KNOCKOUT_UNDEFINED_BIT ) != 0 )
2457 {
2458 return false;
2459 }
2460 const SimplePDF::PDF_Version::Version KNOCKOUT_VERSION = SimplePDF::PDF_Version::PDF_1_4;
2461 if( ! Kernel::the_PDF_version.greaterOrEqual( KNOCKOUT_VERSION ) )
2462 {
2463 Kernel::the_PDF_version.message( KNOCKOUT_VERSION, "The text state knockout mode setting was ignored." );
2464 }
2465 knockout_ = ref->knockout_;
2466 typedef typeof knockoutNameMap_ MapType;
2467 MapType::const_iterator i = knockoutNameMap_.find( knockout_ );
2468 if( i != knockoutNameMap_.end( ) )
2469 {
2470 os << resources->nameofGraphicsState( i->second ) << " gs " ;
2471 }
2472 else
2473 {
2474 RefCountPtr< SimplePDF::PDF_Dictionary > dic;
2475 (*dic)[ "Type" ] = SimplePDF::newName( "ExtGState" );
2476 (*dic)[ "TK" ] = SimplePDF::newBoolean( knockout_ );
2477
2478 RefCountPtr< SimplePDF::PDF_Object > indirection = SimplePDF::indirect( dic, & Kernel::theIndirectObjectCount );
2479 knockoutNameMap_.insert( MapType::value_type( knockout_, indirection ) );
2480
2481 os << resources->nameofGraphicsState( indirection ) << " gs " ;
2482 }
2483 return true;
2484 }
2485 return false;
2486 }
2487
2488 void
2489 Kernel::TextState::assertKnockout( const Kernel::TextState * ref )
2490 {
2491 if( knockout_ != ref->knockout_ )
2492 {
2493 throw Exceptions::MiscellaneousRequirement( "PDF does not allow the text knockout mode to change within a text object." );
2494 }
2495 }
2496
2497 bool
2498 Kernel::TextState::synchButKnockout( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool clip, bool force )
2499 {
2500 bool anyChange = false;
2501 anyChange = synchCharacterSpacing( os, ref, resources, force ) || anyChange;
2502 anyChange = synchWordSpacing( os, ref, resources, force ) || anyChange;
2503 anyChange = synchHorizontalScaling( os, ref, resources, force ) || anyChange;
2504 anyChange = synchFontAndSize( os, ref, resources, force ) || anyChange;
2505 anyChange = synchLeading( os, ref, resources, force ) || anyChange; // It is important that this is done after synching the size!
2506 anyChange = synchMode( os, ref, resources, clip, force ) || anyChange;
2507 anyChange = synchRise( os, ref, resources, force ) || anyChange;
2508 if( anyChange )
2509 {
2510 os << std::endl ;
2511 }
2512 return anyChange;
2513 }
Graphics language