?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Example: Changed glyph-outline.shape for use with FontConfig.
[shapes.git] / source / texttypes.cc
blobb5ff4ae2299a3693d4f0a128f9182e810bd409a7
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, 2010 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 "methodbase.h"
34 #include "shapescore.h"
35 #include "config.h"
36
37 #include <fstream>
38 #include <sys/types.h>
39 #include <sys/stat.h>
40 #include <stdint.h>
41 #include <cstddef>
42 #include <iomanip>
43
44 #ifdef HAVE_FT2
45 #include FT_OUTLINE_H
46 #endif
47
48 using namespace Shapes;
49
50 std::map< RefCountPtr< const char >, RefCountPtr< SimplePDF::PDF_Object >, charRefPtrLess > Lang::Font::theFontResourceMap_;
51 std::map< RefCountPtr< const char >, RefCountPtr< const FontMetrics::FontMetric >, charRefPtrLess > Lang::Font::theFontMetricsMap_;
52 std::list< std::string > Lang::Font::theFontMetricsSearchPath_;
53
54 namespace Shapes
55 {
56 namespace Helpers
57 {
58 Kernel::StructureFactory FontMethod_glyph_resultFactory( "painter", "paths" );
59 }
60 }
61
62 SimplePDF::PDF_ToUnicode::PDF_ToUnicode( RefCountPtr< CharSet > charSet, const RefCountPtr< const Shapes::Lang::Font > & font )
63 : charSet_( charSet ),
64 font_( font )
65 {
66 dic[ "Filter" ] = SimplePDF::newName( "FlateDecode" );
67 }
68
69 SimplePDF::PDF_ToUnicode::~PDF_ToUnicode( )
70 { }
71
72 void
73 SimplePDF::PDF_ToUnicode::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
74 {
75 std::ostringstream & wdata = const_cast< std::ostringstream & >( data );
76 wdata << std::setfill( '0' );
77 wdata << "/CIDInit /ProcSet findresource begin" << std::endl
78 << "12 dict begin" << std::endl
79 << "begincmap" << std::endl
80 << "/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def" << std::endl
81 << "/CMapName /Adobe-Identity-UCS def" << std::endl
82 << "/CMapType 2 def" << std::endl
83 << "1 begincodespacerange" << std::endl
84 << "<0000> <FFFF>" << std::endl
85 << "endcodespacerange" << std::endl ;
86 const size_t bufSize = 10;
87 unsigned char buf[ bufSize ];
88 size_t remaining = charSet_->size( );
89 size_t room = std::min( static_cast< size_t >( 100 ), remaining );
90 remaining -= room;
91 wdata << room << " beginbfchar" << std::endl ;
92 for( CharSet::const_iterator i = charSet_->begin( ); i != charSet_->end( ); ++i, --room )
93 {
94 if( room == 0 )
95 {
96 wdata << "endbfchar" << std::endl ;
97 room = std::min( static_cast< size_t >( 100 ), remaining );
98 remaining -= room;
99 wdata << room << " beginbfchar" << std::endl ;
100 }
101 size_t out_avail = 2;
102 unsigned char * out_buf = buf;
103 font_->encode( *i, reinterpret_cast< char ** >( & out_buf ), & out_avail );
104 if( out_avail != 0 )
105 {
106 throw Exceptions::InternalError( "Expected the encoded character to occupy exactly two bytes." );
107 }
108 wdata << "<" << std::hex << std::setw( 2 ) << static_cast< int >( buf[0] ) << std::hex << std::setw( 2 ) << static_cast< int >( buf[1] ) << "> " ;
109 out_avail = bufSize;
110 out_buf = buf;
111 i->encode_UTF16BE( reinterpret_cast< char ** >( & out_buf ), & out_avail );
112 wdata << "<" ;
113 for( const unsigned char * c = buf; c != out_buf; ++c )
114 {
115 wdata << std::hex << std::setw( 2 ) << static_cast< int >( *c ) ;
116 }
117 wdata << ">" << std::endl ;
118 }
119 wdata << "endbfchar" << std::endl
120 << "endcmap" << std::endl
121 << "CMapName currentdict /CMap defineresource pop" << std::endl
122 << "end" << std::endl
123 << "end" ; /* No need to put a newline at the end. */
124 PDF_Stream_out::writeTo( os, xref, self );
125 }
126
127 SimplePDF::PDF_Widths::PDF_Widths( RefCountPtr< CharSet > charSet, const RefCountPtr< const Shapes::Lang::Font > & font )
128 : charSet_( charSet ),
129 font_( font )
130 { }
131
132 SimplePDF::PDF_Widths::~PDF_Widths( )
133 { }
134
135 void
136 SimplePDF::PDF_Widths::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
137 {
138 const FontMetrics::WritingDirectionMetrics * metrics = font_->metrics( )->horizontalMetrics_.getPtr( );
139 const size_t bufSize = 2;
140 unsigned char buf[ bufSize ];
141 VecType & wvec = const_cast< VecType & >( vec );
142 FontMetrics::CharacterMetrics m( 0 );
143 for( CharSet::const_iterator i = charSet_->begin( ); i != charSet_->end( ); )
144 {
145 CharSet::const_iterator j = i;
146 CharSet::const_iterator last = i;
147 ++i;
148 for( ; i != charSet_->end( ) && i->get_UCS4( ) == last->get_UCS4( ) + 1; last = i, ++i )
149 ;
150 size_t out_avail = bufSize;
151 unsigned char * out_buf = buf;
152 font_->encode( j->get_UCS4( ), reinterpret_cast< char ** >( & out_buf ), & out_avail );
153 if( out_avail != 0 )
154 {
155 throw Exceptions::InternalError( "Expected the encoded character to occupy exactly two bytes." );
156 }
157 wvec.push_back( SimplePDF::newInt( static_cast< SimplePDF::PDF_Int::ValueType >( buf[0] ) * 0x100 +
158 static_cast< SimplePDF::PDF_Int::ValueType >( buf[1] ) ) );
159 SimplePDF::PDF_Vector * sub_vec = new SimplePDF::PDF_Vector;
160 wvec.push_back( RefCountPtr< SimplePDF::PDF_Object >( sub_vec ) );
161 for( ; j != i; ++j )
162 {
163 sub_vec->vec.push_back( SimplePDF::newFloat( metrics->charByCode( j->get_UCS4( ), & m )->horizontalCharWidthX_* 1000 ) );
164 }
165 }
166 PDF_Vector::writeTo( os, xref, self );
167 }
168
169 namespace Shapes
170 {
171
172 namespace Lang
173 {
174
175 class FontMethod_glyph : public Lang::MethodBase< Lang::Font >
176 {
177 public:
178 FontMethod_glyph( RefCountPtr< const Lang::Font > _self, const Ast::FileID * fullMethodID );
179 virtual ~FontMethod_glyph( );
180 virtual void call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const;
181 static const char * staticFieldID( ) { return "glyph"; }
182 };
183
184 }
185 }
186
187 void
188 Font_register_methods( Lang::SystemFinalClass * dstClass )
189 {
190 dstClass->registerMethod( new Kernel::MethodFactory< Lang::Font, Lang::FontMethod_glyph >( ) );
191 }
192
193 void
194 Lang::Font::push_backFontMetricsPath( const std::string & path )
195 {
196 if( path.empty( ) ||
197 path[ path.size( ) - 1 ] == '/' )
198 {
199 theFontMetricsSearchPath_.push_back( path );
200 }
201 else
202 {
203 theFontMetricsSearchPath_.push_back( path + "/" );
204 }
205 }
206
207 std::string
208 Lang::Font::searchGlyphList( )
209 {
210 std::string res;
211
212 if( theFontMetricsSearchPath_.empty( ) )
213 {
214 throw Exceptions::ExternalError( strrefdup( "The font metrics path was not set up (needed for the glyph list). Consider defining the environment variable SHAPESFONTMETRICS." ) );
215 }
216
217 typedef typeof theFontMetricsSearchPath_ ListType;
218 for( ListType::const_iterator i = theFontMetricsSearchPath_.begin( ); i != theFontMetricsSearchPath_.end( ); ++i )
219 {
220 res = *i + "glyphlist.txt";
221 struct stat theStatDummy;
222 if( stat( res.c_str( ), & theStatDummy ) == 0 )
223 {
224 return res;
225 }
226 }
227 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." );
228 }
229
230 std::string
231 Lang::Font::searchFontMetrics( RefCountPtr< const char > fontName )
232 {
233 std::string res;
234
235 if( strlen( fontName.getPtr( ) ) == 0 )
236 {
237 throw Exceptions::InternalError( strrefdup( "Lang::Font::searchFontMetrics called with empty argument." ) );
238 }
239
240 if( *fontName.getPtr( ) == '/' )
241 {
242 throw Exceptions::InternalError( "The font name cannot begin with \"/\", as if is was an absolute path to something." );
243 }
244
245 if( theFontMetricsSearchPath_.empty( ) )
246 {
247 throw Exceptions::ExternalError( strrefdup( "The font metrics path was not set up. Consider defining the environment variable SHAPESFONTMETRICS." ) );
248 }
249
250 typedef typeof theFontMetricsSearchPath_ ListType;
251 for( ListType::const_iterator i = theFontMetricsSearchPath_.begin( ); i != theFontMetricsSearchPath_.end( ); ++i )
252 {
253 res = *i + fontName.getPtr( ) + ".afm";
254 struct stat theStatDummy;
255 if( stat( res.c_str( ), & theStatDummy ) == 0 )
256 {
257 return res;
258 }
259 }
260 throw Exceptions::MissingFontMetrics( fontName, & theFontMetricsSearchPath_ );
261 }
262
263 std::string
264 Lang::Font::searchCharacterEncoding( const char * encodingName )
265 {
266 std::string res;
267
268 if( theFontMetricsSearchPath_.empty( ) )
269 {
270 throw Exceptions::ExternalError( strrefdup( "The font metrics path was not set up. Consider defining the environment variable SHAPESFONTMETRICS." ) );
271 }
272
273 typedef typeof theFontMetricsSearchPath_ ListType;
274 for( ListType::const_iterator i = theFontMetricsSearchPath_.begin( ); i != theFontMetricsSearchPath_.end( ); ++i )
275 {
276 res = *i + encodingName + ".enc";
277 struct stat theStatDummy;
278 if( stat( res.c_str( ), & theStatDummy ) == 0 )
279 {
280 return res;
281 }
282 }
283 std::ostringstream msg;
284 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." ;
285 throw Exceptions::MiscellaneousRequirement( strrefdup( msg ) );
286 }
287
288
289 Lang::Font::Font( const RefCountPtr< const char > fontName, RefCountPtr< SimplePDF::PDF_Object > & resource, RefCountPtr< const FontMetrics::FontMetric > metrics )
290 : fontName_( fontName ), resource_( resource ), metrics_( metrics )
291 {
292 // If this font has been instantiated before, it is reused.
293 {
294 typedef typeof theFontResourceMap_ MapType;
295 MapType::const_iterator i = theFontResourceMap_.find( fontName_ );
296 if( i != theFontResourceMap_.end( ) )
297 {
298 resource_ = i->second;
299 }
300 else
301 {
302 theFontResourceMap_.insert( MapType::value_type( fontName_, resource_ ) );
303 }
304 }
305 {
306 typedef typeof theFontMetricsMap_ MapType;
307 MapType::const_iterator i = theFontMetricsMap_.find( fontName_ );
308 if( i != theFontMetricsMap_.end( ) )
309 {
310 metrics_ = i->second;
311 }
312 else if( metrics_ != NullPtr< const FontMetrics::FontMetric >( ) )
313 {
314 theFontMetricsMap_.insert( MapType::value_type( fontName_, metrics_ ) );
315 }
316 }
317 }
318
319 // Note that we must not initialize name_ with builtinFontMap_[ fontConst ] here, since builtinFontMap_ may not be
320 // initialized when this constructor is invoked from globals.cc.
321 Lang::Font::Font( const RefCountPtr< const char > fontName )
322 : fontName_( fontName ), resource_( NullPtr< SimplePDF::PDF_Object >( ) ), metrics_( NullPtr< const FontMetrics::FontMetric >( ) )
323 { }
324
325 Lang::Font::~Font( )
326 { }
327
328 Kernel::VariableHandle
329 Lang::Font::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
330 {
331 // if( strcmp( fieldID, "CIDFont?" ) == 0 )
332 // {
333 // return Helpers::newValHandle( new Lang::Boolean( metrics_->isCIDFont_ ) );
334 // }
335 if( strcmp( fieldID, "kerning?" ) == 0 )
336 {
337 return Helpers::newValHandle( new Lang::Boolean( metrics_->hasKerning_ ) );
338 }
339 if( strcmp( fieldID, "family" ) == 0 )
340 {
341 return Kernel::VariableHandle( new Kernel::Variable( this->family_name( ) ) );
342 }
343 if( strcmp( fieldID, "style" ) == 0 )
344 {
345 return Kernel::VariableHandle( new Kernel::Variable( this->style_name( ) ) );
346 }
347 if( strcmp( fieldID, "PostScript_name" ) == 0 )
348 {
349 return Kernel::VariableHandle( new Kernel::Variable( this->PostScript_name( ) ) );
350 }
351
352 return TypeID->getMethod( selfRef, fieldID ); /* This will throw if there is no such method. */
353 }
354
355 RefCountPtr< const Lang::String >
356 Lang::Font::family_name( ) const
357 {
358 return RefCountPtr< const Lang::String >( new Lang::String( fontName_ ) );
359 }
360
361 RefCountPtr< const Lang::String >
362 Lang::Font::style_name( ) const
363 {
364 return RefCountPtr< const Lang::String >( new Lang::String( "", true ) );
365 }
366
367 RefCountPtr< const Lang::Symbol >
368 Lang::Font::PostScript_name( ) const
369 {
370 return RefCountPtr< const Lang::Symbol >( new Lang::Symbol( fontName_.getPtr( ) ) );
371 }
372
373 RefCountPtr< const Lang::Value >
374 Lang::Font::getGlyph( Kernel::UnicodeCodePoint c, Concrete::Length size ) const
375 {
376 throw Exceptions::MiscellaneousRequirement( "It is not possible to extract individual glyphs from this font." );
377 }
378
379
380 const RefCountPtr< SimplePDF::PDF_Object > &
381 Lang::Font::resource( ) const
382 {
383 if( resource_ != NullPtr< SimplePDF::PDF_Object >( ) )
384 {
385 return resource_;
386 }
387
388 typedef typeof theFontResourceMap_ MapType;
389
390 {
391 MapType::const_iterator i = theFontResourceMap_.find( fontName_ );
392 if( i != theFontResourceMap_.end( ) )
393 {
394 resource_ = i->second;
395 return resource_;
396 }
397 }
398
399 {
400 RefCountPtr< SimplePDF::PDF_Dictionary > dic;
401 resource_ = SimplePDF::indirect( dic, & Kernel::theIndirectObjectCount );
402 (*dic)[ "Type" ] = SimplePDF::newName( "Font" );
403 (*dic)[ "Subtype" ] = SimplePDF::newName( "Type1" );
404 (*dic)[ "Encoding" ] = SimplePDF::newName( "MacRomanEncoding" );
405 (*dic)[ "BaseFont" ] = SimplePDF::newName( fontName_.getPtr( ) ); // Here, it is crucial that this is really a built-in font!
406 }
407 return resource_;
408 }
409
410 RefCountPtr< const char >
411 Lang::Font::fontName( ) const
412 {
413 return fontName_;
414 }
415
416 RefCountPtr< const FontMetrics::FontMetric >
417 Lang::Font::metrics( ) const
418 {
419 if( metrics_ != NullPtr< const FontMetrics::FontMetric >( ) )
420 {
421 return metrics_;
422 }
423
424 // Otherwise, we hope that we can find an Adobe Font Metrics file.
425 std::string filename = searchFontMetrics( fontName_ );
426 std::ifstream afmFile( filename.c_str( ) );
427 if( ! afmFile.is_open( ) )
428 {
429 std::ostringstream oss;
430 oss << "File has been located but couldn't be opened: " << filename ;
431 throw Exceptions::ExternalError( strrefdup( oss ) );
432 }
433
434 // I fiddle a little with the consts here...
435 FontMetrics::AFM * newMetrics = new FontMetrics::AFM;
436 metrics_ = RefCountPtr< const FontMetrics::FontMetric >( newMetrics );
437
438 AfmScanner scanner( newMetrics, & afmFile );
439 scanner.setTellQue( Interaction::fontMetricMessages ); // We want to know about things that are not recognized and this ignored.
440 if( Interaction::fontMetricDebug )
441 {
442 scanner.set_debug( 1 );
443 }
444 try
445 {
446 int status = scanner.yylex( );
447 if( status != 0 )
448 {
449 std::ostringstream oss;
450 oss << "Font metrics parser returned with non-zero status: " << status ;
451 throw Exceptions::InternalError( strrefdup( oss ) );
452 }
453 }
454 catch( const char * ball )
455 {
456 std::ostringstream oss;
457 oss << "Font metrics parser failed with message: " << ball ;
458 throw Exceptions::InternalError( strrefdup( oss ) );
459 }
460 catch( const RefCountPtr< const char > ball )
461 {
462 std::ostringstream oss;
463 oss << "Font metrics parser failed with message: " << ball ;
464 throw Exceptions::InternalError( strrefdup( oss ) );
465 }
466
467 return metrics_;
468 }
469
470 void
471 Lang::Font::show( std::ostream & os ) const
472 {
473 os << "< font: " << fontName_ << " >" ;
474 }
475
476 void
477 Lang::Font::gcMark( Kernel::GCMarkedSet & marked )
478 { }
479
480 RefCountPtr< const Lang::Class > Lang::Font::TypeID( new Lang::SystemFinalClass( strrefdup( "Font" ), Font_register_methods ) );
481 TYPEINFOIMPL( Font );
482
483
484 Lang::PDFStandardFont::PDFStandardFont( const RefCountPtr< const char > builtInFontName )
485 : Lang::Font( builtInFontName )
486 { }
487
488 Lang::PDFStandardFont::~PDFStandardFont( )
489 { }
490
491 void
492 Lang::PDFStandardFont::encode( const char ** text_UTF8, size_t * in_avail, char ** dst_PDF, size_t * out_avail ) const
493 {
494 encode_MacRoman( text_UTF8, in_avail, dst_PDF, out_avail );
495 }
496
497 void
498 Lang::PDFStandardFont::encode( Kernel::UnicodeCodePoint c, char ** dst_PDF, size_t * out_avail ) const
499 {
500 encode_MacRoman( c, dst_PDF, out_avail );
501 }
502
503 void
504 Lang::PDFStandardFont::encode_MacRoman( const char ** text_UTF8, size_t * in_avail, char ** dst_PDF, size_t * out_avail )
505 {
506 iconv_t converter = Helpers::requireUTF8ToMacRomanConverter( );
507 // The ICONV_CAST macro is defined in config.h.
508 size_t count = iconv( converter,
509 ICONV_CAST( text_UTF8 ), in_avail,
510 dst_PDF, out_avail );
511 if( count == (size_t)(-1) )
512 {
513 if( errno == EILSEQ )
514 {
515 throw Exceptions::MiscellaneousRequirement( "It is suspected that one of the UFT-8 characters used in showed text cannot be represented in the MacRoman encoding (used for the 14 standard fonts of PDF; consider using a normal font instead)." );
516 }
517 else if( errno == EINVAL )
518 {
519 throw Exceptions::MiscellaneousRequirement( "It is suspected that showed text ended with an incomplete multibyte character." );
520 }
521 else if( errno == E2BIG )
522 {
523 throw Exceptions::InternalError( "The buffer allocated for UTF-8 to PDF show-text string conversion was too small." );
524 }
525 else
526 {
527 std::ostringstream msg;
528 msg << "iconv failed with an unrecognized error code: " << errno ;
529 throw Exceptions::InternalError( strrefdup( msg ) );
530 }
531 }
532 }
533
534 void
535 Lang::PDFStandardFont::encode_MacRoman( Kernel::UnicodeCodePoint c, char ** dst_PDF, size_t * out_avail )
536 {
537 if( *out_avail < 1 )
538 {
539 throw Exceptions::InternalError( "The buffer allocated conversion of a single UCS-4 to MacRoman was too small." );
540 }
541 **dst_PDF = c.get_MacRoman( );
542 ++*dst_PDF;
543 --*out_avail;
544 }
545
546
547 Lang::Type3Font::Type3Font( const RefCountPtr< const char > fontName, RefCountPtr< SimplePDF::PDF_Object > & resource, RefCountPtr< const FontMetrics::FontMetric > metrics )
548 : Lang::Font( fontName, resource, metrics )
549 { }
550
551 Lang::Type3Font::~Type3Font( )
552 { }
553
554 void
555 Lang::Type3Font::encode( const char ** text_UTF8, size_t * in_avail, char ** dst_PDF, size_t * out_avail ) const
556 {
557 Lang::PDFStandardFont::encode_MacRoman( text_UTF8, in_avail, dst_PDF, out_avail );
558 }
559
560 void
561 Lang::Type3Font::encode( Kernel::UnicodeCodePoint c, char ** dst_PDF, size_t * out_avail ) const
562 {
563 Lang::PDFStandardFont::encode_MacRoman( c, dst_PDF, out_avail );
564 }
565
566
567
568 #ifdef HAVE_FT2
569
570 Lang::FreeTypeFont::FreeTypeFont( FT_Face face, const RefCountPtr< const char > fontName, RefCountPtr< SimplePDF::PDF_Object > & resource, RefCountPtr< const FontMetrics::FontMetric > metrics, RefCountPtr< SimplePDF::PDF_ToUnicode::CharSet > & usedChars )
571 : Lang::Font( fontName, resource, metrics ),
572 face_( face ),
573 usedChars_( usedChars )
574 { }
575
576 Lang::FreeTypeFont::~FreeTypeFont( )
577 { }
578
579 void
580 Lang::FreeTypeFont::encode( const char ** text_UTF8, size_t * in_avail, char ** dst_PDF, size_t * out_avail ) const
581 {
582 iconv_t converter = Helpers::requireUTF8ToUCS4Converter( );
583
584 size_t bufSize = 4 * *in_avail;
585 char * buf = new char[ bufSize ];
586 char * outbuf = buf;
587 DeleteOnExit< char > bufDeleter( buf );
588
589 // The ICONV_CAST macro is defined in config.h.
590 size_t count = iconv( converter,
591 ICONV_CAST( text_UTF8 ), in_avail,
592 & outbuf, & bufSize );
593 if( count == (size_t)(-1) )
594 {
595 if( errno == EILSEQ )
596 {
597 throw Exceptions::MiscellaneousRequirement( "Failed to convert from UTF-8 to UCS-4 code points." );
598 }
599 else if( errno == EINVAL )
600 {
601 throw Exceptions::MiscellaneousRequirement( "It is suspected that showed text ended with an incomplete multibyte character." );
602 }
603 else if( errno == E2BIG )
604 {
605 throw Exceptions::InternalError( "The temporary UCS-4 buffer allocated for UTF-8 to PDF show-text string conversion was too small." );
606 }
607 else
608 {
609 std::ostringstream msg;
610 msg << "iconv failed with an unrecognized error code: " << errno ;
611 throw Exceptions::InternalError( strrefdup( msg ) );
612 }
613 }
614 /* The number of characters equals ( outbuf - buf ) / 4, so the memory needed to store these equals
615 * 2 * ( outbuf - buf ) / 4 = ( outbuf - buf ) / 2
616 */
617 if( static_cast< ptrdiff_t >( *out_avail ) < ( outbuf - buf ) / 2 )
618 {
619 throw Exceptions::InternalError( "The buffer allocated for UTF-8 to PDF show-text string conversion was too small." );
620 }
621 *out_avail -= ( outbuf - buf ) / 2;
622 for( const char * src = buf; src != outbuf; src += 4)
623 {
624 Kernel::UnicodeCodePoint code;
625 code.decode_UCS4( src );
626 usedChars_->insert( usedChars_->begin( ), code );
627 FT_UInt index = FT_Get_Char_Index( face_, code.get_UCS4( ) );
628 if( index == 0 )
629 {
630 std::cerr << "Warning: Missing glyph: " << code.get_UCS4( ) << std::endl ;
631 }
632 if( index > 0xFFFF )
633 {
634 throw Exceptions::InternalError( "PDF text encoding: Glyph index is out of the two byte code range." );
635 }
636 /* Remember that the endianness is unknown! Hence, don't */
637 // *reinterpret_cast< uint16_t * >( *dst_PDF ) = index;
638 // *dst_PDF += 2;
639 /* ... but do */
640 **dst_PDF = index / 0x100;
641 ++*dst_PDF;
642 **dst_PDF = index % 0x100;
643 ++*dst_PDF;
644 }
645 }
646
647 void
648 Lang::FreeTypeFont::encode( Kernel::UnicodeCodePoint c, char ** dst_PDF, size_t * out_avail ) const
649 {
650 if( *out_avail < 2 )
651 {
652 throw Exceptions::InternalError( "The buffer allocated conversion of one UCS-4 code point to PDF show-text encoding was too small." );
653 }
654 FT_UInt index = FT_Get_Char_Index( face_, c.get_UCS4( ) );
655 if( index == 0 )
656 {
657 std::cerr << "Warning: Missing glyph: " << c.get_UCS4( ) << std::endl ;
658 }
659 if( index > 0xFFFF )
660 {
661 throw Exceptions::InternalError( "PDF text encoding: Glyph index is out of the two byte code range." );
662 }
663 /* Remember that the endianness is unknown! Hence, don't */
664 // *reinterpret_cast< uint16_t * >( *dst_PDF ) = index;
665 // *dst_PDF += 2;
666 /* ... but do */
667 **dst_PDF = index / 0x100;
668 ++*dst_PDF;
669 **dst_PDF = index % 0x100;
670 ++*dst_PDF;
671 *out_avail -= 2;
672 }
673
674 RefCountPtr< const Lang::String >
675 Lang::FreeTypeFont::family_name( ) const
676 {
677 return RefCountPtr< const Lang::String >( new Lang::String( face_->family_name, true ) );
678 }
679
680 RefCountPtr< const Lang::String >
681 Lang::FreeTypeFont::style_name( ) const
682 {
683 return RefCountPtr< const Lang::String >( new Lang::String( face_->style_name, true ) );
684 }
685
686 RefCountPtr< const Lang::Symbol >
687 Lang::FreeTypeFont::PostScript_name( ) const
688 {
689 const char * PostScriptName = FT_Get_Postscript_Name( face_ );
690 if( PostScriptName == 0 )
691 {
692 throw Exceptions::MiscellaneousRequirement( "The FreeType font does not provide a PostScript name." );
693 }
694 /* It is assumed that the created symbol is not used after the face_ is destroyed! */
695 return RefCountPtr< const Lang::Symbol >( new Lang::Symbol( PostScriptName ) );
696 }
697
698 namespace Shapes
699 {
700 namespace Helpers
701 {
702 class GetGlyphState
703 {
704 public:
705 Lang::MultiPath2D * paths_;
706 Lang::ElementaryPath2D * contour_;
707 Concrete::PathPoint2D * last_;
708 Concrete::Length scaled_font_unit_;
709
710 void close( )
711 {
712 if( contour_ != 0 )
713 {
714 /* We should eliminate the duplicated point where the path begins and ends. */
715 contour_->pop_back( );
716 if( last_->rear_ != last_->mid_ )
717 {
718 contour_->front( )->rear_ = last_->rear_;
719 last_->rear_ = last_->mid_; /* This gives away the ownership of last_->rear_. */
720 }
721 delete last_;
722 last_ = 0;
723 contour_->close( );
724 contour_ = 0;
725 }
726 }
727 int move_to( const FT_Vector & to )
728 {
729 close( );
730 contour_ = new Lang::ElementaryPath2D( );
731 paths_->push_back( RefCountPtr< const Lang::Path2D >( contour_ ) );
732 last_ = new Concrete::PathPoint2D( new Concrete::Coords2D( to.x * scaled_font_unit_, to.y * scaled_font_unit_ ) );
733 contour_->push_back( last_ );
734 return 0;
735 }
736 int line_to( const FT_Vector & to )
737 {
738 last_ = new Concrete::PathPoint2D( new Concrete::Coords2D( to.x * scaled_font_unit_, to.y * scaled_font_unit_ ) );
739 contour_->push_back( last_ );
740 return 0;
741 }
742 int conic_to( const FT_Vector & control, const FT_Vector & to )
743 {
744 Concrete::Coords2D c( control.x * scaled_font_unit_, control.y * scaled_font_unit_ );
745 last_->front_ = new Concrete::Coords2D( (2./3) * c + (1./3) * *last_->mid_ );
746 last_ = new Concrete::PathPoint2D( new Concrete::Coords2D( to.x * scaled_font_unit_, to.y * scaled_font_unit_ ) );
747 last_->rear_ = new Concrete::Coords2D( (2./3) * c + (1./3) * *last_->mid_ );
748 contour_->push_back( last_ );
749 return 0;
750 }
751 int cubic_to( const FT_Vector & control1, const FT_Vector & control2, const FT_Vector & to )
752 {
753 last_->front_ = new Concrete::Coords2D( control1.x * scaled_font_unit_, control1.y * scaled_font_unit_ );
754 last_ = new Concrete::PathPoint2D( new Concrete::Coords2D( to.x * scaled_font_unit_, to.y * scaled_font_unit_ ) );
755 last_->rear_ = new Concrete::Coords2D( control2.x * scaled_font_unit_, control2.y * scaled_font_unit_ );
756 contour_->push_back( last_ );
757 return 0;
758 }
759
760 GetGlyphState( Lang::MultiPath2D * paths, Concrete::Length scaled_font_unit )
761 : paths_( paths ),
762 contour_( 0 ),
763 last_( 0 ),
764 scaled_font_unit_( scaled_font_unit )
765 { }
766 ~GetGlyphState( )
767 {
768 close( );
769 }
770 };
771 int getGlyph_move_to( const FT_Vector * to, void * stateUntyped )
772 {
773 return reinterpret_cast< GetGlyphState * >( stateUntyped )->move_to( *to );
774 }
775 int getGlyph_line_to( const FT_Vector * to, void * stateUntyped )
776 {
777 return reinterpret_cast< GetGlyphState * >( stateUntyped )->line_to( *to );
778 }
779 int getGlyph_conic_to( const FT_Vector * control, const FT_Vector * to, void * stateUntyped )
780 {
781 return reinterpret_cast< GetGlyphState * >( stateUntyped )->conic_to( *control, *to );
782 }
783 int getGlyph_cubic_to( const FT_Vector * control1, const FT_Vector * control2, const FT_Vector * to, void * stateUntyped )
784 {
785 return reinterpret_cast< GetGlyphState * >( stateUntyped )->cubic_to( *control1, *control2, *to );
786 }
787 }
788 }
789
790 RefCountPtr< const Lang::Value >
791 Lang::FreeTypeFont::getGlyph( Kernel::UnicodeCodePoint c, Concrete::Length size ) const
792 {
793 FT_UInt index = FT_Get_Char_Index( face_, c.get_UCS4( ) );
794 if( index == 0 )
795 {
796 const size_t bufsize = 10;
797 char buf[ bufsize ];
798 char * tmp = buf;
799 size_t outavail = bufsize - 1;
800 c.encode_UTF8( & tmp, & outavail );
801 *tmp = '\0';
802 std::ostringstream msg;
803 msg << "The font " << fontName_ << " does not cover the character `" << buf << "´ (code point " << c.get_UCS4( ) << ")." ;
804 throw Exceptions::OutOfRange( strrefdup( msg ) );
805 }
806 FT_Error error = FT_Load_Glyph( face_, index, FT_LOAD_NO_SCALE );
807 if( error != 0 )
808 {
809 std::ostringstream msg;
810 msg << "Unable to load glyph in FreeType 2, at code point " << c.get_UCS4( ) ;
811 throw Shapes::Exceptions::OutOfRange( strrefdup( msg ) );
812 }
813 if( face_->glyph->format != FT_GLYPH_FORMAT_OUTLINE )
814 {
815 const size_t bufsize = 10;
816 char buf[ bufsize ];
817 char * tmp = buf;
818 size_t outavail = bufsize - 1;
819 c.encode_UTF8( & tmp, & outavail );
820 *tmp = '\0';
821 std::ostringstream msg;
822 msg << "Unsupported glyph format in the font " << fontName_ << ", character `" << buf << "´ (code point " << c.get_UCS4( ) << ")." ;
823 throw Exceptions::MiscellaneousRequirement( strrefdup( msg ) );
824 }
825
826 const FT_Outline & ol = face_->glyph->outline;
827
828 Helpers::FontMethod_glyph_resultFactory.set
829 ( "painter",
830 Kernel::VariableHandle( new Kernel::Variable( ( ( ol.flags & FT_OUTLINE_REVERSE_FILL ) == 0 ) ? Lang::THE_FILL : Lang::THE_FILLODD ) ) );
831
832 Lang::MultiPath2D * pathsPtr = new Lang::MultiPath2D( );
833 RefCountPtr< const Lang::MultiPath2D > paths( pathsPtr );
834 {
835 FT_Outline_Funcs emitters;
836 emitters.move_to = Helpers::getGlyph_move_to;
837 emitters.line_to = Helpers::getGlyph_line_to;
838 emitters.conic_to = Helpers::getGlyph_conic_to;
839 emitters.cubic_to = Helpers::getGlyph_cubic_to;
840 emitters.shift = 0;
841 emitters.delta = 0;
842 Helpers::GetGlyphState state( pathsPtr, size / static_cast< double >( face_->units_per_EM ) );
843 FT_Error error = FT_Outline_Decompose( & face_->glyph->outline, & emitters, reinterpret_cast< void * >( & state ) );
844 if( error != 0 )
845 {
846 std::ostringstream msg;
847 msg << "FreeType error, FT_Outline_Decompose returned with error: " << Kernel::FreeTypeErrorMessage( error ) ;
848 throw Exceptions::ExternalError( strrefdup( msg ) );
849 }
850 }
851 Helpers::FontMethod_glyph_resultFactory.set( "paths", Kernel::VariableHandle( new Kernel::Variable( paths ) ) );
852
853 return Helpers::FontMethod_glyph_resultFactory.build( );
854 }
855
856 #endif /* End of #ifdef HAVE_FT2. */
857
858 Lang::TextOperation::TextOperation( )
859 { }
860
861 Lang::TextOperation::~TextOperation( )
862 { }
863
864 RefCountPtr< const Lang::Class > Lang::TextOperation::TypeID( new Lang::SystemFinalClass( strrefdup( "TextOperation" ) ) );
865 TYPEINFOIMPL( TextOperation );
866
867
868 Lang::KernedText::KernedText( const RefCountPtr< const Kernel::TextState > & textState, const RefCountPtr< const Kernel::GraphicsState > & metaState )
869 : textState_( textState ), metaState_( metaState ), maxLength_( 0 )
870 { }
871
872 Lang::KernedText::KernedText( const RefCountPtr< const Kernel::TextState > & textState, const RefCountPtr< const Kernel::GraphicsState > & metaState, const RefCountPtr< const Lang::String > & str)
873 : textState_( textState ), metaState_( metaState ), maxLength_( 0 )
874 {
875 pushString( str );
876 }
877
878 Lang::KernedText::~KernedText( )
879 { }
880
881 Kernel::VariableHandle
882 Lang::KernedText::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
883 {
884 if( strcmp( fieldID, "list" ) == 0 )
885 {
886 return Kernel::VariableHandle( new Kernel::Variable( makeList( ) ) );
887 }
888 throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
889 }
890
891 RefCountPtr< const Lang::SingleList >
892 Lang::KernedText::makeList( ) const
893 {
894 /* The list is first computed in a bidirectional list, and then we construct the stateless cons list.
895 */
896
897 /* I'm lazy today, so i use a cons pair to group the horizontal step with the glyph. The better solution
898 * would be to use a structure with nicely named fields...
899 */
900
901 std::list< RefCountPtr< const Lang::Value > > revlist;
902
903 iconv_t converter = Helpers::requireUTF8ToUCS4Converter( );
904
905 RefCountPtr< FontMetrics::WritingDirectionMetrics > horizontalMetrics = textState_->font_->metrics( )->horizontalMetrics_;
906 if( horizontalMetrics == NullPtr< FontMetrics::WritingDirectionMetrics >( ) )
907 {
908 throw Exceptions::FontMetricsError( textState_->font_->fontName( ), strrefdup( "No horizontal metrics defined." ) );
909 }
910 const FontMetrics::CharacterMetrics * defaultCharMetrics = horizontalMetrics->default_char( );
911
912 Concrete::Length ySize = textState_->size_;
913 Concrete::Length xSize = ySize * textState_->horizontalScaling_;
914 Concrete::Length characterTrackKern = textState_->horizontalScaling_ * textState_->characterSpacing_;
915 Concrete::Length wordTrackKern = textState_->horizontalScaling_ * textState_->wordSpacing_;
916
917 Concrete::Length xpos = 0;
918
919 size_t bufSize = 4 * maxLength_; // This will be enough if UCS4 coding is used, since this encoding uses only one byte per character.
920 char * buf = new char[ bufSize ];
921 DeleteOnExit< char > bufDeleter( buf );
922
923 FontMetrics::CharacterMetrics tmpCharMetric( 0 );
924
925 typedef typeof strings_ ListType;
926 std::list< double >::const_iterator ki = kernings_.begin( );
927 for( ListType::const_iterator i = strings_.begin( ); i != strings_.end( ); ++i )
928 {
929 if( *i != NullPtr< const Lang::String >( ) )
930 {
931 const char * inbuf = (*i)->val_.getPtr( );
932 if( strchr( inbuf, '\n' ) != 0 )
933 {
934 throw Exceptions::MiscellaneousRequirement( "Newlines cannot be represented in the pos-character list." );
935 }
936 char * outbuf = buf;
937 size_t inbytesleft = strlen( inbuf );
938 size_t outbytesleft = bufSize;
939 // The ICONV_CAST macro is defined in config.h.
940 size_t count = iconv( converter,
941 ICONV_CAST( & inbuf ), & inbytesleft,
942 & outbuf, & outbytesleft );
943 if( count == (size_t)(-1) )
944 {
945 if( errno == EILSEQ )
946 {
947 throw Exceptions::MiscellaneousRequirement( "It is suspected that string data is not proper UFT-8, since conversion to UCS-4 failed." );
948 }
949 else if( errno == EINVAL )
950 {
951 throw Exceptions::MiscellaneousRequirement( "It is suspected that showed text ended with an incomplete multibyte character." );
952 }
953 else if( errno == E2BIG )
954 {
955 throw Exceptions::InternalError( "The buffer allocated for UTF-8 to UCS-4 conversion was too small." );
956 }
957 else
958 {
959 std::ostringstream msg;
960 msg << "iconv failed with an unrecognized error code: " << errno ;
961 throw Exceptions::InternalError( strrefdup( msg ) );
962 }
963 }
964 for( const char * src = buf; src != outbuf; src += 4 )
965 {
966 Kernel::UnicodeCodePoint code;
967 code.decode_UCS4( src );
968 if( code == Kernel::UnicodeCodePoint::SPACE ) /* test for space */
969 {
970 // Observe textState_->wordSpacing_
971 const FontMetrics::CharacterMetrics * charMetrics = horizontalMetrics->charByCode( code, & tmpCharMetric );
972 xpos += xSize * charMetrics->horizontalCharWidthX_;
973 xpos += characterTrackKern;
974 xpos += wordTrackKern;
975 }
976 else /* there should not be any newlines in the string, so we expect this to be a non-white character */
977 {
978 // Observe textState_->characterSpacing_
979 const FontMetrics::CharacterMetrics * charMetrics = horizontalMetrics->charByCode( code, & tmpCharMetric );
980 if( Computation::fontMetricGuessIsError && charMetrics == defaultCharMetrics )
981 {
982 std::ostringstream msg;
983 msg << "Character at offset " << src - buf << " in \"" << buf << "\" was not found in font metrics (and according to your options, guessing is not OK)." ;
984 throw Exceptions::FontMetricsError( textState_->font_->fontName( ), strrefdup( msg ) );
985 }
986 revlist.push_back( RefCountPtr< const Lang::Value >
987 ( new Lang::ConsPair
988 ( Helpers::newValHandle( new Lang::Length( xpos ) ),
989 Helpers::newValHandle( new Lang::KernedText( textState_, metaState_, oneUCS4ToUTF8( src ) ) ) ) ) );
990 /* Although not as efficient, it becomes easier to use the list if the distance is
991 * measured from the start of the text rather than from the previous character.
992 */
993 // xpos = 0;
994 xpos += xSize * charMetrics->horizontalCharWidthX_;
995 xpos += characterTrackKern;
996 }
997 }
998 }
999 else
1000 {
1001 if( ki == kernings_.end( ) )
1002 {
1003 throw Exceptions::InternalError( "Short of kerning values in KernedText::measure." );
1004 }
1005 xpos -= xSize * *ki;
1006 ++ki;
1007 }
1008 }
1009 if( ki != kernings_.end( ) )
1010 {
1011 throw Exceptions::InternalError( "Too many kerning values in KernedText::writePDFVectorTo." );
1012 }
1013
1014 RefCountPtr< const Lang::SingleList > res = Lang::THE_CONS_NULL;
1015 while( ! revlist.empty( ) )
1016 {
1017 res = RefCountPtr< const Lang::SingleList >( new Lang::SingleListPair( Kernel::VariableHandle( new Kernel::Variable( revlist.back( ) ) ),
1018 res ) );
1019 revlist.pop_back( );
1020 }
1021 return res;
1022 }
1023
1024 RefCountPtr< const Lang::String >
1025 Lang::KernedText::oneUCS4ToUTF8( const char * c )
1026 {
1027 iconv_t converter = Helpers::requireUCS4ToUTF8Converter( );
1028
1029 const size_t BUF_SIZE = 9;
1030 char buf[ BUF_SIZE ];
1031
1032 char charbuf[ 5 ];
1033 charbuf[0] = *c;
1034 ++c;
1035 charbuf[1] = *c;
1036 ++c;
1037 charbuf[2] = *c;
1038 ++c;
1039 charbuf[3] = *c;
1040 charbuf[4] = '\0';
1041
1042 char * outbuf = buf;
1043 const char * inbuf = charbuf;
1044 size_t inbytesleft = 4;
1045 size_t outbytesleft = BUF_SIZE - 1;
1046 // The ICONV_CAST macro is defined in config.h.
1047 size_t count = iconv( converter,
1048 ICONV_CAST( & inbuf ), & inbytesleft,
1049 & outbuf, & outbytesleft );
1050 if( count == (size_t)(-1) )
1051 {
1052 throw Exceptions::ExternalError( "Conversion of one UCS-4 character to UTF-8 failed." );
1053 }
1054 *outbuf = '\0';
1055 return RefCountPtr< const Lang::String >( new Lang::String( strrefdup( buf ) ) );
1056 }
1057
1058 void
1059 Lang::KernedText::pushString( const RefCountPtr< const Lang::String > & str )
1060 {
1061 strings_.push_back( str );
1062 maxLength_ = std::max( maxLength_, strlen( str->val_.getPtr( ) ) );
1063 }
1064
1065 void
1066 Lang::KernedText::pushKerning( double kerning )
1067 {
1068 strings_.push_back( NullPtr< const Lang::String >( ) );
1069 kernings_.push_back( kerning );
1070 }
1071
1072 void
1073 Lang::KernedText::show( std::ostream & os ) const
1074 {
1075 typedef typeof strings_ ListType;
1076 std::list< double >::const_iterator ki = kernings_.begin( );
1077 for( ListType::const_iterator i = strings_.begin( ); i != strings_.end( ); ++i )
1078 {
1079 if( *i != NullPtr< const Lang::String >( ) )
1080 {
1081 os << "(" << (*i)->val_.getPtr( ) << ")" ;
1082 }
1083 else
1084 {
1085 if( ki == kernings_.end( ) )
1086 {
1087 throw Exceptions::InternalError( "Short of kerning values in KernedText::show." );
1088 }
1089 os << *ki ;
1090 ++ki;
1091 }
1092 }
1093 if( ki != kernings_.end( ) )
1094 {
1095 throw Exceptions::InternalError( "Too many kerning values in KernedText::show." );
1096 }
1097 }
1098
1099
1100 void
1101 Lang::KernedText::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf, bool clip ) const
1102 {
1103 pdfState->text_.synchAssertKnockout( os, textState_.getPtr( ), pdfState->resources_.getPtr( ), clip );
1104 switch( textState_->mode_ )
1105 {
1106 case Lang::TextRenderingMode::FILL:
1107 case Lang::TextRenderingMode::FILLCLIP:
1108 pdfState->graphics_.synchForNonStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
1109 break;
1110 case Lang::TextRenderingMode::STROKE:
1111 case Lang::TextRenderingMode::STROKECLIP:
1112 pdfState->graphics_.synchForStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
1113 break;
1114 case Lang::TextRenderingMode::FILLSTROKE:
1115 case Lang::TextRenderingMode::FILLSTROKECLIP:
1116 pdfState->graphics_.synchForStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
1117 pdfState->graphics_.synchForNonStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
1118 break;
1119 case Lang::TextRenderingMode::INVISIBLE:
1120 case Lang::TextRenderingMode::CLIP:
1121 break;
1122 case Lang::TextRenderingMode::UNDEFINED:
1123 pdfState->graphics_.synchForStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
1124 pdfState->graphics_.synchForNonStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
1125 default:
1126 throw Exceptions::InternalError( "KernedText::writePDFVectorTo: Text rendering mode out of range." );
1127 }
1128
1129
1130 size_t bufSize = 4 * maxLength_; // Even with UTF16BE encoding, no character should use more than 4 bytes.
1131 // The extra one byte will be used to terminate the string.
1132 char * buf = new char[ bufSize ];
1133 DeleteOnExit< char > bufDeleter( buf );
1134
1135 typedef typeof strings_ ListType;
1136 std::list< double >::const_iterator ki = kernings_.begin( );
1137 os << "[ " ;
1138 for( ListType::const_iterator i = strings_.begin( ); i != strings_.end( ); ++i )
1139 {
1140 if( *i != NullPtr< const Lang::String >( ) )
1141 {
1142 os << "(" ;
1143 const char * line = (*i)->val_.getPtr( );
1144 while( true )
1145 {
1146 const char * nextLine = strchr( line, '\n' ); /* Search for line breaks before we convert from UTF8. */
1147 const char * inbuf = line;
1148 char * outbuf = buf;
1149 size_t inbytesleft = ( nextLine != 0 ) ? ( nextLine - line ) : strlen( line );
1150 size_t outbytesleft = bufSize;
1151 textState_->font_->encode( & inbuf, & inbytesleft,
1152 & outbuf, & outbytesleft );
1153 const char * end = buf + ( bufSize - outbytesleft );
1154 for( const char * src = buf; src != end; ++src )
1155 {
1156 switch( *src )
1157 {
1158 case '(':
1159 os << "\\(" ;
1160 break;
1161 case ')':
1162 os << "\\)" ;
1163 break;
1164 case '\\':
1165 os << "\\\\" ;
1166 break;
1167 default:
1168 os << *src ;
1169 }
1170 }
1171 if( nextLine == 0 )
1172 {
1173 break;
1174 }
1175 os << ")] TJ T* [(" ;
1176 line = nextLine;
1177 ++line; /* Skip the \n character */
1178 }
1179 os << ") " ;
1180 }
1181 else
1182 {
1183 if( ki == kernings_.end( ) )
1184 {
1185 throw Exceptions::InternalError( "Short of kerning values in KernedText::writePDFVectorTo." );
1186 }
1187 os << 1000 * *ki << " " ;
1188 ++ki;
1189 }
1190 }
1191 if( ki != kernings_.end( ) )
1192 {
1193 throw Exceptions::InternalError( "Too many kerning values in KernedText::writePDFVectorTo." );
1194 }
1195
1196 os << "] TJ " << std::endl ;
1197 }
1198
1199 void
1200 Lang::KernedText::measure( Lang::Transform2D * textMatrix, Lang::Transform2D * textLineMatrix, Concrete::Length * xmin, Concrete::Length * ymin, Concrete::Length * xmax, Concrete::Length * ymax ) const
1201 {
1202 iconv_t converter = Helpers::requireUTF8ToUCS4Converter( );
1203
1204 RefCountPtr< FontMetrics::WritingDirectionMetrics > horizontalMetrics = textState_->font_->metrics( )->horizontalMetrics_;
1205 if( horizontalMetrics == NullPtr< FontMetrics::WritingDirectionMetrics >( ) )
1206 {
1207 throw Exceptions::FontMetricsError( textState_->font_->fontName( ), strrefdup( "No horizontal metrics defined." ) );
1208 }
1209 const FontMetrics::CharacterMetrics * defaultCharMetrics = horizontalMetrics->default_char( );
1210
1211 Concrete::Length ySize = textState_->size_;
1212 Concrete::Length xSize = ySize * textState_->horizontalScaling_;
1213 Concrete::Length characterTrackKern = textState_->horizontalScaling_ * textState_->characterSpacing_;
1214 Concrete::Length wordTrackKern = textState_->horizontalScaling_ * textState_->wordSpacing_;
1215
1216 size_t bufSize = 4 * maxLength_;
1217 char * buf = new char[ bufSize ];
1218 DeleteOnExit< char > bufDeleter( buf );
1219
1220 FontMetrics::CharacterMetrics tmpCharMetric( 0 );
1221
1222 if( textLineMatrix->isTranslation( ) )
1223 {
1224 Concrete::Length x0 = textLineMatrix->xt_;
1225 Concrete::Length y0 = textLineMatrix->yt_ + textState_->riseConcrete( );
1226 Concrete::Length xpos = 0;
1227
1228 typedef typeof strings_ ListType;
1229 std::list< double >::const_iterator ki = kernings_.begin( );
1230 for( ListType::const_iterator i = strings_.begin( ); i != strings_.end( ); ++i )
1231 {
1232 if( *i != NullPtr< const Lang::String >( ) )
1233 {
1234 const char * inbuf = (*i)->val_.getPtr( );
1235 char * outbuf = buf;
1236 size_t inbytesleft = strlen( inbuf );
1237 size_t outbytesleft = bufSize;
1238 // The ICONV_CAST macro is defined in config.h.
1239 size_t count = iconv( converter,
1240 ICONV_CAST( & inbuf ), & inbytesleft,
1241 & outbuf, & outbytesleft );
1242 if( count == (size_t)(-1) )
1243 {
1244 if( errno == EILSEQ )
1245 {
1246 throw Exceptions::MiscellaneousRequirement( "Failed to convert from UFT-8 to UCS-4 code points." );
1247 }
1248 else if( errno == EINVAL )
1249 {
1250 throw Exceptions::MiscellaneousRequirement( "It is suspected that showed text ended with an incomplete multibyte character." );
1251 }
1252 else if( errno == E2BIG )
1253 {
1254 throw Exceptions::InternalError( "The buffer allocated for UTF-8 to UCS-4 conversion was too small." );
1255 }
1256 else
1257 {
1258 std::ostringstream msg;
1259 msg << "iconv failed with an unrecognized error code: " << errno ;
1260 throw Exceptions::InternalError( strrefdup( msg ) );
1261 }
1262 }
1263 for( const char * src = buf; src != outbuf; src += 4 )
1264 {
1265 Kernel::UnicodeCodePoint code;
1266 code.decode_UCS4( src );
1267 if( code == Kernel::UnicodeCodePoint::SPACE )
1268 {
1269 // Observe textState_->wordSpacing_
1270 // In addition, it seems reasonable to not let the space character affect the bounding box.
1271 const FontMetrics::CharacterMetrics * charMetrics = horizontalMetrics->charByCode( code, & tmpCharMetric );
1272 xpos += xSize * charMetrics->horizontalCharWidthX_;
1273 xpos += characterTrackKern;
1274 xpos += wordTrackKern;
1275 }
1276 else if( code == Kernel::UnicodeCodePoint::NEWLINE )
1277 {
1278 textMatrix->prependShift( Concrete::Coords2D( 0, - textState_->leadingConcrete( ) ) );
1279 textLineMatrix->replaceBy( *textMatrix );
1280 x0 = textLineMatrix->xt_;
1281 y0 = textLineMatrix->yt_ + textState_->riseConcrete( );
1282 xpos = 0;
1283 }
1284 else
1285 {
1286 // Observe textState_->characterSpacing_
1287 const FontMetrics::CharacterMetrics * charMetrics = horizontalMetrics->charByCode( code, & tmpCharMetric );
1288 if( Computation::fontMetricGuessIsError && charMetrics == defaultCharMetrics )
1289 {
1290 std::ostringstream msg;
1291 msg << "Character at offset " << src - buf << " in \"" << buf << "\" was not found in font metrics (and according to your options, guessing is not OK)." ;
1292 throw Exceptions::FontMetricsError( textState_->font_->fontName( ), strrefdup( msg ) );
1293 }
1294 *xmin = std::min( *xmin, x0 + xpos + xSize * charMetrics->xmin_ );
1295 *ymin = std::min( *ymin, y0 + ySize * charMetrics->ymin_ );
1296 *xmax = std::max( *xmax, x0 + xpos + xSize * charMetrics->xmax_ );
1297 *ymax = std::max( *ymax, y0 + ySize * charMetrics->ymax_ );
1298 xpos += xSize * charMetrics->horizontalCharWidthX_;
1299 xpos += characterTrackKern;
1300 }
1301 }
1302 }
1303 else
1304 {
1305 if( ki == kernings_.end( ) )
1306 {
1307 throw Exceptions::InternalError( "Short of kerning values in KernedText::measure." );
1308 }
1309 xpos -= xSize * *ki;
1310 ++ki;
1311 }
1312 }
1313 if( ki != kernings_.end( ) )
1314 {
1315 throw Exceptions::InternalError( "Too many kerning values in KernedText::writePDFVectorTo." );
1316 }
1317
1318 textLineMatrix->prependXShift( xpos );
1319 }
1320 else
1321 {
1322 Concrete::Length rise = textState_->riseConcrete( );
1323 // std::cerr << "@<< @stroking:RGB_RED | [stroke [shift " << Helpers::shapesFormat( Concrete::Coords2D( 0, 0 ).transformed( *textLineMatrix ) ) << "] [] [circle 2bp]]" << std::endl ;
1324
1325 typedef typeof strings_ ListType;
1326 std::list< double >::const_iterator ki = kernings_.begin( );
1327 for( ListType::const_iterator i = strings_.begin( ); i != strings_.end( ); ++i )
1328 {
1329 if( *i != NullPtr< const Lang::String >( ) )
1330 {
1331 const char * inbuf = (*i)->val_.getPtr( );
1332 char * outbuf = buf;
1333 size_t inbytesleft = strlen( inbuf );
1334 size_t outbytesleft = bufSize;
1335 // The ICONV_CAST macro is defined in config.h.
1336 size_t count = iconv( converter,
1337 ICONV_CAST( & inbuf ), & inbytesleft,
1338 & outbuf, & outbytesleft );
1339 if( count == (size_t)(-1) )
1340 {
1341 if( errno == EILSEQ )
1342 {
1343 throw Exceptions::MiscellaneousRequirement( "It is suspected that one of the UFT-8 characters used in showed text has no MacRoman representation." );
1344 }
1345 else if( errno == EINVAL )
1346 {
1347 throw Exceptions::MiscellaneousRequirement( "It is suspected that showed text ended with an incomplete multibyte character." );
1348 }
1349 else if( errno == E2BIG )
1350 {
1351 throw Exceptions::InternalError( "The buffer allocated for UTF-8 to UCS-4 conversion was too small." );
1352 }
1353 else
1354 {
1355 std::ostringstream msg;
1356 msg << "iconv failed with an unrecognized error code: " << errno ;
1357 throw Exceptions::InternalError( strrefdup( msg ) );
1358 }
1359 }
1360 for( const char * src = buf; src != outbuf; src += 4 )
1361 {
1362 Kernel::UnicodeCodePoint code;
1363 code.decode_UCS4( src );
1364 if( code == Kernel::UnicodeCodePoint::SPACE )
1365 {
1366 // Observe textState_->wordSpacing_
1367 // In addition, it seems reasonable to not let the space character affect the bounding box.
1368 const FontMetrics::CharacterMetrics * charMetrics = horizontalMetrics->charByCode( code, & tmpCharMetric );
1369 textLineMatrix->prependXShift( xSize * charMetrics->horizontalCharWidthX_ + characterTrackKern + wordTrackKern );
1370 // std::cerr << "@<< @stroking:RGB_BLUE | [stroke [shift " << Helpers::shapesFormat( Concrete::Coords2D( 0, 0 ).transformed( *textLineMatrix ) ) << "] [] [circle 2bp]]" << std::endl ;
1371 }
1372 else if( code == Kernel::UnicodeCodePoint::NEWLINE )
1373 {
1374 textMatrix->prependShift( Concrete::Coords2D( 0, - textState_->leadingConcrete( ) ) );
1375 textLineMatrix->replaceBy( *textMatrix );
1376 // std::cerr << "@<< @stroking:RGB_RED | [stroke [shift " << Helpers::shapesFormat( Concrete::Coords2D( 0, 0 ).transformed( *textLineMatrix ) ) << "] [] [circle 2bp]]" << std::endl ;
1377 }
1378 else
1379 {
1380 // Observe textState_->characterSpacing_
1381 const FontMetrics::CharacterMetrics * charMetrics = horizontalMetrics->charByCode( code, & tmpCharMetric );
1382 if( Computation::fontMetricGuessIsError && charMetrics == defaultCharMetrics )
1383 {
1384 std::ostringstream msg;
1385 msg << "Character at offset " << src - buf << " in \"" << buf << "\" was not found in the font metrics (and according to your options, guessing is not OK)." ;
1386 throw Exceptions::FontMetricsError( textState_->font_->fontName( ), strrefdup( msg ) );
1387 }
1388
1389 Concrete::Coords2D x0y0 = Concrete::Coords2D( xSize * charMetrics->xmin_, ySize * charMetrics->ymin_ + rise ).transformed( *textLineMatrix );
1390 Concrete::Coords2D x0y1 = Concrete::Coords2D( xSize * charMetrics->xmin_, ySize * charMetrics->ymax_ + rise ).transformed( *textLineMatrix );
1391 Concrete::Coords2D x1y0 = Concrete::Coords2D( xSize * charMetrics->xmax_, ySize * charMetrics->ymin_ + rise ).transformed( *textLineMatrix );
1392 Concrete::Coords2D x1y1 = Concrete::Coords2D( xSize * charMetrics->xmax_, ySize * charMetrics->ymax_ + rise ).transformed( *textLineMatrix );
1393 // std::cerr << "@<< @width:0.3bp | [stroke "<< Helpers::shapesFormat( x0y0 ) << "--" << Helpers::shapesFormat( x0y1 ) << "--" << Helpers::shapesFormat( x1y1 ) << "--" << Helpers::shapesFormat( x1y0 ) << "--cycle]" << std::endl ;
1394
1395 *xmin = std::min( *xmin, x0y0.x_ );
1396 *ymin = std::min( *ymin, x0y0.y_ );
1397 *xmax = std::max( *xmax, x0y0.x_ );
1398 *ymax = std::max( *ymax, x0y0.y_ );
1399
1400 *xmin = std::min( *xmin, x0y1.x_ );
1401 *ymin = std::min( *ymin, x0y1.y_ );
1402 *xmax = std::max( *xmax, x0y1.x_ );
1403 *ymax = std::max( *ymax, x0y1.y_ );
1404
1405 *xmin = std::min( *xmin, x1y0.x_ );
1406 *ymin = std::min( *ymin, x1y0.y_ );
1407 *xmax = std::max( *xmax, x1y0.x_ );
1408 *ymax = std::max( *ymax, x1y0.y_ );
1409
1410 *xmin = std::min( *xmin, x1y1.x_ );
1411 *ymin = std::min( *ymin, x1y1.y_ );
1412 *xmax = std::max( *xmax, x1y1.x_ );
1413 *ymax = std::max( *ymax, x1y1.y_ );
1414
1415 textLineMatrix->prependXShift( xSize * charMetrics->horizontalCharWidthX_ + characterTrackKern );
1416 // std::cerr << "@<< [stroke [shift " << Helpers::shapesFormat( Concrete::Coords2D( 0, 0 ).transformed( *textLineMatrix ) ) << "] [] [circle 2bp]]" << std::endl ;
1417 }
1418 }
1419 }
1420 else
1421 {
1422 if( ki == kernings_.end( ) )
1423 {
1424 throw Exceptions::InternalError( "Short of kerning values in KernedText::measure." );
1425 }
1426 textLineMatrix->prependXShift( - xSize * *ki );
1427 ++ki;
1428 }
1429 }
1430 if( ki != kernings_.end( ) )
1431 {
1432 throw Exceptions::InternalError( "Too many kerning values in KernedText::writePDFVectorTo." );
1433 }
1434 }
1435 }
1436
1437 void
1438 Lang::KernedText::push( Lang::KernedText * dst ) const
1439 {
1440 typedef typeof strings_ ListType;
1441 std::list< double >::const_iterator ki = kernings_.begin( );
1442 for( ListType::const_iterator i = strings_.begin( ); i != strings_.end( ); ++i )
1443 {
1444 if( *i != NullPtr< const Lang::String >( ) )
1445 {
1446 dst->pushString( *i );
1447 }
1448 else
1449 {
1450 dst->pushKerning( *ki );
1451 ++ki;
1452 }
1453 }
1454 }
1455
1456
1457 void
1458 Lang::KernedText::gcMark( Kernel::GCMarkedSet & marked )
1459 {
1460 typedef typeof strings_ ListType;
1461 for( ListType::const_iterator i = strings_.begin( ); i != strings_.end( ); ++i )
1462 {
1463 if( *i != NullPtr< const Lang::String >( ) )
1464 {
1465 const_cast< Lang::String * >( i->getPtr( ) )->gcMark( marked );
1466 }
1467 }
1468 }
1469
1470 Lang::TextNewline::TextNewline( const Concrete::Length tx, const Concrete::Length ty )
1471 : t_( tx, ty )
1472 { }
1473
1474 Lang::TextNewline::~TextNewline( )
1475 { }
1476
1477 void
1478 Lang::TextNewline::show( std::ostream & os ) const
1479 {
1480 os << "Newline with offset in bp: " << t_ ;
1481 }
1482
1483 void
1484 Lang::TextNewline::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf, bool clip ) const
1485 {
1486 os << t_ << " Td " ;
1487 }
1488
1489 void
1490 Lang::TextNewline::measure( Lang::Transform2D * textMatrix, Lang::Transform2D * textLineMatrix, Concrete::Length * xmin, Concrete::Length * ymin, Concrete::Length * xmax, Concrete::Length * ymax ) const
1491 {
1492 textMatrix->prependShift( t_ );
1493 textLineMatrix->replaceBy( *textMatrix );
1494 }
1495
1496 void
1497 Lang::TextNewline::gcMark( Kernel::GCMarkedSet & marked )
1498 { }
1499
1500 Lang::TextMoveto::TextMoveto( const RefCountPtr< const Lang::Transform2D > & tf )
1501 : tf_( tf )
1502 { }
1503
1504 Lang::TextMoveto::~TextMoveto( )
1505 { }
1506
1507 void
1508 Lang::TextMoveto::show( std::ostream & os ) const
1509 {
1510 os << "Moveto command" ;
1511 }
1512
1513 void
1514 Lang::TextMoveto::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf, bool clip ) const
1515 {
1516 Lang::Transform2D( tf, *tf_ ).shipout( os );
1517 os << " Tm" << std::endl ;
1518 }
1519
1520 void
1521 Lang::TextMoveto::measure( Lang::Transform2D * textMatrix, Lang::Transform2D * textLineMatrix, Concrete::Length * xmin, Concrete::Length * ymin, Concrete::Length * xmax, Concrete::Length * ymax ) const
1522 {
1523 textMatrix->replaceBy( *tf_ );
1524 textLineMatrix->replaceBy( *textMatrix );
1525 }
1526
1527 void
1528 Lang::TextMoveto::gcMark( Kernel::GCMarkedSet & marked )
1529 {
1530 const_cast< Lang::Transform2D * >( tf_.getPtr( ) )->gcMark( marked );
1531 }
1532
1533
1534
1535 typedef enum { FILL = 0, STROKE, FILLSTROKE, INVISIBLE, FILLCLIP, STROKECLIP, FILLSTROKECLIP, CLIP, UNDEFINED } ValueType;
1536 ValueType mode_;
1537
1538 Lang::TextRenderingMode::TextRenderingMode( const ValueType & mode )
1539 : mode_( mode )
1540 { }
1541
1542 Lang::TextRenderingMode::TextRenderingMode( bool fill, bool stroke, bool clip )
1543 {
1544 switch( ( fill ? 0x01 : 0x00 ) +
1545 ( stroke ? 0x02 : 0x00 ) +
1546 ( clip ? 0x04 : 0x00 ) )
1547 {
1548 case 0x00:
1549 mode_ = INVISIBLE;
1550 break;
1551 case 0x01:
1552 mode_ = FILL;
1553 break;
1554 case 0x02:
1555 mode_ = STROKE;
1556 break;
1557 case 0x03:
1558 mode_ = FILLSTROKE;
1559 break;
1560 case 0x04:
1561 mode_ = CLIP;
1562 break;
1563 case 0x05:
1564 mode_ = FILLCLIP;
1565 break;
1566 case 0x06:
1567 mode_ = STROKECLIP;
1568 break;
1569 case 0x07:
1570 mode_ = FILLSTROKECLIP;
1571 break;
1572 default:
1573 throw Exceptions::InternalError( "Semi-static switch out of range in TextRenderingMode::TextRenderingMode." );
1574 }
1575 }
1576
1577 Lang::TextRenderingMode::ValueType
1578 Lang::TextRenderingMode::clipMode( ValueType mode )
1579 {
1580 switch( mode )
1581 {
1582 case INVISIBLE:
1583 return CLIP;
1584 case FILL:
1585 return FILLCLIP;
1586 case STROKE:
1587 return STROKECLIP;
1588 case FILLSTROKE:
1589 return FILLSTROKECLIP;
1590 default:
1591 return UNDEFINED;
1592 }
1593 }
1594
1595 Lang::TextRenderingMode::~TextRenderingMode( )
1596 { }
1597
1598 RefCountPtr< const Lang::Class > Lang::TextRenderingMode::TypeID( new Lang::SystemFinalClass( strrefdup( "TextRenderingMode" ) ) );
1599 TYPEINFOIMPL( TextRenderingMode );
1600
1601
1602 Lang::CharacterSpacingBinding::CharacterSpacingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Concrete::Length spacing )
1603 : bindingExpr_( bindingExpr ), spacing_( spacing ), isRelative_( false ), id_( id )
1604 { }
1605
1606 Lang::CharacterSpacingBinding::CharacterSpacingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const double r )
1607 : bindingExpr_( bindingExpr ), spacing_( r ), isRelative_( true ), id_( id )
1608 { }
1609
1610 Lang::CharacterSpacingBinding::~CharacterSpacingBinding( )
1611 { }
1612
1613 void
1614 Lang::CharacterSpacingBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
1615 {
1616 if( *sysBindings == 0 )
1617 {
1618 *sysBindings = new Kernel::SystemDynamicVariables( );
1619 Kernel::TextState * newState = new Kernel::TextState( );
1620 if( isRelative_ )
1621 {
1622 newState->setCharacterSpacing( Concrete::Length::offtype( spacing_ ) );
1623 }
1624 else
1625 {
1626 newState->setCharacterSpacing( spacing_ );
1627 }
1628 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1629 return;
1630 }
1631
1632 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
1633 {
1634 Kernel::TextState * newState = new Kernel::TextState( );
1635 if( isRelative_ )
1636 {
1637 newState->setCharacterSpacing( Concrete::Length::offtype( spacing_ ) );
1638 }
1639 else
1640 {
1641 newState->setCharacterSpacing( spacing_ );
1642 }
1643 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1644 return;
1645 }
1646
1647 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
1648
1649 if( newState->hasCharacterSpacing( ) )
1650 {
1651 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
1652 }
1653
1654 if( isRelative_ )
1655 {
1656 newState->setCharacterSpacing( Concrete::Length::offtype( spacing_ ) );
1657 }
1658 else
1659 {
1660 newState->setCharacterSpacing( spacing_ );
1661 }
1662 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1663 }
1664
1665 void
1666 Lang::CharacterSpacingBinding::show( std::ostream & os ) const
1667 {
1668 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":" ;
1669 if( isRelative_ )
1670 {
1671 os << Concrete::Length::offtype( spacing_ ) ;
1672 }
1673 else
1674 {
1675 os << spacing_ / Interaction::displayUnit << Interaction::displayUnitName ;
1676 }
1677 }
1678
1679 void
1680 Lang::CharacterSpacingBinding::gcMark( Kernel::GCMarkedSet & marked )
1681 { }
1682
1683
1684 Lang::WordSpacingBinding::WordSpacingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Concrete::Length spacing )
1685 : bindingExpr_( bindingExpr ), spacing_( spacing ), isRelative_( false ), id_( id )
1686 { }
1687
1688 Lang::WordSpacingBinding::WordSpacingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const double r )
1689 : bindingExpr_( bindingExpr ), spacing_( r ), isRelative_( true ), id_( id )
1690 { }
1691
1692 Lang::WordSpacingBinding::~WordSpacingBinding( )
1693 { }
1694
1695 void
1696 Lang::WordSpacingBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
1697 {
1698 if( *sysBindings == 0 )
1699 {
1700 *sysBindings = new Kernel::SystemDynamicVariables( );
1701 Kernel::TextState * newState = new Kernel::TextState( );
1702 if( isRelative_ )
1703 {
1704 newState->setWordSpacing( Concrete::Length::offtype( spacing_ ) );
1705 }
1706 else
1707 {
1708 newState->setWordSpacing( spacing_ );
1709 }
1710 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1711 return;
1712 }
1713
1714 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
1715 {
1716 Kernel::TextState * newState = new Kernel::TextState( );
1717 if( isRelative_ )
1718 {
1719 newState->setWordSpacing( Concrete::Length::offtype( spacing_ ) );
1720 }
1721 else
1722 {
1723 newState->setWordSpacing( spacing_ );
1724 }
1725 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1726 return;
1727 }
1728
1729 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
1730
1731 if( newState->hasWordSpacing( ) )
1732 {
1733 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
1734 }
1735
1736 if( isRelative_ )
1737 {
1738 newState->setWordSpacing( Concrete::Length::offtype( spacing_ ) );
1739 }
1740 else
1741 {
1742 newState->setWordSpacing( spacing_ );
1743 }
1744 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1745 }
1746
1747 void
1748 Lang::WordSpacingBinding::show( std::ostream & os ) const
1749 {
1750 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":" ;
1751 if( isRelative_ )
1752 {
1753 os << Concrete::Length::offtype( spacing_ ) ;
1754 }
1755 else
1756 {
1757 os << spacing_ / Interaction::displayUnit << Interaction::displayUnitName ;
1758 }
1759 }
1760
1761 void
1762 Lang::WordSpacingBinding::gcMark( Kernel::GCMarkedSet & marked )
1763 { }
1764
1765
1766 Lang::HorizontalScalingBinding::HorizontalScalingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, double scaling )
1767 : bindingExpr_( bindingExpr ), scaling_( scaling ), id_( id )
1768 { }
1769
1770 Lang::HorizontalScalingBinding::~HorizontalScalingBinding( )
1771 { }
1772
1773 void
1774 Lang::HorizontalScalingBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
1775 {
1776 if( *sysBindings == 0 )
1777 {
1778 *sysBindings = new Kernel::SystemDynamicVariables( );
1779 Kernel::TextState * newState = new Kernel::TextState( );
1780 newState->horizontalScaling_ = scaling_;
1781 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1782 return;
1783 }
1784
1785 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
1786 {
1787 Kernel::TextState * newState = new Kernel::TextState( );
1788 newState->horizontalScaling_ = scaling_;
1789 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1790 return;
1791 }
1792
1793 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
1794
1795 if( ! IS_NAN( newState->horizontalScaling_ ) )
1796 {
1797 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
1798 }
1799
1800 newState->horizontalScaling_ = scaling_;
1801 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1802 }
1803
1804 void
1805 Lang::HorizontalScalingBinding::show( std::ostream & os ) const
1806 {
1807 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":"
1808 << scaling_ ;
1809 }
1810
1811 void
1812 Lang::HorizontalScalingBinding::gcMark( Kernel::GCMarkedSet & marked )
1813 { }
1814
1815
1816 Lang::LeadingBinding::LeadingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Concrete::Length ty )
1817 : bindingExpr_( bindingExpr ), ty_( ty ), isRelative_( false ), id_( id )
1818 { }
1819
1820 Lang::LeadingBinding::LeadingBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const double r )
1821 : bindingExpr_( bindingExpr ), ty_( r ), isRelative_( true ), id_( id )
1822 { }
1823
1824 Lang::LeadingBinding::~LeadingBinding( )
1825 { }
1826
1827 void
1828 Lang::LeadingBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
1829 {
1830 if( *sysBindings == 0 )
1831 {
1832 *sysBindings = new Kernel::SystemDynamicVariables( );
1833 Kernel::TextState * newState = new Kernel::TextState( );
1834 if( isRelative_ )
1835 {
1836 newState->setLeading( Concrete::Length::offtype( ty_ ) );
1837 }
1838 else
1839 {
1840 newState->setLeading( ty_ );
1841 }
1842 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1843 return;
1844 }
1845
1846 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
1847 {
1848 Kernel::TextState * newState = new Kernel::TextState( );
1849 if( isRelative_ )
1850 {
1851 newState->setLeading( Concrete::Length::offtype( ty_ ) );
1852 }
1853 else
1854 {
1855 newState->setLeading( ty_ );
1856 }
1857 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1858 return;
1859 }
1860
1861 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
1862
1863 if( newState->hasLeading( ) )
1864 {
1865 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
1866 }
1867
1868 if( isRelative_ )
1869 {
1870 newState->setLeading( Concrete::Length::offtype( ty_ ) );
1871 }
1872 else
1873 {
1874 newState->setLeading( ty_ );
1875 }
1876 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1877 }
1878
1879 void
1880 Lang::LeadingBinding::show( std::ostream & os ) const
1881 {
1882 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":" ;
1883 if( isRelative_ )
1884 {
1885 os << Concrete::Length::offtype( ty_ ) ;
1886 }
1887 else
1888 {
1889 os << ty_ / Interaction::displayUnit << Interaction::displayUnitName ;
1890 }
1891 }
1892
1893 void
1894 Lang::LeadingBinding::gcMark( Kernel::GCMarkedSet & marked )
1895 { }
1896
1897
1898 Lang::FontBinding::FontBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const RefCountPtr< const Lang::Font > & font )
1899 : bindingExpr_( bindingExpr ), font_( font ), id_( id )
1900 { }
1901
1902 Lang::FontBinding::~FontBinding( )
1903 { }
1904
1905 void
1906 Lang::FontBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
1907 {
1908 if( *sysBindings == 0 )
1909 {
1910 *sysBindings = new Kernel::SystemDynamicVariables( );
1911 Kernel::TextState * newState = new Kernel::TextState( );
1912 newState->font_ = font_;
1913 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1914 return;
1915 }
1916
1917 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
1918 {
1919 Kernel::TextState * newState = new Kernel::TextState( );
1920 newState->font_ = font_;
1921 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1922 return;
1923 }
1924
1925 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
1926
1927 if( newState->font_ != NullPtr< const Lang::Font >( ) )
1928 {
1929 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
1930 }
1931
1932 newState->font_ = font_;
1933 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1934 }
1935
1936 void
1937 Lang::FontBinding::show( std::ostream & os ) const
1938 {
1939 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":" ;
1940 font_->show( os );
1941 }
1942
1943 void
1944 Lang::FontBinding::gcMark( Kernel::GCMarkedSet & marked )
1945 {
1946 const_cast< Lang::Font * >( font_.getPtr( ) )->gcMark( marked );
1947 }
1948
1949
1950 Lang::TextSizeBinding::TextSizeBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Concrete::Length size )
1951 : bindingExpr_( bindingExpr ), size_( size ), id_( id )
1952 { }
1953
1954 Lang::TextSizeBinding::~TextSizeBinding( )
1955 { }
1956
1957 void
1958 Lang::TextSizeBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
1959 {
1960 if( *sysBindings == 0 )
1961 {
1962 *sysBindings = new Kernel::SystemDynamicVariables( );
1963 Kernel::TextState * newState = new Kernel::TextState( );
1964 newState->size_ = size_;
1965 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1966 return;
1967 }
1968
1969 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
1970 {
1971 Kernel::TextState * newState = new Kernel::TextState( );
1972 newState->size_ = size_;
1973 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1974 return;
1975 }
1976
1977 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
1978
1979 if( ! IS_NAN( newState->size_ ) )
1980 {
1981 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
1982 }
1983
1984 newState->size_ = size_;
1985 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
1986 }
1987
1988 void
1989 Lang::TextSizeBinding::show( std::ostream & os ) const
1990 {
1991 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":"
1992 << size_ / Interaction::displayUnit << Interaction::displayUnitName ;
1993 }
1994
1995 void
1996 Lang::TextSizeBinding::gcMark( Kernel::GCMarkedSet & marked )
1997 { }
1998
1999
2000 Lang::TextRenderingModeBinding::TextRenderingModeBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Lang::TextRenderingMode::ValueType mode )
2001 : bindingExpr_( bindingExpr ), mode_( mode ), id_( id )
2002 { }
2003
2004 Lang::TextRenderingModeBinding::~TextRenderingModeBinding( )
2005 { }
2006
2007 void
2008 Lang::TextRenderingModeBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
2009 {
2010 if( *sysBindings == 0 )
2011 {
2012 *sysBindings = new Kernel::SystemDynamicVariables( );
2013 Kernel::TextState * newState = new Kernel::TextState( );
2014 newState->mode_ = mode_;
2015 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
2016 return;
2017 }
2018
2019 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
2020 {
2021 Kernel::TextState * newState = new Kernel::TextState( );
2022 newState->mode_ = mode_;
2023 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
2024 return;
2025 }
2026
2027 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
2028
2029 if( newState->mode_ != Lang::TextRenderingMode::UNDEFINED )
2030 {
2031 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
2032 }
2033
2034 newState->mode_ = mode_;
2035 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
2036 }
2037
2038 void
2039 Lang::TextRenderingModeBinding::show( std::ostream & os ) const
2040 {
2041 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":"
2042 << "<internal-enum>" ;
2043 }
2044
2045 void
2046 Lang::TextRenderingModeBinding::gcMark( Kernel::GCMarkedSet & marked )
2047 { }
2048
2049
2050 Lang::TextRiseBinding::TextRiseBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const Concrete::Length ty )
2051 : bindingExpr_( bindingExpr ), ty_( ty ), isRelative_( false ), id_( id )
2052 { }
2053
2054 Lang::TextRiseBinding::TextRiseBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const double r )
2055 : bindingExpr_( bindingExpr ), ty_( r ), isRelative_( true ), id_( id )
2056 { }
2057
2058 Lang::TextRiseBinding::~TextRiseBinding( )
2059 { }
2060
2061 void
2062 Lang::TextRiseBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
2063 {
2064 if( *sysBindings == 0 )
2065 {
2066 *sysBindings = new Kernel::SystemDynamicVariables( );
2067 Kernel::TextState * newState = new Kernel::TextState( );
2068 if( isRelative_ )
2069 {
2070 newState->setRise( Concrete::Length::offtype( ty_ ) );
2071 }
2072 else
2073 {
2074 newState->setRise( ty_ );
2075 }
2076 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
2077 return;
2078 }
2079
2080 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
2081 {
2082 Kernel::TextState * newState = new Kernel::TextState( );
2083 if( isRelative_ )
2084 {
2085 newState->setRise( Concrete::Length::offtype( ty_ ) );
2086 }
2087 else
2088 {
2089 newState->setRise( ty_ );
2090 }
2091 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
2092 return;
2093 }
2094
2095 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
2096
2097 if( newState->hasRise( ) )
2098 {
2099 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
2100 }
2101
2102 if( isRelative_ )
2103 {
2104 newState->setRise( Concrete::Length::offtype( ty_ ) );
2105 }
2106 else
2107 {
2108 newState->setRise( ty_ );
2109 }
2110 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
2111 }
2112
2113 void
2114 Lang::TextRiseBinding::show( std::ostream & os ) const
2115 {
2116 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":" ;
2117 if( isRelative_ )
2118 {
2119 os << Concrete::Length::offtype( ty_ ) ;
2120 }
2121 else
2122 {
2123 os << ty_ / Interaction::displayUnit << Interaction::displayUnitName ;
2124 }
2125 }
2126
2127 void
2128 Lang::TextRiseBinding::gcMark( Kernel::GCMarkedSet & marked )
2129 { }
2130
2131
2132 Lang::TextKnockoutBinding::TextKnockoutBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, bool knockout )
2133 : bindingExpr_( bindingExpr ), knockout_( knockout ), id_( id )
2134 { }
2135
2136 Lang::TextKnockoutBinding::~TextKnockoutBinding( )
2137 { }
2138
2139 void
2140 Lang::TextKnockoutBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
2141 {
2142 if( *sysBindings == 0 )
2143 {
2144 *sysBindings = new Kernel::SystemDynamicVariables( );
2145 Kernel::TextState * newState = new Kernel::TextState( );
2146 newState->knockout_ = knockout_;
2147 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
2148 return;
2149 }
2150
2151 if( (*sysBindings)->textState_ == NullPtr< const Kernel::TextState >( ) )
2152 {
2153 Kernel::TextState * newState = new Kernel::TextState( );
2154 newState->knockout_ = knockout_;
2155 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
2156 return;
2157 }
2158
2159 Kernel::TextState * newState = new Kernel::TextState( *((*sysBindings)->textState_) );
2160
2161 if( ( newState->knockout_ & Kernel::TextState::KNOCKOUT_UNDEFINED_BIT ) != 0 )
2162 {
2163 throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
2164 }
2165
2166 newState->knockout_ = ( knockout_ ? Kernel::TextState::KNOCKOUT_FLAG_BIT : 0 );
2167 (*sysBindings)->textState_ = RefCountPtr< const Kernel::TextState >( newState );
2168 }
2169
2170 void
2171 Lang::TextKnockoutBinding::show( std::ostream & os ) const
2172 {
2173 os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":"
2174 << ( knockout_ ? "true" : "false" ) ;
2175 }
2176
2177 void
2178 Lang::TextKnockoutBinding::gcMark( Kernel::GCMarkedSet & marked )
2179 { }
2180
2181
2182 Kernel::CharacterSpacingDynamicVariableProperties::CharacterSpacingDynamicVariableProperties( const char * name )
2183 : Kernel::DynamicVariableProperties( name )
2184 { }
2185
2186 Kernel::CharacterSpacingDynamicVariableProperties::~CharacterSpacingDynamicVariableProperties( )
2187 { }
2188
2189 Kernel::VariableHandle
2190 Kernel::CharacterSpacingDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
2191 {
2192 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
2193 return Kernel::VariableHandle( new Kernel::Variable( textState->characterSpacing( ) ) );
2194 }
2195
2196 void
2197 Kernel::CharacterSpacingDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
2198 {
2199 RefCountPtr< const Lang::Value > valUntyped = val->getUntyped( );
2200
2201 Kernel::ContRef cont = evalState->cont_;
2202
2203 try
2204 {
2205 typedef const Lang::Length ArgType;
2206 RefCountPtr< ArgType > spacing = Helpers::try_cast_CoreArgument< ArgType >( valUntyped );
2207 cont->takeValue( Kernel::ValueRef( new Lang::CharacterSpacingBinding( name_, bindingExpr, spacing->get( ) ) ),
2208 evalState );
2209 return;
2210 }
2211 catch( const NonLocalExit::NotThisType & ball )
2212 {
2213 /* Wrong type; never mind!.. but see below!
2214 */
2215 }
2216
2217 try
2218 {
2219 typedef const Lang::Float ArgType;
2220 RefCountPtr< ArgType > spacing = Helpers::try_cast_CoreArgument< ArgType >( valUntyped );
2221 cont->takeValue( Kernel::ValueRef( new Lang::CharacterSpacingBinding( name_, bindingExpr, spacing->val_ ) ),
2222 evalState );
2223 return;
2224 }
2225 catch( const NonLocalExit::NotThisType & ball )
2226 {
2227 /* Wrong type; never mind!.. but see below!
2228 */
2229 }
2230
2231 throw Exceptions::TypeMismatch( bindingExpr->exprLoc( ), valUntyped->getTypeName( ), Helpers::typeSetString( Lang::Length::staticTypeName( ), Lang::Float::staticTypeName( ) ) );
2232 }
2233
2234
2235 Kernel::WordSpacingDynamicVariableProperties::WordSpacingDynamicVariableProperties( const char * name )
2236 : Kernel::DynamicVariableProperties( name )
2237 { }
2238
2239 Kernel::WordSpacingDynamicVariableProperties::~WordSpacingDynamicVariableProperties( )
2240 { }
2241
2242 Kernel::VariableHandle
2243 Kernel::WordSpacingDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
2244 {
2245 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
2246 return Kernel::VariableHandle( new Kernel::Variable( textState->wordSpacing( ) ) );
2247 }
2248
2249 void
2250 Kernel::WordSpacingDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
2251 {
2252 RefCountPtr< const Lang::Value > valUntyped = val->getUntyped( );
2253
2254 Kernel::ContRef cont = evalState->cont_;
2255
2256 try
2257 {
2258 typedef const Lang::Length ArgType;
2259 RefCountPtr< ArgType > spacing = Helpers::try_cast_CoreArgument< ArgType >( valUntyped );
2260 cont->takeValue( Kernel::ValueRef( new Lang::WordSpacingBinding( name_, bindingExpr, spacing->get( ) ) ),
2261 evalState );
2262 return;
2263 }
2264 catch( const NonLocalExit::NotThisType & ball )
2265 {
2266 /* Wrong type; never mind!.. but see below!
2267 */
2268 }
2269
2270 try
2271 {
2272 typedef const Lang::Float ArgType;
2273 RefCountPtr< ArgType > spacing = Helpers::try_cast_CoreArgument< ArgType >( valUntyped );
2274 cont->takeValue( Kernel::ValueRef( new Lang::WordSpacingBinding( name_, bindingExpr, spacing->val_ ) ),
2275 evalState );
2276 return;
2277 }
2278 catch( const NonLocalExit::NotThisType & ball )
2279 {
2280 /* Wrong type; never mind!.. but see below!
2281 */
2282 }
2283
2284 throw Exceptions::TypeMismatch( bindingExpr->exprLoc( ), valUntyped->getTypeName( ), Helpers::typeSetString( Lang::Length::staticTypeName( ), Lang::Float::staticTypeName( ) ) );
2285 }
2286
2287
2288 Kernel::HorizontalScalingDynamicVariableProperties::HorizontalScalingDynamicVariableProperties( const char * name )
2289 : Kernel::DynamicVariableProperties( name )
2290 { }
2291
2292 Kernel::HorizontalScalingDynamicVariableProperties::~HorizontalScalingDynamicVariableProperties( )
2293 { }
2294
2295 Kernel::VariableHandle
2296 Kernel::HorizontalScalingDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
2297 {
2298 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
2299 return Kernel::VariableHandle( Shapes::Helpers::newValHandle( new Lang::Float( textState->horizontalScaling_ ) ) );
2300 }
2301
2302 void
2303 Kernel::HorizontalScalingDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
2304 {
2305 RefCountPtr< const Lang::Float > scaling = val->getVal< const Lang::Float >( bindingExpr->exprLoc( ) );
2306 Kernel::ContRef cont = evalState->cont_;
2307 cont->takeValue( Kernel::ValueRef( new Lang::HorizontalScalingBinding( name_, bindingExpr, scaling->val_ ) ),
2308 evalState );
2309 }
2310
2311
2312 Kernel::LeadingDynamicVariableProperties::LeadingDynamicVariableProperties( const char * name )
2313 : Kernel::DynamicVariableProperties( name )
2314 { }
2315
2316 Kernel::LeadingDynamicVariableProperties::~LeadingDynamicVariableProperties( )
2317 { }
2318
2319 Kernel::VariableHandle
2320 Kernel::LeadingDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
2321 {
2322 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
2323 return Kernel::VariableHandle( new Kernel::Variable( textState->leading( ) ) );
2324 }
2325
2326 void
2327 Kernel::LeadingDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
2328 {
2329 RefCountPtr< const Lang::Value > valUntyped = val->getUntyped( );
2330
2331 Kernel::ContRef cont = evalState->cont_;
2332
2333 try
2334 {
2335 typedef const Lang::Length ArgType;
2336 RefCountPtr< ArgType > ty = Helpers::try_cast_CoreArgument< ArgType >( valUntyped );
2337 cont->takeValue( Kernel::ValueRef( new Lang::LeadingBinding( name_, bindingExpr, ty->get( ) ) ),
2338 evalState );
2339 return;
2340 }
2341 catch( const NonLocalExit::NotThisType & ball )
2342 {
2343 /* Wrong type; never mind!.. but see below!
2344 */
2345 }
2346
2347 try
2348 {
2349 typedef const Lang::Float ArgType;
2350 RefCountPtr< ArgType > ty = Helpers::try_cast_CoreArgument< ArgType >( valUntyped );
2351 cont->takeValue( Kernel::ValueRef( new Lang::LeadingBinding( name_, bindingExpr, ty->val_ ) ),
2352 evalState );
2353 return;
2354 }
2355 catch( const NonLocalExit::NotThisType & ball )
2356 {
2357 /* Wrong type; never mind!.. but see below!
2358 */
2359 }
2360
2361 throw Exceptions::TypeMismatch( bindingExpr->exprLoc( ), valUntyped->getTypeName( ), Helpers::typeSetString( Lang::Length::staticTypeName( ), Lang::Float::staticTypeName( ) ) );
2362 }
2363
2364
2365 Kernel::FontDynamicVariableProperties::FontDynamicVariableProperties( const char * name )
2366 : Kernel::DynamicVariableProperties( name )
2367 { }
2368
2369 Kernel::FontDynamicVariableProperties::~FontDynamicVariableProperties( )
2370 { }
2371
2372 Kernel::VariableHandle
2373 Kernel::FontDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
2374 {
2375 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
2376 return Kernel::VariableHandle( new Kernel::Variable( textState->font_ ) );
2377 }
2378
2379 void
2380 Kernel::FontDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
2381 {
2382 Kernel::ContRef cont = evalState->cont_;
2383 cont->takeValue( Kernel::ValueRef( new Lang::FontBinding( name_, bindingExpr, val->getVal< const Lang::Font >( bindingExpr->exprLoc( ) ) ) ),
2384 evalState );
2385 }
2386
2387
2388 Kernel::TextSizeDynamicVariableProperties::TextSizeDynamicVariableProperties( const char * name )
2389 : Kernel::DynamicVariableProperties( name )
2390 { }
2391
2392 Kernel::TextSizeDynamicVariableProperties::~TextSizeDynamicVariableProperties( )
2393 { }
2394
2395 Kernel::VariableHandle
2396 Kernel::TextSizeDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
2397 {
2398 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
2399 return Kernel::VariableHandle( Shapes::Helpers::newValHandle( new Lang::Length( textState->size_ ) ) );
2400 }
2401
2402 void
2403 Kernel::TextSizeDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
2404 {
2405 RefCountPtr< const Lang::Length > size = val->getVal< const Lang::Length >( bindingExpr->exprLoc( ) );
2406 Kernel::ContRef cont = evalState->cont_;
2407 cont->takeValue( Kernel::ValueRef( new Lang::TextSizeBinding( name_, bindingExpr, size->get( ) ) ),
2408 evalState );
2409 }
2410
2411
2412 Kernel::TextRenderingModeDynamicVariableProperties::TextRenderingModeDynamicVariableProperties( const char * name )
2413 : Kernel::DynamicVariableProperties( name )
2414 { }
2415
2416 Kernel::TextRenderingModeDynamicVariableProperties::~TextRenderingModeDynamicVariableProperties( )
2417 { }
2418
2419 Kernel::VariableHandle
2420 Kernel::TextRenderingModeDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
2421 {
2422 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
2423 return Kernel::VariableHandle( Shapes::Helpers::newValHandle( new Lang::TextRenderingMode( textState->mode_ ) ) );
2424 }
2425
2426 void
2427 Kernel::TextRenderingModeDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
2428 {
2429 RefCountPtr< const Lang::TextRenderingMode > mode = val->getVal< const Lang::TextRenderingMode >( bindingExpr->exprLoc( ) );
2430 Kernel::ContRef cont = evalState->cont_;
2431 cont->takeValue( Kernel::ValueRef( new Lang::TextRenderingModeBinding( name_, bindingExpr, mode->mode_ ) ),
2432 evalState );
2433 }
2434
2435
2436 Kernel::TextRiseDynamicVariableProperties::TextRiseDynamicVariableProperties( const char * name )
2437 : Kernel::DynamicVariableProperties( name )
2438 { }
2439
2440 Kernel::TextRiseDynamicVariableProperties::~TextRiseDynamicVariableProperties( )
2441 { }
2442
2443 Kernel::VariableHandle
2444 Kernel::TextRiseDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
2445 {
2446 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
2447 return Kernel::VariableHandle( new Kernel::Variable( textState->rise( ) ) );
2448 }
2449
2450 void
2451 Kernel::TextRiseDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
2452 {
2453 RefCountPtr< const Lang::Value > valUntyped = val->getUntyped( );
2454
2455 Kernel::ContRef cont = evalState->cont_;
2456
2457 try
2458 {
2459 typedef const Lang::Length ArgType;
2460 RefCountPtr< ArgType > ty = Helpers::try_cast_CoreArgument< ArgType >( valUntyped );
2461 cont->takeValue( Kernel::ValueRef( new Lang::TextRiseBinding( name_, bindingExpr, ty->get( ) ) ),
2462 evalState );
2463 return;
2464 }
2465 catch( const NonLocalExit::NotThisType & ball )
2466 {
2467 /* Wrong type; never mind!.. but see below!
2468 */
2469 }
2470
2471 try
2472 {
2473 typedef const Lang::Float ArgType;
2474 RefCountPtr< ArgType > ty = Helpers::try_cast_CoreArgument< ArgType >( valUntyped );
2475 cont->takeValue( Kernel::ValueRef( new Lang::TextRiseBinding( name_, bindingExpr, ty->val_ ) ),
2476 evalState );
2477 return;
2478 }
2479 catch( const NonLocalExit::NotThisType & ball )
2480 {
2481 /* Wrong type; never mind!.. but see below!
2482 */
2483 }
2484
2485 throw Exceptions::TypeMismatch( bindingExpr->exprLoc( ), valUntyped->getTypeName( ), Helpers::typeSetString( Lang::Length::staticTypeName( ), Lang::Float::staticTypeName( ) ) );
2486 }
2487
2488
2489 Kernel::TextKnockoutDynamicVariableProperties::TextKnockoutDynamicVariableProperties( const char * name )
2490 : Kernel::DynamicVariableProperties( name )
2491 { }
2492
2493 Kernel::TextKnockoutDynamicVariableProperties::~TextKnockoutDynamicVariableProperties( )
2494 { }
2495
2496 Kernel::VariableHandle
2497 Kernel::TextKnockoutDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
2498 {
2499 RefCountPtr< const Kernel::TextState > textState = dyn->getTextState( );
2500 return Kernel::VariableHandle( Shapes::Helpers::newValHandle( new Lang::Boolean( ( textState->knockout_ & Kernel::TextState::KNOCKOUT_FLAG_BIT ) != 0 ) ) );
2501 }
2502
2503 void
2504 Kernel::TextKnockoutDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
2505 {
2506 RefCountPtr< const Lang::Boolean > mode = val->getVal< const Lang::Boolean >( bindingExpr->exprLoc( ) );
2507 Kernel::ContRef cont = evalState->cont_;
2508 cont->takeValue( Kernel::ValueRef( new Lang::TextKnockoutBinding( name_, bindingExpr, mode->val_ ) ),
2509 evalState );
2510 }
2511
2512
2513
2514 Kernel::TextState::TextState( )
2515 : relativeFlags_( 0 ),
2516 characterSpacing_( Concrete::Length( std::numeric_limits< double >::signaling_NaN( ) ) ),
2517 wordSpacing_( Concrete::Length( std::numeric_limits< double >::signaling_NaN( ) ) ),
2518 horizontalScaling_( std::numeric_limits< double >::signaling_NaN( ) ),
2519 leading_( Concrete::Length( std::numeric_limits< double >::signaling_NaN( ) ) ),
2520 rise_( Concrete::Length( std::numeric_limits< double >::signaling_NaN( ) ) ),
2521 font_( NullPtr< const Lang::Font >( ) ),
2522 size_( Concrete::Length( std::numeric_limits< double >::signaling_NaN( ) ) ),
2523 mode_( Lang::TextRenderingMode::UNDEFINED ),
2524 knockout_( KNOCKOUT_UNDEFINED_BIT )
2525 { }
2526
2527 Kernel::TextState::TextState( const Kernel::TextState & orig )
2528 : relativeFlags_( orig.relativeFlags_ ),
2529 characterSpacing_( orig.characterSpacing_ ),
2530 wordSpacing_( orig.wordSpacing_ ),
2531 horizontalScaling_( orig.horizontalScaling_ ),
2532 leading_( orig.leading_ ),
2533 rise_( orig.rise_ ),
2534 font_( orig.font_ ),
2535 size_( orig.size_ ),
2536 mode_( orig.mode_ ),
2537 knockout_( orig.knockout_ )
2538 { }
2539
2540 Kernel::TextState::TextState( const Kernel::TextState & newValues, const Kernel::TextState & oldValues )
2541 : relativeFlags_( oldValues.relativeFlags_ ),
2542 characterSpacing_( oldValues.characterSpacing_ ),
2543 wordSpacing_( oldValues.wordSpacing_ ),
2544 horizontalScaling_( oldValues.horizontalScaling_ ),
2545 leading_( oldValues.leading_ ),
2546 rise_( oldValues.rise_ ),
2547 font_( oldValues.font_ ),
2548 size_( oldValues.size_ ),
2549 mode_( oldValues.mode_ ),
2550 knockout_( oldValues.knockout_ )
2551 {
2552 if( newValues.hasCharacterSpacing( ) )
2553 {
2554 characterSpacing_ = newValues.characterSpacing_;
2555 relativeFlags_ = ( newValues.characterSpacingIsRelative( ) ? ( relativeFlags_ | RELATIVE_CHARACTER_SPACING ) : ( relativeFlags_ & ~RELATIVE_CHARACTER_SPACING ) );
2556 }
2557 if( newValues.hasWordSpacing( ) )
2558 {
2559 wordSpacing_ = newValues.wordSpacing_;
2560 relativeFlags_ = ( newValues.wordSpacingIsRelative( ) ? ( relativeFlags_ | RELATIVE_WORD_SPACING ) : ( relativeFlags_ & ~RELATIVE_WORD_SPACING ) );
2561 }
2562 if( ! IS_NAN( newValues.horizontalScaling_ ) )
2563 {
2564 horizontalScaling_ = newValues.horizontalScaling_;
2565 }
2566 if( newValues.hasLeading( ) )
2567 {
2568 leading_ = newValues.leading_;
2569 relativeFlags_ = ( newValues.leadingIsRelative( ) ? ( relativeFlags_ | RELATIVE_LEADING ) : ( relativeFlags_ & ~RELATIVE_LEADING ) );
2570 }
2571 if( newValues.hasRise( ) )
2572 {
2573 rise_ = newValues.rise_;
2574 relativeFlags_ = ( newValues.riseIsRelative( ) ? ( relativeFlags_ | RELATIVE_RISE ) : ( relativeFlags_ & ~RELATIVE_RISE ) );
2575 }
2576 if( newValues.font_ != NullPtr< const Lang::Font >( ) )
2577 {
2578 font_ = newValues.font_;
2579 }
2580 if( ! IS_NAN( newValues.size_ ) )
2581 {
2582 size_ = newValues.size_;
2583 }
2584 if( newValues.mode_ != Lang::TextRenderingMode::UNDEFINED )
2585 {
2586 mode_ = newValues.mode_;
2587 }
2588 if( ! ( newValues.knockout_ & KNOCKOUT_UNDEFINED_BIT ) )
2589 {
2590 knockout_ = newValues.knockout_;
2591 }
2592 }
2593
2594 std::map< bool, RefCountPtr< SimplePDF::PDF_Object > > Kernel::TextState::knockoutNameMap_;
2595
2596 Kernel::TextState::TextState( bool setDefaults )
2597 : relativeFlags_( RELATIVE_LEADING ),
2598 characterSpacing_( 0 ),
2599 wordSpacing_( 0 ),
2600 horizontalScaling_( 1 ),
2601 leading_( 1 ),
2602 rise_( 0 ),
2603 font_( Lang::THE_FONT_HELVETICA ),
2604 size_( Concrete::Length( 10 ) ),
2605 mode_( Lang::TextRenderingMode::FILL ),
2606 knockout_( 0 ) // this means false
2607 {
2608 if( ! setDefaults )
2609 {
2610 throw Exceptions::InternalError( strrefdup( "setDefaults must be true in TextState::TextState." ) );
2611 }
2612 }
2613
2614 Kernel::TextState::~TextState( )
2615 { }
2616
2617 void
2618 Kernel::TextState::print( std::ostream & os, const std::string & indentation ) const
2619 {
2620 if( font_ != NullPtr< const Lang::Font >( ) )
2621 {
2622 os << indentation << Interaction::DYNAMIC_VARIABLE_PREFIX << Lang::DYNAMIC_VARIABLE_ID_TEXT_FONT << ": " << font_->fontName( ) << std::endl ;
2623 }
2624 if( ! IS_NAN( size_ ) )
2625 {
2626 os << indentation << Interaction::DYNAMIC_VARIABLE_PREFIX << Lang::DYNAMIC_VARIABLE_ID_TEXT_SIZE << ": " << size_ / Interaction::displayUnit << Interaction::displayUnitName << std::endl ;
2627 }
2628 os << "(and a bunch of other variables...)" << std::endl ;
2629 }
2630
2631
2632 void
2633 Kernel::TextState::setLeading( const Concrete::Length leading )
2634 {
2635 relativeFlags_ &= ~ RELATIVE_LEADING;
2636 leading_ = leading;
2637 }
2638
2639 void
2640 Kernel::TextState::setLeading( const double relativeLeading )
2641 {
2642 relativeFlags_ |= RELATIVE_LEADING;
2643 leading_ = Concrete::Length( relativeLeading ); // We must keep track of this type trick by always looking at relativeFlags_ & RELATIVE_LEADING.
2644 }
2645
2646 RefCountPtr< const Lang::Value >
2647 Kernel::TextState::leading( ) const
2648 {
2649 if( leadingIsRelative( ) )
2650 {
2651 return RefCountPtr< const Lang::Value >( new Lang::Float( Concrete::Length::offtype( leading_ ) ) );
2652 }
2653 return RefCountPtr< const Lang::Value >( new Lang::Length( leading_ ) );
2654 }
2655
2656 Concrete::Length
2657 Kernel::TextState::leadingConcrete( ) const
2658 {
2659 if( leadingIsRelative( ) )
2660 {
2661 return Concrete::Length::offtype( leading_ ) * size_;
2662 }
2663 return leading_;
2664 }
2665
2666 bool
2667 Kernel::TextState::hasLeading( ) const
2668 {
2669 return ! IS_NAN( leading_ );
2670 }
2671
2672 bool
2673 Kernel::TextState::leadingIsRelative( ) const
2674 {
2675 return ( relativeFlags_ & RELATIVE_LEADING ) != 0;
2676 }
2677
2678
2679 void
2680 Kernel::TextState::setRise( const Concrete::Length rise )
2681 {
2682 relativeFlags_ &= ~ RELATIVE_RISE;
2683 rise_ = rise;
2684 }
2685
2686 void
2687 Kernel::TextState::setRise( const double relativeRise )
2688 {
2689 relativeFlags_ |= RELATIVE_RISE;
2690 rise_ = Concrete::Length( relativeRise ); // We must keep track of this type trick by always looking at relativeFlags_ & RELATIVE_RISE.
2691 }
2692
2693 RefCountPtr< const Lang::Value >
2694 Kernel::TextState::rise( ) const
2695 {
2696 if( riseIsRelative( ) )
2697 {
2698 return RefCountPtr< const Lang::Value >( new Lang::Float( Concrete::Length::offtype( rise_ ) ) );
2699 }
2700 return RefCountPtr< const Lang::Value >( new Lang::Length( rise_ ) );
2701 }
2702
2703 Concrete::Length
2704 Kernel::TextState::riseConcrete( ) const
2705 {
2706 if( riseIsRelative( ) )
2707 {
2708 return Concrete::Length::offtype( rise_ ) * size_;
2709 }
2710 return rise_;
2711 }
2712
2713 bool
2714 Kernel::TextState::hasRise( ) const
2715 {
2716 return ! IS_NAN( rise_ );
2717 }
2718
2719 bool
2720 Kernel::TextState::riseIsRelative( ) const
2721 {
2722 return ( relativeFlags_ & RELATIVE_RISE ) != 0;
2723 }
2724
2725
2726 void
2727 Kernel::TextState::setCharacterSpacing( const Concrete::Length spacing )
2728 {
2729 relativeFlags_ &= ~ RELATIVE_CHARACTER_SPACING;
2730 characterSpacing_ = spacing;
2731 }
2732
2733 void
2734 Kernel::TextState::setCharacterSpacing( const double relativeSpacing )
2735 {
2736 relativeFlags_ |= RELATIVE_CHARACTER_SPACING;
2737 characterSpacing_ = Concrete::Length( relativeSpacing ); // We must keep track of this type trick by always looking at the relevant bit in relativeFlags_.
2738 }
2739
2740 RefCountPtr< const Lang::Value >
2741 Kernel::TextState::characterSpacing( ) const
2742 {
2743 if( characterSpacingIsRelative( ) )
2744 {
2745 return RefCountPtr< const Lang::Value >( new Lang::Float( Concrete::Length::offtype( characterSpacing_ ) ) );
2746 }
2747 return RefCountPtr< const Lang::Value >( new Lang::Length( characterSpacing_ ) );
2748 }
2749
2750 Concrete::Length
2751 Kernel::TextState::characterSpacingConcrete( ) const
2752 {
2753 if( characterSpacingIsRelative( ) )
2754 {
2755 return Concrete::Length::offtype( characterSpacing_ ) * size_;
2756 }
2757 return characterSpacing_;
2758 }
2759
2760 bool
2761 Kernel::TextState::hasCharacterSpacing( ) const
2762 {
2763 return ! IS_NAN( characterSpacing_ );
2764 }
2765
2766 bool
2767 Kernel::TextState::characterSpacingIsRelative( ) const
2768 {
2769 return ( relativeFlags_ & RELATIVE_CHARACTER_SPACING ) != 0;
2770 }
2771
2772
2773 void
2774 Kernel::TextState::setWordSpacing( const Concrete::Length spacing )
2775 {
2776 relativeFlags_ &= ~ RELATIVE_WORD_SPACING;
2777 wordSpacing_ = spacing;
2778 }
2779
2780 void
2781 Kernel::TextState::setWordSpacing( const double relativeSpacing )
2782 {
2783 relativeFlags_ |= RELATIVE_WORD_SPACING;
2784 wordSpacing_ = Concrete::Length( relativeSpacing ); // We must keep track of this type trick by always looking at the relevant bit in relativeFlags_.
2785 }
2786
2787 RefCountPtr< const Lang::Value >
2788 Kernel::TextState::wordSpacing( ) const
2789 {
2790 if( wordSpacingIsRelative( ) )
2791 {
2792 return RefCountPtr< const Lang::Value >( new Lang::Float( Concrete::Length::offtype( wordSpacing_ ) ) );
2793 }
2794 return RefCountPtr< const Lang::Value >( new Lang::Length( wordSpacing_ ) );
2795 }
2796
2797 Concrete::Length
2798 Kernel::TextState::wordSpacingConcrete( ) const
2799 {
2800 if( wordSpacingIsRelative( ) )
2801 {
2802 return Concrete::Length::offtype( wordSpacing_ ) * size_;
2803 }
2804 return wordSpacing_;
2805 }
2806
2807 bool
2808 Kernel::TextState::hasWordSpacing( ) const
2809 {
2810 return ! IS_NAN( wordSpacing_ );
2811 }
2812
2813 bool
2814 Kernel::TextState::wordSpacingIsRelative( ) const
2815 {
2816 return ( relativeFlags_ & RELATIVE_WORD_SPACING ) != 0;
2817 }
2818
2819
2820 bool
2821 Kernel::TextState::synchAssertKnockout( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool clip, bool force )
2822 {
2823 assertKnockout( ref );
2824 return synchButKnockout( os, ref, resources, clip, force );
2825 }
2826
2827 bool
2828 Kernel::TextState::synchCharacterSpacing( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force )
2829 {
2830 if( force ||
2831 characterSpacing_ != ref->characterSpacing_ ||
2832 characterSpacingIsRelative( ) != ref->characterSpacingIsRelative( ) )
2833 {
2834 if( ! ref->hasCharacterSpacing( ) )
2835 {
2836 return false;
2837 }
2838 relativeFlags_ = ( ref->characterSpacingIsRelative( ) ? ( relativeFlags_ | RELATIVE_CHARACTER_SPACING ) : ( relativeFlags_ & ~RELATIVE_CHARACTER_SPACING ) );
2839 characterSpacing_ = ref->characterSpacing_;
2840 if( characterSpacingIsRelative( ) )
2841 {
2842 os << Concrete::Length::offtype( characterSpacing_ ) * Concrete::Length::offtype( ref->size_ ) << " Tc " ;
2843 }
2844 else
2845 {
2846 os << Concrete::Length::offtype( characterSpacing_ ) << " Tc " ;
2847 }
2848 return true;
2849 }
2850 return false;
2851 }
2852
2853 bool
2854 Kernel::TextState::synchWordSpacing( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force )
2855 {
2856 if( force ||
2857 wordSpacing_ != ref->wordSpacing_ ||
2858 wordSpacingIsRelative( ) != ref->wordSpacingIsRelative( ) )
2859 {
2860 if( ! ref->hasWordSpacing( ) )
2861 {
2862 return false;
2863 }
2864 relativeFlags_ = ( ref->wordSpacingIsRelative( ) ? ( relativeFlags_ | RELATIVE_WORD_SPACING ) : ( relativeFlags_ & ~RELATIVE_WORD_SPACING ) );
2865 wordSpacing_ = ref->wordSpacing_;
2866 if( wordSpacingIsRelative( ) )
2867 {
2868 os << Concrete::Length::offtype( wordSpacing_ ) * Concrete::Length::offtype( ref->size_ ) << " Tw " ;
2869 }
2870 else
2871 {
2872 os << Concrete::Length::offtype( wordSpacing_ ) << " Tw " ;
2873 }
2874 return true;
2875 }
2876 return false;
2877 }
2878
2879 bool
2880 Kernel::TextState::synchHorizontalScaling( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force )
2881 {
2882 if( force || horizontalScaling_ != ref->horizontalScaling_ )
2883 {
2884 if( IS_NAN( ref->horizontalScaling_ ) )
2885 {
2886 return false;
2887 }
2888 horizontalScaling_ = ref->horizontalScaling_;
2889 os << 100 * horizontalScaling_ << " Tz " ;
2890 return true;
2891 }
2892 return false;
2893 }
2894
2895 bool
2896 Kernel::TextState::synchLeading( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force )
2897 {
2898 if( force ||
2899 leading_ != ref->leading_ ||
2900 leadingIsRelative( ) != ref->leadingIsRelative( ) )
2901 {
2902 if( ! ref->hasLeading( ) )
2903 {
2904 return false;
2905 }
2906 relativeFlags_ = ( ref->leadingIsRelative( ) ? ( relativeFlags_ | RELATIVE_LEADING ) : ( relativeFlags_ & ~RELATIVE_LEADING ) );
2907 leading_ = ref->leading_;
2908 if( leadingIsRelative( ) )
2909 {
2910 os << Concrete::Length::offtype( leading_ ) * Concrete::Length::offtype( ref->size_ ) << " TL " ;
2911 }
2912 else
2913 {
2914 os << Concrete::Length::offtype( leading_ ) << " TL " ;
2915 }
2916 return true;
2917 }
2918 return false;
2919 }
2920
2921 bool
2922 Kernel::TextState::synchFontAndSize( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force )
2923 {
2924 if( force ||
2925 font_ != ref->font_ ||
2926 size_ != ref->size_ )
2927 {
2928 if( ref->font_ == NullPtr< const Lang::Font >( ) &&
2929 IS_NAN( ref->size_ ) )
2930 {
2931 return false;
2932 }
2933 if( ref->font_ == NullPtr< const Lang::Font >( ) ||
2934 IS_NAN( ref->size_ ) )
2935 {
2936 throw Exceptions::MiscellaneousRequirement( "It is impossible to leave unspecified only one of font and size." );
2937 }
2938 bool sizeChanged = ( size_ != ref->size_ );
2939 font_ = ref->font_;
2940 size_ = ref->size_;
2941 os << resources->nameofFont( font_->resource( ) ) << " " << Concrete::Length::offtype( size_ ) << " Tf " ;
2942 if( sizeChanged )
2943 {
2944 if( ref->hasLeading( ) && ref->leadingIsRelative( ) )
2945 {
2946 synchLeading( os, ref, resources, true );
2947 }
2948 if( ref->hasRise( ) && ref->riseIsRelative( ) )
2949 {
2950 synchRise( os, ref, resources, true );
2951 }
2952 if( ref->hasCharacterSpacing( ) && ref->characterSpacingIsRelative( ) )
2953 {
2954 synchCharacterSpacing( os, ref, resources, true );
2955 }
2956 if( ref->hasWordSpacing( ) && ref->wordSpacingIsRelative( ) )
2957 {
2958 synchWordSpacing( os, ref, resources, true );
2959 }
2960 }
2961 return true;
2962 }
2963 return false;
2964 }
2965
2966 bool
2967 Kernel::TextState::synchMode( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool clip, bool force )
2968 {
2969 Lang::TextRenderingMode::ValueType refMode = clip ? Lang::TextRenderingMode::clipMode( ref->mode_ ) : ref->mode_ ;
2970 if( force || mode_ != refMode )
2971 {
2972 if( ref->mode_ == Lang::TextRenderingMode::UNDEFINED )
2973 {
2974 return false;
2975 }
2976 mode_ = refMode;
2977 os << mode_ << " Tr " ;
2978 return true;
2979 }
2980 return false;
2981 }
2982
2983 bool
2984 Kernel::TextState::synchRise( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force )
2985 {
2986 if( force ||
2987 rise_ != ref->rise_ ||
2988 riseIsRelative( ) != ref->riseIsRelative( ) )
2989 {
2990 if( ! ref->hasRise( ) )
2991 {
2992 return false;
2993 }
2994 relativeFlags_ = ( ref->riseIsRelative( ) ? ( relativeFlags_ | RELATIVE_RISE ) : ( relativeFlags_ & ~RELATIVE_RISE ) );
2995 rise_ = ref->rise_;
2996 if( riseIsRelative( ) )
2997 {
2998 os << Concrete::Length::offtype( rise_ ) * Concrete::Length::offtype( ref->size_ ) << " Ts " ;
2999 }
3000 else
3001 {
3002 os << Concrete::Length::offtype( rise_ ) << " Ts " ;
3003 }
3004 return true;
3005 }
3006 return false;
3007 }
3008
3009 bool
3010 Kernel::TextState::synchKnockout( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool force )
3011 {
3012 if( force || knockout_ != ref->knockout_ )
3013 {
3014 if( ( ref->knockout_ & Kernel::TextState::KNOCKOUT_UNDEFINED_BIT ) != 0 )
3015 {
3016 return false;
3017 }
3018 const SimplePDF::PDF_Version::Version KNOCKOUT_VERSION = SimplePDF::PDF_Version::PDF_1_4;
3019 if( ! Kernel::the_PDF_version.greaterOrEqual( KNOCKOUT_VERSION ) )
3020 {
3021 Kernel::the_PDF_version.message( KNOCKOUT_VERSION, "The text state knockout mode setting was ignored." );
3022 }
3023 knockout_ = ref->knockout_;
3024 typedef typeof knockoutNameMap_ MapType;
3025 MapType::const_iterator i = knockoutNameMap_.find( knockout_ );
3026 if( i != knockoutNameMap_.end( ) )
3027 {
3028 os << resources->nameofGraphicsState( i->second ) << " gs " ;
3029 }
3030 else
3031 {
3032 RefCountPtr< SimplePDF::PDF_Dictionary > dic;
3033 (*dic)[ "Type" ] = SimplePDF::newName( "ExtGState" );
3034 (*dic)[ "TK" ] = SimplePDF::newBoolean( knockout_ );
3035
3036 RefCountPtr< SimplePDF::PDF_Object > indirection = SimplePDF::indirect( dic, & Kernel::theIndirectObjectCount );
3037 knockoutNameMap_.insert( MapType::value_type( knockout_, indirection ) );
3038
3039 os << resources->nameofGraphicsState( indirection ) << " gs " ;
3040 }
3041 return true;
3042 }
3043 return false;
3044 }
3045
3046 void
3047 Kernel::TextState::assertKnockout( const Kernel::TextState * ref )
3048 {
3049 if( knockout_ != ref->knockout_ )
3050 {
3051 throw Exceptions::MiscellaneousRequirement( "PDF does not allow the text knockout mode to change within a text object." );
3052 }
3053 }
3054
3055 bool
3056 Kernel::TextState::synchButKnockout( std::ostream & os, const Kernel::TextState * ref, SimplePDF::PDF_Resources * resources, bool clip, bool force )
3057 {
3058 bool anyChange = false;
3059 anyChange = synchCharacterSpacing( os, ref, resources, force ) || anyChange;
3060 anyChange = synchWordSpacing( os, ref, resources, force ) || anyChange;
3061 anyChange = synchHorizontalScaling( os, ref, resources, force ) || anyChange;
3062 anyChange = synchFontAndSize( os, ref, resources, force ) || anyChange;
3063 anyChange = synchLeading( os, ref, resources, force ) || anyChange; // It is important that this is done after synching the size!
3064 anyChange = synchMode( os, ref, resources, clip, force ) || anyChange;
3065 anyChange = synchRise( os, ref, resources, force ) || anyChange;
3066 if( anyChange )
3067 {
3068 os << std::endl ;
3069 }
3070 return anyChange;
3071 }
3072
3073
3074 Lang::FontMethod_glyph::FontMethod_glyph( RefCountPtr< const Lang::Font > self, const Ast::FileID * fullMethodID )
3075 : Lang::MethodBase< class_type >( self, fullMethodID, false, true )
3076 {
3077 formals_->appendEvaluatedCoreFormal( "char", Kernel::THE_SLOT_VARIABLE );
3078 }
3079
3080 Lang::FontMethod_glyph::~FontMethod_glyph( )
3081 { }
3082
3083 void
3084 Lang::FontMethod_glyph::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
3085 {
3086 args.applyDefaults( );
3087
3088 size_t argsi = 0;
3089 typedef const Lang::Character ArgType;
3090
3091 Kernel::ContRef cont = evalState->cont_;
3092 cont->takeValue( self_->getGlyph( Helpers::down_cast_CoreArgument< ArgType >( title_, args, argsi, callLoc )->val_,
3093 evalState->dyn_->getTextState( )->size_ ),
3094 evalState );
3095 return;
3096 }
Graphics language