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