source/annotations.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 "Shapes_Helpers_decls.h"
  20
  21 #include "annotations.h"
  22 #include "pdfstructure.h"
  23 #include "classtypes.h"
  24 #include "drawabletypes.h"
  25 #include "pathtypes.h"
  26 #include "globals.h"
  27 #include "shapesexceptions.h"
  28
  29 using namespace Shapes;
  30
  31
  32 Lang::AnnotationSite::AnnotationSite( const RefCountPtr< const Lang::Drawable2D > & target, const RefCountPtr< const char > & contentText, const RefCountPtr< const char > & identifier, size_t flags,
  33                                                                                                                                                         char borderStyle, const Concrete::Length & borderWidth, const RefCountPtr< const Lang::Dash > & borderDash, double borderCloudy, const Concrete::RGB & color,
  34                                                                                                                                                         const RefCountPtr< const Lang::XObject > & appearanceNormal, const RefCountPtr< const Lang::XObject > & appearanceRollover, const RefCountPtr< const Lang::XObject > & appearanceDown )
  35         : target_( target ), contentText_( contentText ), identifier_( identifier ), flags_( flags ),
  36                 borderStyle_( borderStyle ), borderWidth_( borderWidth ), borderDash_( borderDash ), borderCloudy_( borderCloudy ), color_( color ),
  37                 appearanceNormal_( appearanceNormal ), appearanceRollover_( appearanceRollover ), appearanceDown_( appearanceDown )
  38 { }
  39
  40 Lang::AnnotationSite::~AnnotationSite( )
  41 { }
  42
  43 RefCountPtr< const Lang::Class > Lang::AnnotationSite::TypeID( new Lang::SystemFinalClass( strrefdup( "AnnotationSite" ) ) );
  44 TYPEINFOIMPL( AnnotationSite );
  45
  46 RefCountPtr< const Lang::AnnotationSite >
  47 Lang::AnnotationSite::typed_transformed( const Lang::Transform2D & transform ) const
  48 {
  49         return RefCountPtr< const Lang::AnnotationSite >
  50                 ( new AnnotationSite( target_->typed_transformed( transform, target_ ), contentText_, identifier_, flags_,
  51                                                                                                         borderStyle_, borderWidth_, borderDash_, borderCloudy_, color_,
  52                                                                                                         appearanceNormal_, appearanceRollover_, appearanceDown_ ) );
  53 }
  54
  55 RefCountPtr< const Lang::Geometric2D >
  56 Lang::AnnotationSite::transformed( const Lang::Transform2D & transform, const RefCountPtr< const Lang::Geometric2D > & self ) const
  57 {
  58         return typed_transformed( transform );
  59 }
  60
  61 RefCountPtr< const Lang::Geometric3D >
  62 Lang::AnnotationSite::to3D( const RefCountPtr< const Lang::Geometric2D > & self ) const
  63 {
  64         throw Exceptions::NotImplemented( "Annotation sites in 3D." );
  65 }
  66
  67 void
  68 Lang::AnnotationSite::gcMark( Kernel::GCMarkedSet & marked )
  69 {
  70         const_cast< Lang::Drawable2D * >( target_.getPtr( ) )->gcMark( marked );
  71         if( borderDash_ != NullPtr< const Lang::Dash >( ) )
  72                 {
  73                         const_cast< Lang::Dash * >( borderDash_.getPtr( ) )->gcMark( marked );
  74                 }
  75         if( appearanceNormal_ != NullPtr< const Lang::XObject >( ) )
  76                 {
  77                         const_cast< Lang::XObject * >( appearanceNormal_.getPtr( ) )->gcMark( marked );
  78                 } if( appearanceRollover_ != NullPtr< const Lang::XObject >( ) )
  79                 {
  80                         const_cast< Lang::XObject * >( appearanceRollover_.getPtr( ) )->gcMark( marked );
  81                 }
  82         if( appearanceDown_ != NullPtr< const Lang::XObject >( ) )
  83                 {
  84                         const_cast< Lang::XObject * >( appearanceDown_.getPtr( ) )->gcMark( marked );
  85                 }
  86 }
  87
  88 RefCountPtr< SimplePDF::PDF_Dictionary >
  89 Lang::AnnotationSite::getDictionary( const char * subtype, const RefCountPtr< SimplePDF::PDF_Indirect_out > & i_page ) const
  90 {
  91         const SimplePDF::PDF_Version::Version FANCY_VERSION = SimplePDF::PDF_Version::PDF_1_2;
  92
  93         RefCountPtr< SimplePDF::PDF_Dictionary > res = RefCountPtr< SimplePDF::PDF_Dictionary >( new SimplePDF::PDF_Dictionary );
  94
  95         res->dic[ "Type" ] = SimplePDF::newName( "Annot" );
  96         res->dic[ "Subtype" ] = SimplePDF::newName( subtype );
  97         {
  98                 Concrete::Coords2D llcorner( 0, 0 );
  99                 Concrete::Coords2D urcorner( 0, 0 );
 100                 RefCountPtr< const Lang::ElementaryPath2D > theBBox = target_->bbox( Lang::Drawable2D::BOUNDING );
 101                 if( theBBox->empty( ) )
 102                         {
 103                                 throw Exceptions::MiscellaneousRequirement( "The annotation target produced an empty bounding box." );
 104                         }
 105                 theBBox->boundingRectangle( & llcorner, & urcorner );
 106                 res->dic[ "Rect" ] = RefCountPtr< SimplePDF::PDF_Vector >
 107                         ( new SimplePDF::PDF_Vector( llcorner.x_.offtype< 1, 0 >( ),
 108                                                                                                                                          llcorner.y_.offtype< 1, 0 >( ),
 109                                                                                                                                          urcorner.x_.offtype< 1, 0 >( ),
 110                                                                                                                                          urcorner.y_.offtype< 1, 0 >( ) ) );
 111         }
 112         if( contentText_ != NullPtr< const char >( ) )
 113                 {
 114                         res->dic[ "Contents" ] = SimplePDF::newString( contentText_.getPtr( ) );
 115                 }
 116         res->dic[ "P" ] = i_page;
 117         if( identifier_ != NullPtr< const char >( ) )
 118                 {
 119                         const SimplePDF::PDF_Version::Version ELEMENT_NAME_VERSION = SimplePDF::PDF_Version::PDF_1_4;
 120                         if( Kernel::the_PDF_version.greaterOrEqual( ELEMENT_NAME_VERSION ) )
 121                                 {
 122                                         res->dic[ "NM" ] = SimplePDF::newString( identifier_.getPtr( ) );
 123                                 }
 124                         else
 125                                 {
 126                                         Kernel::the_PDF_version.message( ELEMENT_NAME_VERSION, "Annotation identifiier was ignored." );
 127                                 }
 128                 }
 129         res->dic[ "F" ] = SimplePDF::newInt( flags_ );
 130         {
 131                 RefCountPtr< SimplePDF::PDF_Dictionary > bs = RefCountPtr< SimplePDF::PDF_Dictionary >( new SimplePDF::PDF_Dictionary );
 132
 133                 if( static_cast< double >( borderWidth_.offtype< 1, 0 >( ) ) != 1 )
 134                         {
 135                                 bs->dic[ "W" ] = SimplePDF::newFloat( borderWidth_.offtype< 1, 0 >( ) );
 136                         }
 137                 if( borderStyle_ != 'S' )
 138                         {
 139                                 char buf[2];
 140                                 buf[0] = borderStyle_;
 141                                 buf[1] = '\0';
 142                                 bs->dic[ "S" ] = SimplePDF::newName( buf );
 143                         }
 144                 if( borderDash_ != NullPtr< const Lang::Dash >( ) )
 145                         {
 146                                 bs->dic[ "D" ] = borderDash_->getDashArray( );
 147                         }
 148                 if( borderCloudy_ >= 0 )
 149                         {
 150                                 RefCountPtr< SimplePDF::PDF_Dictionary > be = RefCountPtr< SimplePDF::PDF_Dictionary >( new SimplePDF::PDF_Dictionary );
 151                                 be->dic[ "S" ] = SimplePDF::newName( "C" );
 152                                 be->dic[ "I" ] = SimplePDF::newFloat( borderCloudy_ );
 153                                 bs->dic[ "BE" ] = be;
 154                         }
 155
 156                 if( ! bs->dic.empty( ) )
 157                         {
 158                                 if( Kernel::the_PDF_version.greaterOrEqual( FANCY_VERSION ) )
 159                                         {
 160                                                 res->dic[ "BS" ] = bs;
 161                                         }
 162                                 else
 163                                         {
 164                                                 Kernel::the_PDF_version.message( FANCY_VERSION, "Annotation border style was ignored." );
 165                                         }
 166                         }
 167         }
 168
 169         {
 170                 RefCountPtr< SimplePDF::PDF_Dictionary > ap = RefCountPtr< SimplePDF::PDF_Dictionary >( new SimplePDF::PDF_Dictionary );
 171
 172                 if( appearanceNormal_ != NullPtr< const Lang::XObject >( ) )
 173                         {
 174                                 ap->dic[ "N" ] = appearanceNormal_->getResource( );
 175                         }
 176                 if( appearanceRollover_ != NullPtr< const Lang::XObject >( ) )
 177                         {
 178                                 ap->dic[ "R" ] = appearanceRollover_->getResource( );
 179                         }
 180                 if( appearanceDown_ != NullPtr< const Lang::XObject >( ) )
 181                         {
 182                                 ap->dic[ "D" ] = appearanceDown_->getResource( );
 183                         }
 184
 185                 if( ! ap->dic.empty( ) )
 186                         {
 187                                 if( Kernel::the_PDF_version.greaterOrEqual( FANCY_VERSION ) )
 188                                         {
 189                                                 res->dic[ "AP" ] = ap;
 190                                         }
 191                                 else
 192                                         {
 193                                                 Kernel::the_PDF_version.message( FANCY_VERSION, "Annotation appearance was ignored." );
 194                                         }
 195                         }
 196         }
 197
 198         if( color_.mean( ) > 0 )
 199                 {
 200                         if( Kernel::the_PDF_version.greaterOrEqual( FANCY_VERSION ) )
 201                                 {
 202                                         res->dic[ "C"   ] = color_.componentVector( );
 203                                 }
 204                         else
 205                                 {
 206                                         Kernel::the_PDF_version.message( FANCY_VERSION, "Annotation color was ignored." );
 207                                 }
 208                 }
 209
 210
 211         return res;
 212 }
 213
 214
 215 Lang::AnnotationBase::AnnotationBase( const RefCountPtr< const Lang::AnnotationSite > & site )
 216         : site_( site )
 217 { }
 218
 219 Lang::AnnotationBase::~AnnotationBase( )
 220 { }
 221
 222 RefCountPtr< const Lang::Class > Lang::AnnotationBase::TypeID( new Lang::SystemFinalClass( strrefdup( "Annotation" ) ) );
 223 TYPEINFOIMPL( AnnotationBase );
 224
 225 void
 226 Lang::AnnotationBase::gcMark( Kernel::GCMarkedSet & marked )
 227 {
 228         const_cast< AnnotationSite * >( site_.getPtr( ) )->gcMark( marked );
 229         this->subtypeGcMark( marked );
 230 }
 231
 232
 233 RefCountPtr< const Lang::Geometric3D >
 234 Lang::AnnotationBase::to3D( const RefCountPtr< const Lang::Geometric2D > & self ) const
 235 {
 236         throw Exceptions::NotImplemented( "Annotations in 3D." );
 237 }
 238
 239
 240 Lang::TextAnnotation::TextAnnotation( const RefCountPtr< const Lang::AnnotationSite > & site, const RefCountPtr< const char > & title, bool open, const RefCountPtr< const char > & icon )
 241         : Lang::AnnotationBase( site ), title_( title ), open_( open ), icon_( icon )
 242 { }
 243
 244 Lang::TextAnnotation::~TextAnnotation( )
 245 { }
 246
 247 RefCountPtr< const Lang::Geometric2D >
 248 Lang::TextAnnotation::transformed( const Lang::Transform2D & transform, const RefCountPtr< const Lang::Geometric2D > & self ) const
 249 {
 250         return RefCountPtr< const Lang::Geometric2D >
 251                 ( new TextAnnotation( site_->typed_transformed( transform ), title_, open_, icon_ ) );
 252 }
 253
 254 RefCountPtr< SimplePDF::PDF_Dictionary >
 255 Lang::TextAnnotation::getDictionary( const RefCountPtr< SimplePDF::PDF_Indirect_out > & i_page, const std::map< RefCountPtr< const char >, RefCountPtr< SimplePDF::PDF_Vector >, charRefPtrLess > & namedDestinations ) const
 256 {
 257         RefCountPtr< SimplePDF::PDF_Dictionary > res = site_->getDictionary( "Text", i_page );
 258         if( title_ != NullPtr< const char >( ) )
 259                 {
 260                         res->dic[ "T" ] = SimplePDF::newString( title_.getPtr( ) );
 261                 }
 262         if( open_ )
 263                 {
 264                         res->dic[ "Open" ] = SimplePDF::theTrue;
 265                 }
 266         if( icon_ != NullPtr< const char >( ) )
 267                 {
 268                         res->dic[ "Name" ] = SimplePDF::newString( icon_.getPtr( ) );
 269                 }
 270
 271         return res;
 272 }
 273
 274 void
 275 Lang::TextAnnotation::subtypeGcMark( Kernel::GCMarkedSet & marked )
 276 {
 277         /* Nothing to mark.
 278          */
 279 }
 280
 281
 282 Lang::LinkAnnotation::LinkAnnotation( const RefCountPtr< const Lang::AnnotationSite > & site, const Ast::SourceLocation & loc, char highlight, const RefCountPtr< const char > & destination, Lang::LinkAnnotation::Kind kind )
 283         : Lang::AnnotationBase( site ), loc_( loc ), highlight_( highlight ), destination_( destination ), kind_( kind )
 284 { }
 285
 286 Lang::LinkAnnotation::~LinkAnnotation( )
 287 { }
 288
 289 RefCountPtr< const Lang::Geometric2D >
 290 Lang::LinkAnnotation::transformed( const Lang::Transform2D & transform, const RefCountPtr< const Lang::Geometric2D > & self ) const
 291 {
 292         return RefCountPtr< const Lang::Geometric2D >
 293                 ( new LinkAnnotation( site_->typed_transformed( transform ), loc_, highlight_, destination_, kind_ ) );
 294 }
 295
 296 RefCountPtr< SimplePDF::PDF_Dictionary >
 297 Lang::LinkAnnotation::getDictionary( const RefCountPtr< SimplePDF::PDF_Indirect_out > & i_page, const std::map< RefCountPtr< const char >, RefCountPtr< SimplePDF::PDF_Vector >, charRefPtrLess > & namedDestinations ) const
 298 {
 299         RefCountPtr< SimplePDF::PDF_Dictionary > res = site_->getDictionary( "Link", i_page );
 300         if( highlight_ != 'I' )
 301                 {
 302                         char buf[2];
 303                         buf[0] = highlight_;
 304                         buf[1] = '\0';
 305                         res->dic[ "H" ] = SimplePDF::newName( buf );
 306                 }
 307
 308         switch( kind_ )
 309                 {
 310                 case LAUNCH_FILE:
 311                         {
 312                                 RefCountPtr< SimplePDF::PDF_Dictionary > action = RefCountPtr< SimplePDF::PDF_Dictionary >( new SimplePDF::PDF_Dictionary );
 313                                 res->dic[ "A" ] = action;
 314                                 action->dic[ "S" ] = SimplePDF::newName( "Launch" );
 315                                 action->dic[ "F" ] = SimplePDF::newString( destination_.getPtr( ) );
 316                         }
 317                         break;
 318                 case LAUNCH_URI:
 319                         {
 320                                 RefCountPtr< SimplePDF::PDF_Dictionary > action = RefCountPtr< SimplePDF::PDF_Dictionary >( new SimplePDF::PDF_Dictionary );
 321                                 res->dic[ "A" ] = action;
 322                                 action->dic[ "S" ] = SimplePDF::newName( "URI" );
 323                                 action->dic[ "URI" ] = SimplePDF::newString( destination_.getPtr( ) );
 324                                 //                      RefCountPtr< SimplePDF::PDF_Dictionary > filespec = RefCountPtr< SimplePDF::PDF_Dictionary >( new SimplePDF::PDF_Dictionary );
 325                                 //                      action->dic[ "F" ] = filespec;
 326                                 //                      filespec->dic[ "FS" ] = SimplePDF::newName( "URI" );
 327                                 //                      filespec->dic[ "F" ] = SimplePDF::newString( destination_.getPtr( ) );
 328                         }
 329                         break;
 330                 case DOC_LINK:
 331                         {
 332                                 if( namedDestinations.find( destination_ ) == namedDestinations.end( ) )
 333                                         {
 334                                                 throw new Exceptions::UndefinedCrossRef( loc_, destination_ );
 335                                         }
 336                                 res->dic[ "Dest" ] = SimplePDF::newString( destination_.getPtr( ) );
 337                         }
 338                         break;
 339                 default:
 340                         throw Exceptions::InternalError( "Link annotation type out of range." );
 341                 }
 342
 343         return res;
 344 }
 345
 346 void
 347 Lang::LinkAnnotation::subtypeGcMark( Kernel::GCMarkedSet & marked )
 348 {
 349         /* Nothing to mark.
 350          */
 351 }