source/pdfstructure.cc

   1 /* This file is part of Shapes.
   2  *
   3  * Shapes is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * any later version.
   7  *
   8  * Shapes is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with Shapes.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  * Copyright 2008 Henrik Tidefelt
  17  */
  18
  19 #include <iomanip>
  20 #include <cstdlib>
  21 #include <cstring>
  22 #include <cstdio>
  23 #include <zlib.h>
  24
  25 #include "pdfstructure.h"
  26 #include "simplepdfo.h"
  27 #include "simplepdfi.h"
  28 #include "autoonoff.h"
  29
  30 using namespace std;
  31
  32 using namespace SimplePDF;
  33
  34 /****************/
  35
  36 SimplePDF::PDF_Object::PDF_Object( )
  37         : complete( false )
  38 { }
  39 SimplePDF::PDF_Object::~PDF_Object( )
  40 { }
  41 void
  42 SimplePDF::PDF_Object::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
  43 {
  44         throw "This function, PDF_Object::writeTo, must not be called.  It is practically purely virtual.";
  45 }
  46 RefCountPtr< PDF_Object >
  47 SimplePDF::PDF_Object::deepCopy( RefCountPtr< PDF_Object > self, size_t * indirectObjectCounter, IndirectRemapType * remap )
  48 {
  49         return self;
  50 }
  51
  52 /****************/
  53
  54 template< class S >
  55 RefCountPtr< S >
  56 SimplePDF::down_cast_follow( RefCountPtr< PDF_Object > maybeIndirect )
  57 {
  58         {
  59                 const PDF_Indirect_in * theIndirect( dynamic_cast< const PDF_Indirect_in * >( maybeIndirect.getPtr( ) ) );
  60                 if( theIndirect != 0 )
  61                         {
  62                                 return theIndirect->PDFin->follow< S >( maybeIndirect );
  63                         }
  64         }
  65         {
  66                 const PDF_Indirect_out * theIndirect( dynamic_cast< const PDF_Indirect_out * >( maybeIndirect.getPtr( ) ) );
  67                 if( theIndirect != 0 )
  68                         {
  69                                 return SimplePDF::down_cast_follow< S >( theIndirect->obj );
  70                         }
  71         }
  72
  73         return maybeIndirect.down_cast< S >( );
  74 }
  75
  76 namespace SimplePDF
  77 {
  78         template< >
  79         RefCountPtr< SimplePDF::PDF_Float >
  80         down_cast_follow< SimplePDF::PDF_Float >( RefCountPtr< PDF_Object > maybeIndirect )
  81         {
  82                 {
  83                         const PDF_Indirect_in * theIndirect( dynamic_cast< const PDF_Indirect_in * >( maybeIndirect.getPtr( ) ) );
  84                         if( theIndirect != 0 )
  85                                 {
  86                                         return theIndirect->PDFin->follow< SimplePDF::PDF_Float >( maybeIndirect );
  87                                 }
  88                 }
  89                 {
  90                         const PDF_Indirect_out * theIndirect( dynamic_cast< const PDF_Indirect_out * >( maybeIndirect.getPtr( ) ) );
  91                         if( theIndirect != 0 )
  92                                 {
  93                                         return SimplePDF::down_cast_follow< SimplePDF::PDF_Float >( theIndirect->obj );
  94                                 }
  95                 }
  96                 {
  97                         RefCountPtr< PDF_Int > res( maybeIndirect.down_cast< PDF_Int >( ) );
  98                         if( res != NullPtr< PDF_Int >( ) )
  99                                 {
 100                                         return RefCountPtr< PDF_Float >( new PDF_Float( res->value( ) ) );
 101                                 }
 102                 }
 103                 return maybeIndirect.down_cast< SimplePDF::PDF_Float >( );
 104         }
 105 }
 106
 107 namespace SimplePDF
 108 {
 109         template RefCountPtr< SimplePDF::PDF_Vector > down_cast_follow< SimplePDF::PDF_Vector >( RefCountPtr< PDF_Object > );
 110 }
 111
 112 /****************/
 113
 114 SimplePDF::PDF_Null::PDF_Null( )
 115 { }
 116 SimplePDF::PDF_Null::~PDF_Null( )
 117 { }
 118
 119 void
 120 SimplePDF::PDF_Null::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 121 {
 122         os << "null" ;
 123 }
 124
 125 /****************/
 126
 127 SimplePDF::PDF_Boolean::PDF_Boolean( ValueType _value )
 128         : my_value( _value )
 129 { }
 130 SimplePDF::PDF_Boolean::~PDF_Boolean( )
 131 { }
 132
 133 SimplePDF::PDF_Boolean::ValueType
 134 SimplePDF::PDF_Boolean::value( ) const
 135 {
 136         return my_value;
 137 }
 138
 139 void
 140 SimplePDF::PDF_Boolean::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 141 {
 142         if( my_value )
 143                 {
 144                         os << "true" ;
 145                 }
 146         else
 147                 {
 148                         os << "false" ;
 149                 }
 150 }
 151
 152 /****************/
 153
 154 SimplePDF::PDF_Int::PDF_Int( PDF_Int::ValueType _value )
 155         : my_value( _value )
 156 { }
 157 SimplePDF::PDF_Int::PDF_Int( const char * strvalue )
 158 {
 159         /* How can it be that end shall be non-const, while strvalue is const? */
 160         //      const char * end;
 161         char * end;
 162         my_value = strtol( strvalue, & end, 10 );
 163         if( *end != '\0' )
 164                 {
 165                         throw "Internal error: Bad numeric int format";
 166                 }
 167 }
 168 SimplePDF::PDF_Int::~PDF_Int( )
 169 { }
 170
 171 PDF_Int::ValueType
 172 SimplePDF::PDF_Int::value( ) const
 173 {
 174         return my_value;
 175 }
 176
 177 void
 178 SimplePDF::PDF_Int::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 179 {
 180         os << my_value ;
 181 }
 182
 183 /****************/
 184
 185 SimplePDF::PDF_Float::PDF_Float( PDF_Float::ValueType _value )
 186         : my_value( _value )
 187 { }
 188 SimplePDF::PDF_Float::PDF_Float( const char * strvalue )
 189 {
 190         /* How can it be that end shall be non-const, while strvalue is const? */
 191         //      const char * end;
 192         char * end;
 193         my_value = strtod( strvalue, & end );
 194         if( *end != '\0' )
 195                 {
 196                         throw( "Internal error: Bad numeric float format" );
 197                 }
 198 }
 199 SimplePDF::PDF_Float::~PDF_Float( )
 200 { }
 201
 202 SimplePDF::PDF_Float::ValueType PDF_Float::value( ) const
 203 {
 204         return my_value;
 205 }
 206
 207 void
 208 SimplePDF::PDF_Float::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 209 {
 210         os << my_value ;
 211 }
 212
 213 /****************/
 214
 215 SimplePDF::PDF_String::PDF_String( )
 216 { }
 217 SimplePDF::PDF_String::~PDF_String( )
 218 { }
 219
 220 /****************/
 221
 222 SimplePDF::PDF_LiteralString::PDF_LiteralString( const string & _str )
 223         : my_str( _str )
 224 { }
 225 SimplePDF::PDF_LiteralString::PDF_LiteralString( const char * _str )
 226         : my_str( _str )
 227 { }
 228 SimplePDF::PDF_LiteralString::PDF_LiteralString( const list< RefCountPtr< char > > & strs )
 229 {
 230         size_t length( 0 );
 231         typedef list< RefCountPtr< char > >::const_iterator I;
 232         for( I i( strs.begin( ) ); i != strs.end( ); ++i )
 233                 {
 234                         length += strlen( i->getPtr( ) );
 235                 }
 236         RefCountPtr< char > mem( new char[ length + 1 ] );
 237         char * dst = mem.getPtr( );
 238         for( I i( strs.begin( ) ); i != strs.end( ); ++i )
 239                 {
 240                         strcpy( dst, i->getPtr( ) );
 241                         dst += strlen( i->getPtr( ) );
 242                 }
 243         *dst = '\0';
 244         my_str = mem.getPtr( );
 245 }
 246 SimplePDF::PDF_LiteralString::~PDF_LiteralString( )
 247 { }
 248
 249 const string &
 250 SimplePDF::PDF_LiteralString::str( ) const
 251 {
 252         return my_str;
 253 }
 254
 255 void
 256 SimplePDF::PDF_LiteralString::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 257 {
 258         os << "(" ;
 259         for( const char * src = my_str.c_str( ); *src != '\0'; ++src )
 260                 {
 261                         switch( *src )
 262                                 {
 263                                 case '(':
 264                                         os << "\\(" ;
 265                                         break;
 266                                 case ')':
 267                                         os << "\\)" ;
 268                                         break;
 269                                 case '\\':
 270                                         os << "\\\\" ;
 271                                         break;
 272                                 default:
 273                                         os << *src ;
 274                                 }
 275                 }
 276         os << ")" ;
 277 }
 278
 279 /****************/
 280
 281 SimplePDF::PDF_HexString::PDF_HexString( const string & _hexstr )
 282         : my_hexstr( _hexstr )
 283 { }
 284 SimplePDF::PDF_HexString::PDF_HexString( const char * _hexstr )
 285         : my_hexstr( _hexstr )
 286 { }
 287 SimplePDF::PDF_HexString::~PDF_HexString( )
 288 { }
 289
 290 const string &
 291 SimplePDF::PDF_HexString::hexstr( ) const
 292 {
 293         return my_hexstr;
 294 }
 295
 296 void
 297 SimplePDF::PDF_HexString::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 298 {
 299         os << "<" << my_hexstr << ">" ;
 300 }
 301
 302 /****************/
 303
 304 SimplePDF::PDF_Name::PDF_Name( const string & _name )
 305         : my_name( _name )
 306 { }
 307 SimplePDF::PDF_Name::~PDF_Name( )
 308 { }
 309
 310 const string &
 311 SimplePDF::PDF_Name::name( ) const
 312 {
 313         return my_name;
 314 }
 315
 316 void
 317 SimplePDF::PDF_Name::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 318 {
 319         os << "/" << my_name ;
 320 }
 321
 322 ostream & SimplePDF::operator << ( std::ostream & os, const PDF_Name & self )
 323 {
 324         return os << "/" << self.my_name ;
 325 }
 326
 327
 328 /****************/
 329
 330 SimplePDF::PDF_Vector::PDF_Vector( )
 331 { }
 332 SimplePDF::PDF_Vector::PDF_Vector( PDF_Float::ValueType c )
 333 {
 334         vec.push_back( SimplePDF::newFloat( c ) );
 335 }
 336 SimplePDF::PDF_Vector::PDF_Vector( PDF_Float::ValueType c1, PDF_Float::ValueType c2 )
 337 {
 338         vec.push_back( SimplePDF::newFloat( c1 ) );
 339         vec.push_back( SimplePDF::newFloat( c2 ) );
 340 }
 341 SimplePDF::PDF_Vector::PDF_Vector( PDF_Float::ValueType c1, PDF_Float::ValueType c2, PDF_Float::ValueType c3 )
 342 {
 343         vec.push_back( SimplePDF::newFloat( c1 ) );
 344         vec.push_back( SimplePDF::newFloat( c2 ) );
 345         vec.push_back( SimplePDF::newFloat( c3 ) );
 346 }
 347 SimplePDF::PDF_Vector::PDF_Vector( PDF_Float::ValueType x1, PDF_Float::ValueType y1,
 348                                                                                                                                          PDF_Float::ValueType x2, PDF_Float::ValueType y2 )
 349 {
 350         vec.push_back( SimplePDF::newFloat( x1 ) );
 351         vec.push_back( SimplePDF::newFloat( y1 ) );
 352         vec.push_back( SimplePDF::newFloat( x2 ) );
 353         vec.push_back( SimplePDF::newFloat( y2 ) );
 354 }
 355 SimplePDF::PDF_Vector::PDF_Vector( PDF_Float::ValueType a, PDF_Float::ValueType b,
 356                                                                                                                                          PDF_Float::ValueType c, PDF_Float::ValueType d,
 357                                                                                                                                          PDF_Float::ValueType e, PDF_Float::ValueType f )
 358 {
 359         vec.push_back( SimplePDF::newFloat( a ) );
 360         vec.push_back( SimplePDF::newFloat( b ) );
 361         vec.push_back( SimplePDF::newFloat( c ) );
 362         vec.push_back( SimplePDF::newFloat( d ) );
 363         vec.push_back( SimplePDF::newFloat( e ) );
 364         vec.push_back( SimplePDF::newFloat( f ) );
 365 }
 366 SimplePDF::PDF_Vector::PDF_Vector( PDF_Int::ValueType x1, PDF_Int::ValueType y1,
 367                                                                                                                                          PDF_Int::ValueType x2, PDF_Int::ValueType y2 )
 368 {
 369         vec.push_back( SimplePDF::newInt( x1 ) );
 370         vec.push_back( SimplePDF::newInt( y1 ) );
 371         vec.push_back( SimplePDF::newInt( x2 ) );
 372         vec.push_back( SimplePDF::newInt( y2 ) );
 373 }
 374 SimplePDF::PDF_Vector::~PDF_Vector( )
 375 { }
 376
 377 void
 378 SimplePDF::PDF_Vector::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 379 {
 380         os << "[" ;
 381         for( VecType::const_iterator i( vec.begin( ) ); i != vec.end( ); ++i )
 382                 {
 383                         os << " " ;
 384                         (*i)->writeTo( os, xref, *i );
 385                 }
 386         os << " ]" ;
 387 }
 388
 389 RefCountPtr< PDF_Object >
 390 SimplePDF::PDF_Vector::deepCopy( RefCountPtr< PDF_Object > self, size_t * indirectObjectCounter, IndirectRemapType * remap )
 391 {
 392         bool allSame( true );
 393         RefCountPtr< PDF_Vector > res( new PDF_Vector );
 394         res->vec.reserve( vec.size( ) );
 395         for( VecType::iterator i( vec.begin( ) ); i != vec.end( ); ++i )
 396                 {
 397                         RefCountPtr< PDF_Object > copy( ::deepCopy( *i, indirectObjectCounter, remap ) );
 398                         res->vec.push_back( copy );
 399                         if( allSame && copy != *i )
 400                                 {
 401                                         allSame = false;
 402                                 }
 403                 }
 404         if( allSame )
 405                 {
 406                         return self;
 407                 }
 408         return res;
 409 }
 410
 411 RefCountPtr< SimplePDF::PDF_Vector >
 412 SimplePDF::PDF_Vector::rectangleIntersection( const RefCountPtr< SimplePDF::PDF_Vector > & other ) const
 413 {
 414         if( vec.size( ) != 4 )
 415                 {
 416                         throw "Internal error: PDF_Vector::rectangleIntersection: self size is not 4.";
 417                 }
 418         if( other->vec.size( ) != 4 )
 419                 {
 420                         throw "Internal error: PDF_Vector::rectangleIntersection: self size is not 4.";
 421                 }
 422
 423         RefCountPtr< PDF_Vector > res( new PDF_Vector );
 424         res->vec.reserve( vec.size( ) );
 425
 426         typedef typeof vec VectorType;
 427         typedef VectorType::const_iterator I;
 428         I src1 = vec.begin( );
 429         I src2 = other->vec.begin( );
 430         res->vec.push_back( RefCountPtr< PDF_Float >( new PDF_Float( max( SimplePDF::down_cast_follow< PDF_Float >( *src1 )->value( ), SimplePDF::down_cast_follow< PDF_Float >( *src2 )->value( ) ) ) ) );
 431         ++src1;
 432         ++src2;
 433         res->vec.push_back( RefCountPtr< PDF_Float >( new PDF_Float( max( SimplePDF::down_cast_follow< PDF_Float >( *src1 )->value( ), SimplePDF::down_cast_follow< PDF_Float >( *src2 )->value( ) ) ) ) );
 434         ++src1;
 435         ++src2;
 436         res->vec.push_back( RefCountPtr< PDF_Float >( new PDF_Float( min( SimplePDF::down_cast_follow< PDF_Float >( *src1 )->value( ), SimplePDF::down_cast_follow< PDF_Float >( *src2 )->value( ) ) ) ) );
 437         ++src1;
 438         ++src2;
 439         res->vec.push_back( RefCountPtr< PDF_Float >( new PDF_Float( min( SimplePDF::down_cast_follow< PDF_Float >( *src1 )->value( ), SimplePDF::down_cast_follow< PDF_Float >( *src2 )->value( ) ) ) ) );
 440
 441         return res;
 442 }
 443
 444
 445 /****************/
 446
 447 SimplePDF::PDF_Dictionary::PDF_Dictionary( )
 448 { }
 449 SimplePDF::PDF_Dictionary::PDF_Dictionary( const PDF_Dictionary & orig )
 450         : dic( orig.dic )
 451 { }
 452 SimplePDF::PDF_Dictionary::~PDF_Dictionary( )
 453 { }
 454
 455 void
 456 SimplePDF::PDF_Dictionary::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 457 {
 458         os << "<< " ;
 459         for( DicType::const_iterator i( dic.begin( ) ); i != dic.end( ); ++i )
 460                 {
 461                         os << "/" << (i->first) << " " ;
 462                         (i->second)->writeTo( os, xref, i->second );
 463                         os << endl ;
 464                 }
 465         os << ">>" ;
 466 }
 467
 468 void
 469 SimplePDF::PDF_Dictionary::writeToWithLength( std::ostream & os, SimplePDF::PDF_xref * xref, size_t len ) const
 470 {
 471         os << "<< " ;
 472         os << "/Length " << len << endl ;
 473         for( DicType::const_iterator i( dic.begin( ) ); i != dic.end( ); ++i )
 474                 {
 475                         os << "/" << (i->first) << " " ;
 476                         (i->second)->writeTo( os, xref, i->second );
 477                         os << endl ;
 478                 }
 479         os << ">>" ;
 480 }
 481
 482 PDF_Int::ValueType
 483 SimplePDF::PDF_Dictionary::getLength( ) const
 484 {
 485         DicType::const_iterator i( dic.find( string( "Length" ) ) );
 486         if( i == dic.end( ) )
 487                 {
 488                         throw( "Dictionary[Length]: /Length field missing" );
 489                 }
 490         RefCountPtr< const PDF_Int > theInt = SimplePDF::down_cast_follow< const PDF_Int >( i->second );
 491         if( theInt == NullPtr< const PDF_Int >( ) )
 492                 {
 493                         throw( "Dictionary[Length]: /Length is not a PDF_Int" );
 494                 }
 495         return theInt->value( );
 496 }
 497
 498 PDF_Int::ValueType
 499 SimplePDF::PDF_Dictionary::getCount( ) const
 500 {
 501         DicType::const_iterator i( dic.find( string( "Count" ) ) );
 502         if( i == dic.end( ) )
 503                 {
 504                         throw( "Dictionary[Count]: /Count field missing" );
 505                 }
 506         RefCountPtr< const PDF_Int > theInt = SimplePDF::down_cast_follow< const PDF_Int >( i->second );
 507         if( theInt == NullPtr< const PDF_Int >( ) )
 508                 {
 509                         throw( "Dictionary[Count]: /Count is not a PDF_Int" );
 510                 }
 511         return theInt->value( );
 512 }
 513
 514 bool
 515 SimplePDF::PDF_Dictionary::isPages( ) const
 516 {
 517         DicType::const_iterator i( dic.find( string( "Type" ) ) );
 518         if( i == dic.end( ) )
 519                 {
 520                         throw( "PDF_Dictionary::isPages: /Type field missing" );
 521                 }
 522         const PDF_Name * theType( dynamic_cast< const PDF_Name * >( i->second.getPtr( ) ) );
 523         if( theType == 0 )
 524                 {
 525                         throw( "PDF_Dictionary::isPages: /Type is not a PDF_Name" );
 526                 }
 527         return theType->name( ) == "Pages";
 528 }
 529
 530 RefCountPtr< SimplePDF::PDF_Object >
 531 SimplePDF::PDF_Dictionary::getInheritable( const char * name ) const
 532 {
 533         {
 534                 DicType::const_iterator i( dic.find( string( name ) ) );
 535                 if( i != dic.end( ) )
 536                         {
 537                                 return i->second;
 538                         }
 539         }
 540         {
 541                 DicType::const_iterator i( dic.find( string( "Parent" ) ) );
 542                 if( i != dic.end( ) )
 543                         {
 544                                 return SimplePDF::down_cast_follow< SimplePDF::PDF_Dictionary >( i->second )->getInheritable( name );
 545                         }
 546         }
 547         return RefCountPtr< SimplePDF::PDF_Object >( NullPtr< SimplePDF::PDF_Object >( ) );
 548 }
 549
 550
 551 RefCountPtr< PDF_Object > &
 552 SimplePDF::PDF_Dictionary::operator [] ( const char * key )
 553 {
 554         DicType::iterator i( dic.find( key ) );
 555         if( i == dic.end( ) )
 556                 {
 557                         return ((dic.insert(DicType::value_type( key, RefCountPtr< PDF_Object >( new PDF_Null( ) ) ))).first)->second;
 558                 }
 559         return i->second;
 560 }
 561
 562 bool
 563 SimplePDF::PDF_Dictionary::hasKey( const char * key ) const
 564 {
 565         return dic.find( key ) != dic.end( );
 566 }
 567
 568 RefCountPtr< PDF_Object >
 569 SimplePDF::PDF_Dictionary::deepCopy( RefCountPtr< PDF_Object > self, size_t * indirectObjectCounter, IndirectRemapType * remap )
 570 {
 571         bool allSame( true );
 572         RefCountPtr< PDF_Dictionary > res( new PDF_Dictionary );
 573         for( DicType::iterator i( dic.begin( ) ); i != dic.end( ); ++i )
 574                 {
 575                         RefCountPtr< PDF_Object > copy( ::deepCopy( i->second, indirectObjectCounter, remap ) );
 576                         res->dic[ i->first ] = copy;
 577                         if( allSame && copy != i->second )
 578                                 {
 579                                         allSame = false;
 580                                 }
 581                 }
 582         if( allSame )
 583                 {
 584                         return self;
 585                 }
 586         return res;
 587 }
 588
 589 /****************/
 590
 591 SimplePDF::PDF_Stream::PDF_Stream( )
 592 { }
 593 SimplePDF::PDF_Stream::PDF_Stream( const PDF_Dictionary & dic )
 594         : PDF_Dictionary( dic )
 595 { }
 596 SimplePDF::PDF_Stream::~PDF_Stream( )
 597 { }
 598
 599 void
 600 SimplePDF::PDF_Stream::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 601 {
 602         throw "PDF_Stream::writeTo called";
 603 }
 604
 605 RefCountPtr< PDF_Object >
 606 SimplePDF::PDF_Stream::deepCopy( RefCountPtr< PDF_Object > self, size_t * indirectObjectCounter, IndirectRemapType * remap )
 607 {
 608         throw "PDF_Stream::deepCopy must not be called. (However PDF_Stream_in::deepCopy may be called.)";
 609 }
 610 /****************/
 611
 612 SimplePDF::PDF_Stream_out::PDF_Stream_out( )
 613 {
 614         data << std::setiosflags( std::ios_base::fixed ) ;
 615 }
 616 SimplePDF::PDF_Stream_out::~PDF_Stream_out( )
 617 { }
 618
 619 void
 620 SimplePDF::PDF_Stream_out::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 621 {
 622         const string & dataStr( data.str( ) );
 623         PDF_Dictionary::writeToWithLength( os, xref, dataStr.size( ) );
 624         os << endl << "stream" << endl ;
 625         os << dataStr << endl ;
 626         os << "endstream " ;
 627 }
 628
 629 /****************/
 630
 631 SimplePDF::PDF_Stream_in::PDF_Stream_in( PDF_Dictionary * dic, istream * _is, streamoff _dataStart )
 632         : PDF_Stream( *dic ), is( _is ), dataStart( _dataStart )
 633 { }
 634 SimplePDF::PDF_Stream_in::PDF_Stream_in( istream * _is, streamoff _dataStart )
 635         : is( _is ), dataStart( _dataStart )
 636 { }
 637 SimplePDF::PDF_Stream_in::~PDF_Stream_in( )
 638 { }
 639
 640 void
 641 SimplePDF::PDF_Stream_in::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 642 {
 643         size_t length( PDF_Dictionary::getLength( ) );
 644         PDF_Dictionary::writeTo( os, xref, self );
 645         os << endl << "stream" << endl ;
 646         RefCountPtr< char > buf( new char[ length ] );
 647         is->seekg( dataStart, ios::beg );
 648         is->read( buf.getPtr( ), length );
 649         os.write( buf.getPtr( ), length );
 650         os << endl << "endstream " ;
 651 }
 652 void
 653 SimplePDF::PDF_Stream_in::writeDataTo( std::ostream & os ) const
 654 {
 655         size_t length( PDF_Dictionary::getLength( ) );
 656         RefCountPtr< char > buf( new char[ length ] );
 657         is->seekg( dataStart, ios::beg );
 658         is->read( buf.getPtr( ), length );
 659         os.write( buf.getPtr( ), length );
 660 }
 661 void
 662 SimplePDF::PDF_Stream_in::writeDataDefilteredTo( std::ostream & os ) const
 663 {
 664         if( dic.find( "Filter" ) == dic.end( ) )
 665                 {
 666                         writeDataTo( os );
 667                         return;
 668                 }
 669
 670         RefCountPtr< PDF_Object > filterEntry = RefCountPtr< PDF_Object >( new PDF_Null( ) );
 671         typedef typeof dic DicType;
 672         DicType::const_iterator i = dic.find( "Filter" );
 673         if( i != dic.end( ) )
 674                 {
 675                         filterEntry = i->second;
 676                 }
 677         if( filterEntry.down_cast< PDF_Null >( ) != NullPtr< PDF_Null >( ) )
 678                 {
 679                         writeDataTo( os );
 680                         return;
 681                 }
 682
 683         RefCountPtr< PDF_Name > filterNameObj( filterEntry.down_cast< PDF_Name >( ) );
 684         if( filterNameObj == NullPtr< PDF_Name >( ) )
 685                 {
 686                         throw( "The Filter entry was not a name (nor null) in the stream dictionary" );
 687                 }
 688         const string & filter( filterNameObj->name( ) );
 689
 690         if( filter == "FlateDecode" )
 691                 {
 692                         size_t inBufSize( PDF_Dictionary::getLength( ) );
 693                         RefCountPtr< char > inBuf( new char[ inBufSize ] );
 694                         is->seekg( dataStart, ios::beg );
 695                         is->read( inBuf.getPtr( ), inBufSize );
 696
 697                         const size_t BUFSIZE( 1024 );
 698                         RefCountPtr< char > outBuf( new char[ BUFSIZE ] );
 699
 700                         z_stream zs;
 701                         zs.next_in = reinterpret_cast< Bytef * >( inBuf.getPtr( ) );
 702                         zs.avail_in = inBufSize;
 703                         zs.next_out = reinterpret_cast< Bytef * >( outBuf.getPtr( ) );
 704                         zs.avail_out = BUFSIZE;
 705                         zs.zalloc = Z_NULL;
 706                         zs.zfree = Z_NULL;
 707                         switch( inflateInit( & zs ) )
 708                                 {
 709                                 case    Z_OK:
 710                                         break;
 711                                 default:
 712                                         throw( "inflateInit failed" );
 713                                 }
 714
 715                         {
 716                                 int status;
 717                                 while( ( status = inflate( & zs, Z_NO_FLUSH ) ) == Z_OK )
 718                                         {
 719                                                 os.write( outBuf.getPtr( ), BUFSIZE - zs.avail_out );
 720                                                 zs.next_out = reinterpret_cast< Bytef * >( outBuf.getPtr( ) );
 721                                                 zs.avail_out = BUFSIZE;
 722                                         }
 723                                 switch( status )
 724                                         {
 725                                         case Z_STREAM_END:
 726                                                 os.write( outBuf.getPtr( ), BUFSIZE - zs.avail_out );
 727                                                 break;
 728                                         default:
 729                                                 throw( "The inflate cycle did not finish with Z_STREAM_END" );
 730                                         }
 731                         }
 732
 733                         switch( inflateEnd( & zs ) )
 734                                 {
 735                                 case    Z_OK:
 736                                         break;
 737                                 default:
 738                                         throw( "inflateEnd failed" );
 739                                 }
 740                 }
 741         else
 742                 {
 743                         throw( "The filter " + filter + " is not yet supported" );
 744                 }
 745 }
 746
 747 RefCountPtr< PDF_Object >
 748 SimplePDF::PDF_Stream_in::deepCopy( RefCountPtr< PDF_Object > self, size_t * indirectObjectCounter, IndirectRemapType * remap )
 749 {
 750         RefCountPtr< PDF_Object > dicCopy( PDF_Dictionary::deepCopy( self, indirectObjectCounter, remap ) );
 751         if( dicCopy.getPtr( ) == this )
 752                 {
 753                         return self;
 754                 }
 755         /* By increasing the count by 1, we ensure that the memory is not destroyed when this function exits.
 756          * We use that this object is newly created, so there are no other references to it.
 757          */
 758         if( *dicCopy.getCounterPtr( ) != 1 )
 759                 {
 760                         throw "I expected to own the only reference to the new PDF_Dictionary";
 761                 }
 762         ++(*dicCopy.getCounterPtr( ));
 763         return RefCountPtr< PDF_Stream_in >( new PDF_Stream_in( reinterpret_cast< PDF_Dictionary * >( dicCopy.getPtr( ) ), is, dataStart ) );
 764 }
 765 /****************/
 766
 767 SimplePDF::PDF_Indirect::PDF_Indirect( size_t _i, size_t _v )
 768         : i( _i ), v( _v )
 769 { }
 770 SimplePDF::PDF_Indirect::~PDF_Indirect( )
 771 { }
 772 void
 773 SimplePDF::PDF_Indirect_in::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 774 {
 775         throw "Internal error: PDF_Indirect_in::writeTo: This object is only good for reading, not for writing!";
 776         //      os << i << " " << v << " R" ;
 777 }
 778 bool SimplePDF::operator < ( const PDF_Indirect & o1, const PDF_Indirect & o2 )
 779 {
 780         if( o1.i < o2.i )
 781                 {
 782                         return true;
 783                 }
 784         if( o1.i > o2.i )
 785                 {
 786                         return false;
 787                 }
 788         if( o1.v < o2.v )
 789                 {
 790                         return true;
 791                 }
 792         return false;
 793 }
 794 RefCountPtr< PDF_Object >
 795 SimplePDF::PDF_Indirect::deepCopy( RefCountPtr< PDF_Object > self, size_t * indirectObjectCounter, IndirectRemapType * remap )
 796 {
 797         throw "PDF_Indirect::deepCopy must not be called.       (However PDF_Indirect_in::deepCopy may be called.)";
 798 }
 799 /****************/
 800
 801 SimplePDF::PDF_Indirect_out::PDF_Indirect_out( RefCountPtr<PDF_Object> _obj, size_t _i, size_t _v )
 802         : PDF_Indirect( _i, _v ), inUse( true ), obj( _obj )
 803 { }
 804 SimplePDF::PDF_Indirect_out::~PDF_Indirect_out( )
 805 { }
 806 void
 807 SimplePDF::PDF_Indirect_out::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 808 {
 809         xref->enqueue( self.down_cast< const PDF_Indirect_out >( ) );  /* This shall not fail! */
 810         os << xref->local( i ) << " " << v << " R" ;  /* We must not call xref->local before xref->enqueue ! */
 811 }
 812 void
 813 SimplePDF::PDF_Indirect_out::writeObject( std::ostream & os, SimplePDF::PDF_xref * xref ) const
 814 {
 815         if( inUse )
 816                 {
 817                         os << xref->local( i ) << " " << v << " obj" << endl ;
 818                         obj->writeTo( os, xref, obj );
 819                         os << endl << "endobj" << endl ;
 820                 }
 821 }
 822
 823 /****************/
 824
 825 SimplePDF::PDF_Indirect_in::PDF_Indirect_in( size_t _i, size_t _v )
 826         : PDF_Indirect( _i, _v ), PDFin( 0 )
 827 { }
 828 SimplePDF::PDF_Indirect_in::~PDF_Indirect_in( )
 829 { }
 830 RefCountPtr< PDF_Object >
 831 SimplePDF::PDF_Indirect_in::deref( )
 832 {
 833         if( PDFin == 0 )
 834                 {
 835                         throw( "PDF_Indirect_in::deref: PDFin is not assigned" );
 836                 }
 837         return PDFin->readObjectNumbered( i, v );
 838 }
 839 RefCountPtr< PDF_Object >
 840 SimplePDF::PDF_Indirect_in::deepCopy( RefCountPtr< PDF_Object > self, size_t * indirectObjectCounter, IndirectRemapType * remap )
 841 {
 842         {
 843                 IndirectRemapType::iterator i( remap->find( *this ) );
 844                 if( i != remap->end( ) )
 845                         {
 846                                 return i->second;
 847                         }
 848         }
 849         return remap->insert( IndirectRemapType::value_type( *this, SimplePDF::indirect( ::deepCopy( deref( ), indirectObjectCounter, remap ),
 850                                                                                                                                                                                                                                                                                                                                          indirectObjectCounter ) ) ).first->second;
 851 }
 852
 853 /**************/
 854
 855 SimplePDF::PDF_xref::PDF_xref( )
 856         : size_( 0 )
 857 {
 858         /* The first position in the xref table is special. */
 859         localOrder_.push_back( 0 ); /* The first object shall appear in the xref table. */
 860         localNumbers_.push_back( 0 ); /* It has number 0. */
 861         byteOffsets_.push_back( 0 ); /* This is interpreted as "not in use" */
 862         generations_.push_back( 65535 );
 863 }
 864
 865 void
 866 SimplePDF::PDF_xref::enqueue( const RefCountPtr< const::PDF_Indirect_out > & obj )
 867 {
 868         /* Grow big enough */
 869         while( byteOffsets_.size( ) <= obj->i )
 870                 {
 871                         localNumbers_.push_back( 0 );
 872                         byteOffsets_.push_back( 0 );
 873                         generations_.push_back( 0 );
 874                 }
 875
 876         if( byteOffsets_[ obj->i ] == 0 )
 877                 {
 878                         indirectQueue_.push_back( obj );
 879                         localNumbers_[ obj->i ] = localOrder_.size( );
 880                         byteOffsets_[ obj->i ] = 1; /* We will change this later, this just indicates that the object has been put in queue. */
 881                         localOrder_.push_back( obj->i );
 882                 }
 883 }
 884
 885 void
 886 SimplePDF::PDF_xref::writeRecursive( std::ostream & os )
 887 {
 888         std::streamoff os_start;
 889         {
 890                 std::streamoff tmp = static_cast< streamoff >( os.tellp( ) );
 891                 os.seekp( 0 );
 892                 os_start = static_cast< streamoff >( os.tellp( ) ); /* Will this always be some kind of zero value? */
 893                 os.seekp( tmp );
 894         }
 895         while( ! indirectQueue_.empty( ) )
 896                 {
 897                         RefCountPtr< const SimplePDF::PDF_Indirect_out > i_obj = indirectQueue_.front( );
 898                         indirectQueue_.pop_front( );
 899                         byteOffsets_[ i_obj->i ] = static_cast< streamoff >( os.tellp( ) ) - os_start;
 900                         generations_[ i_obj->i ] = i_obj->v;
 901                         i_obj->writeObject( os, this );
 902                 }
 903 }
 904
 905 size_t
 906 SimplePDF::PDF_xref::local( size_t i ) const
 907 {
 908         return localNumbers_[ i ];
 909 }
 910
 911 void
 912 SimplePDF::PDF_xref::writeTable( std::ostream & os ) const
 913 {
 914         if( size_ > 0 )
 915                 {
 916                         throw "Internal error: PDF_xref::writeTable: This table has already been written.";
 917                 }
 918         size_ = localOrder_.size( );
 919
 920         os << setfill( '0' ) ;
 921         os << "xref" << endl
 922                  << 0 << " " << size_ << endl ;
 923         typedef typeof localOrder_ ListType;
 924         for( ListType::const_iterator i = localOrder_.begin( ); i != localOrder_.end( ); ++i )
 925                 {
 926                         size_t v = generations_[ *i ];
 927                         size_t o = byteOffsets_[ *i ];
 928                         os << setw( 10 ) << o << ' ' << setw( 5 ) << v << ' ' << 'n' << ' ' << static_cast< char >( 10 ) ;
 929                 }
 930 }
 931
 932 size_t
 933 SimplePDF::PDF_xref::size( ) const
 934 {
 935         if( size_ == 0 )
 936                 {
 937                         throw "Internal error: PDF_xref::size: The size of the table is not determined yet.  Call writeTable first.";
 938                 }
 939         return size_;
 940 }
 941
 942
 943 /**************/
 944
 945 RefCountPtr< PDF_Indirect_out >
 946 SimplePDF::indirect( RefCountPtr< PDF_Object > obj, size_t * i, size_t v )
 947 {
 948         return RefCountPtr< PDF_Indirect_out >( new PDF_Indirect_out( obj, (*i)++, v ) );
 949 }
 950
 951 RefCountPtr< PDF_Object >
 952 SimplePDF::deepCopy( RefCountPtr< PDF_Object > obj, size_t * indirectObjectCounter, IndirectRemapType * remap )
 953 {
 954         return obj->deepCopy( obj, indirectObjectCounter, remap );
 955 }