source/tagtypes.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 "tagtypes.h"
  20 #include "globals.h"
  21 #include "ast.h"
  22
  23 using namespace Shapes;
  24
  25 Lang::Tagged2D::Tagged2D( const RefCountPtr< const Lang::Symbol > & key )
  26         : key_( key->getKey( ) )
  27 { }
  28
  29 Lang::Tagged2D::Tagged2D( const Lang::Symbol::KeyType key )
  30         : key_( key )
  31 { }
  32
  33 Lang::Tagged2D::~Tagged2D( )
  34 { }
  35
  36 Lang::Symbol::KeyType
  37 Lang::Tagged2D::key( ) const
  38 {
  39         return key_;
  40 }
  41
  42
  43 Lang::TaggedValue2D::TaggedValue2D( const RefCountPtr< const Lang::Symbol > & key, const RefCountPtr< const Lang::Value > & val )
  44         : Lang::Tagged2D( key ), val_( val )
  45 { }
  46
  47 Lang::TaggedValue2D::TaggedValue2D( const Lang::Symbol::KeyType key, const RefCountPtr< const Lang::Value > & val )
  48         : Lang::Tagged2D( key ), val_( val )
  49 { }
  50
  51 Lang::TaggedValue2D::~TaggedValue2D( )
  52 { }
  53
  54 void
  55 Lang::TaggedValue2D::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf ) const
  56 {
  57         // Do nothing!
  58 }
  59
  60 RefCountPtr< const Lang::ElementaryPath2D >
  61 Lang::TaggedValue2D::bbox( Lang::Drawable2D::BoxType boxType ) const
  62 {
  63         return Lang::THE_EMPTYPATH2D;
  64 }
  65
  66 RefCountPtr< const Lang::Geometric3D >
  67 Lang::TaggedValue2D::to3D( const RefCountPtr< const Lang::Geometric2D > & self ) const
  68 {
  69         return RefCountPtr< const Lang::Geometric3D >( new Lang::TaggedValue3D( key_, val_ ) );
  70 }
  71
  72 void
  73 Lang::TaggedValue2D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
  74 {
  75         // tf is ignored for this type of tag.
  76         if( key_ == key )
  77                 {
  78                         dst->push_back( val_ );
  79                 }
  80 }
  81
  82 bool
  83 Lang::TaggedValue2D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
  84 {
  85         // tf is ignored for this type of tag.
  86         if( key_ == key )
  87                 {
  88                         Kernel::ContRef cont = evalState->cont_;
  89                         cont->takeValue( val_,
  90                                                                                          evalState );
  91                         return true;
  92                 }
  93         return false;
  94 }
  95
  96 void
  97 Lang::TaggedValue2D::show( std::ostream & os ) const
  98 {
  99         try
 100                 {
 101                         os << "Value with the tag " << Lang::Symbol::nameFromKey( key_ ).getPtr( ) ;
 102                 }
 103         catch( ... )
 104                 {
 105                         os << "Value with unique tag." ;
 106                 }
 107 }
 108
 109 RefCountPtr< const Lang::Value >
 110 Lang::TaggedValue2D::val( ) const
 111 {
 112         return val_;
 113 }
 114
 115 void
 116 Lang::TaggedValue2D::gcMark( Kernel::GCMarkedSet & marked )
 117 {
 118         const_cast< Lang::Value * >( val_.getPtr( ) )->gcMark( marked );
 119 }
 120
 121
 122 Lang::TaggedGeometric2D::TaggedGeometric2D( const RefCountPtr< const Lang::Symbol > & key, const RefCountPtr< const Lang::Geometric2D > & val )
 123         : Lang::Tagged2D( key ), val_( val )
 124 { }
 125
 126 Lang::TaggedGeometric2D::TaggedGeometric2D( const Lang::Symbol::KeyType key, const RefCountPtr< const Lang::Geometric2D > & val )
 127         : Lang::Tagged2D( key ), val_( val )
 128 { }
 129
 130 Lang::TaggedGeometric2D::~TaggedGeometric2D( )
 131 { }
 132
 133 void
 134 Lang::TaggedGeometric2D::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf ) const
 135 {
 136         // Do nothing!
 137 }
 138
 139 RefCountPtr< const Lang::ElementaryPath2D >
 140 Lang::TaggedGeometric2D::bbox( Lang::Drawable2D::BoxType boxType ) const
 141 {
 142         return Lang::THE_EMPTYPATH2D;
 143 }
 144
 145 RefCountPtr< const Lang::Geometric3D >
 146 Lang::TaggedGeometric2D::to3D( const RefCountPtr< const Lang::Geometric2D > & self ) const
 147 {
 148         return RefCountPtr< const Lang::Geometric3D >( new Lang::TaggedGeometric3D( key_, val_->to3D( val_ ) ) );
 149 }
 150
 151 void
 152 Lang::TaggedGeometric2D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
 153 {
 154         // tf is ignored for this type of tag.
 155         if( key_ == key )
 156                 {
 157                         dst->push_back( val_->transformed( tf, val_ ) );
 158                 }
 159 }
 160
 161 bool
 162 Lang::TaggedGeometric2D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
 163 {
 164         // tf is ignored for this type of tag.
 165         if( key_ == key )
 166                 {
 167                         Kernel::ContRef cont = evalState->cont_;
 168                         cont->takeValue( val_->transformed( tf, val_ ),
 169                                                                                          evalState );
 170                         return true;
 171                 }
 172         return false;
 173 }
 174
 175 void
 176 Lang::TaggedGeometric2D::show( std::ostream & os ) const
 177 {
 178         try
 179                 {
 180                         os << "Geometric value with the tag " << Lang::Symbol::nameFromKey( key_ ).getPtr( ) ;
 181                 }
 182         catch( ... )
 183                 {
 184                         os << "Geometric value with unique tag." ;
 185                 }
 186 }
 187
 188 void
 189 Lang::TaggedGeometric2D::gcMark( Kernel::GCMarkedSet & marked )
 190 {
 191         const_cast< Lang::Geometric2D * >( val_.getPtr( ) )->gcMark( marked );
 192 }
 193
 194
 195 Lang::TaggedDrawable2D::TaggedDrawable2D( const RefCountPtr< const Lang::Symbol > & key, const RefCountPtr< const Lang::Drawable2D > & val )
 196         : Lang::Tagged2D( key ), val_( val )
 197 { }
 198
 199 Lang::TaggedDrawable2D::TaggedDrawable2D( const Lang::Symbol::KeyType key, const RefCountPtr< const Lang::Drawable2D > & val )
 200         : Lang::Tagged2D( key ), val_( val )
 201 { }
 202
 203 Lang::TaggedDrawable2D::~TaggedDrawable2D( )
 204 { }
 205
 206 void
 207 Lang::TaggedDrawable2D::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf ) const
 208 {
 209         val_->shipout( os, pdfState, tf );
 210 }
 211
 212 RefCountPtr< const Lang::ElementaryPath2D >
 213 Lang::TaggedDrawable2D::bbox( Lang::Drawable2D::BoxType boxType ) const
 214 {
 215         return val_->bbox( boxType );
 216 }
 217
 218 RefCountPtr< const Lang::Geometric3D >
 219 Lang::TaggedDrawable2D::to3D( const RefCountPtr< const Lang::Geometric2D > & self ) const
 220 {
 221         return RefCountPtr< const Lang::Geometric3D >( new Lang::TaggedDrawable3D
 222                                                                                                                                                                                                  ( key_,
 223                                                                                                                                                                                                          RefCountPtr< const Lang::Drawable3D >( new Lang::Drawable2Din3D( val_ ) ) ) );
 224 }
 225
 226 void
 227 Lang::TaggedDrawable2D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
 228 {
 229         // tf is ignored for this type of tag.
 230         if( key_ == key )
 231                 {
 232                         dst->push_back( val_->transformed( tf, val_ ) );
 233                 }
 234 }
 235
 236 bool
 237 Lang::TaggedDrawable2D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
 238 {
 239         // tf is ignored for this type of tag.
 240         if( key_ == key )
 241                 {
 242                         Kernel::ContRef cont = evalState->cont_;
 243                         cont->takeValue( val_->transformed( tf, val_ ),
 244                                                                                          evalState );
 245                         return true;
 246                 }
 247         return false;
 248 }
 249
 250 void
 251 Lang::TaggedDrawable2D::show( std::ostream & os ) const
 252 {
 253         try
 254                 {
 255                         os << "Drawable value with the tag " << Lang::Symbol::nameFromKey( key_ ).getPtr( ) ;
 256                 }
 257         catch( ... )
 258                 {
 259                         os << "Drawable value with unique tag." ;
 260                 }
 261 }
 262
 263 void
 264 Lang::TaggedDrawable2D::gcMark( Kernel::GCMarkedSet & marked )
 265 {
 266         const_cast< Lang::Drawable2D * >( val_.getPtr( ) )->gcMark( marked );
 267 }
 268
 269
 270 Lang::Tagged3D::Tagged3D( const RefCountPtr< const Lang::Symbol > & key )
 271         : key_( key->getKey( ) )
 272 { }
 273
 274 Lang::Tagged3D::Tagged3D( const Lang::Symbol::KeyType key )
 275         : key_( key )
 276 { }
 277
 278 Lang::Tagged3D::~Tagged3D( )
 279 { }
 280
 281 Lang::Symbol::KeyType
 282 Lang::Tagged3D::key( ) const
 283 {
 284         return key_;
 285 }
 286
 287
 288 Lang::TaggedValue3D::TaggedValue3D( const RefCountPtr< const Lang::Symbol > & key, const RefCountPtr< const Lang::Value > & val )
 289         : Lang::Tagged3D( key ), val_( val )
 290 { }
 291
 292 Lang::TaggedValue3D::TaggedValue3D( const Lang::Symbol::KeyType key, const RefCountPtr< const Lang::Value > & val )
 293         : Lang::Tagged3D( key ), val_( val )
 294 { }
 295
 296 Lang::TaggedValue3D::~TaggedValue3D( )
 297 { }
 298
 299 RefCountPtr< const Lang::Drawable2D >
 300 Lang::TaggedValue3D::typed_to2D( const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
 301 {
 302         return RefCountPtr< const Lang::Drawable2D >( new Lang::TaggedValue2D( key_, val_ ) );
 303 }
 304
 305 void
 306 Lang::TaggedValue3D::polygonize( std::list< RefCountPtr< Computation::PaintedPolygon3D > > * zBufPile, std::list< RefCountPtr< Computation::StrokedLine3D > > * linePile, const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
 307 {
 308         // Note that polygonization eats tags.
 309 }
 310
 311 void
 312 Lang::TaggedValue3D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
 313 {
 314         // tf is ignored for this type of tag.
 315         if( key_ == key )
 316                 {
 317                         dst->push_back( val_ );
 318                 }
 319 }
 320
 321 bool
 322 Lang::TaggedValue3D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
 323 {
 324         // tf is ignored for this type of tag.
 325         if( key_ == key )
 326                 {
 327                         Kernel::ContRef cont = evalState->cont_;
 328                         cont->takeValue( val_,
 329                                                                                          evalState );
 330                         return true;
 331                 }
 332         return false;
 333 }
 334
 335 void
 336 Lang::TaggedValue3D::show( std::ostream & os ) const
 337 {
 338         try
 339                 {
 340                         os << "Value (3D) with the tag " << Lang::Symbol::nameFromKey( key_ ).getPtr( ) ;
 341                 }
 342         catch( ... )
 343                 {
 344                         os << "Value (3D) with unique tag." ;
 345                 }
 346 }
 347
 348 void
 349 Lang::TaggedValue3D::gcMark( Kernel::GCMarkedSet & marked )
 350 {
 351         const_cast< Lang::Value * >( val_.getPtr( ) )->gcMark( marked );
 352 }
 353
 354
 355 Lang::TaggedGeometric3D::TaggedGeometric3D( const RefCountPtr< const Lang::Symbol > & key, const RefCountPtr< const Lang::Geometric3D > & val )
 356         : Lang::Tagged3D( key ), val_( val )
 357 { }
 358
 359 Lang::TaggedGeometric3D::TaggedGeometric3D( const Lang::Symbol::KeyType key, const RefCountPtr< const Lang::Geometric3D > & val )
 360         : Lang::Tagged3D( key ), val_( val )
 361 { }
 362
 363 Lang::TaggedGeometric3D::~TaggedGeometric3D( )
 364 { }
 365
 366
 367 RefCountPtr< const Lang::Drawable2D >
 368 Lang::TaggedGeometric3D::typed_to2D( const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
 369 {
 370         RefCountPtr< const Lang::Geometric3D > tfVal = val_->transformed( tf, val_ );
 371         return RefCountPtr< const Lang::Drawable2D >( new Lang::TaggedGeometric2D( key_, tfVal->to2D( dyn, tfVal ) ) );
 372 }
 373
 374 void
 375 Lang::TaggedGeometric3D::polygonize( std::list< RefCountPtr< Computation::PaintedPolygon3D > > * zBufPile, std::list< RefCountPtr< Computation::StrokedLine3D > > * linePile, const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
 376 {
 377         // Note that polygonization eats tags.
 378 }
 379
 380 void
 381 Lang::TaggedGeometric3D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
 382 {
 383         // tf is ignored for this type of tag.
 384         if( key_ == key )
 385                 {
 386                         dst->push_back( val_->transformed( tf, val_ ) );
 387                 }
 388 }
 389
 390 bool
 391 Lang::TaggedGeometric3D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
 392 {
 393         // tf is ignored for this type of tag.
 394         if( key_ == key )
 395                 {
 396                         Kernel::ContRef cont = evalState->cont_;
 397                         cont->takeValue( val_->transformed( tf, val_ ),
 398                                                                                          evalState );
 399                         return true;
 400                 }
 401         return false;
 402 }
 403
 404 void
 405 Lang::TaggedGeometric3D::show( std::ostream & os ) const
 406 {
 407         try
 408                 {
 409                         os << "Geometric value (3D) with the tag " << Lang::Symbol::nameFromKey( key_ ).getPtr( ) ;
 410                 }
 411         catch( ... )
 412                 {
 413                         os << "Geometric value (3D) with unique tag." ;
 414                 }
 415 }
 416
 417 void
 418 Lang::TaggedGeometric3D::gcMark( Kernel::GCMarkedSet & marked )
 419 {
 420         const_cast< Lang::Geometric3D * >( val_.getPtr( ) )->gcMark( marked );
 421 }
 422
 423
 424 Lang::TaggedDrawable3D::TaggedDrawable3D( const RefCountPtr< const Lang::Symbol > & key, const RefCountPtr< const Lang::Drawable3D > & val )
 425         : Lang::Tagged3D( key ), val_( val )
 426 { }
 427
 428 Lang::TaggedDrawable3D::TaggedDrawable3D( const Lang::Symbol::KeyType key, const RefCountPtr< const Lang::Drawable3D > & val )
 429         : Lang::Tagged3D( key ), val_( val )
 430 { }
 431
 432 Lang::TaggedDrawable3D::~TaggedDrawable3D( )
 433 { }
 434
 435 RefCountPtr< const Lang::Drawable2D >
 436 Lang::TaggedDrawable3D::typed_to2D( const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
 437 {
 438         return RefCountPtr< const Lang::Drawable2D >( new Lang::TaggedDrawable2D( key_, val_->typed_to2D( dyn, tf, val_ ) ) );
 439 }
 440
 441 void
 442 Lang::TaggedDrawable3D::polygonize( std::list< RefCountPtr< Computation::PaintedPolygon3D > > * zBufPile, std::list< RefCountPtr< Computation::StrokedLine3D > > * linePile, const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
 443 {
 444         // Note that polygonization eats tags.
 445
 446         val_->polygonize( zBufPile, linePile, dyn, tf, val_ );
 447 }
 448
 449
 450 void
 451 Lang::TaggedDrawable3D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
 452 {
 453         // tf is ignored for this type of tag.
 454         if( key_ == key )
 455                 {
 456                         dst->push_back( val_->transformed( tf, val_ ) );
 457                 }
 458 }
 459
 460 bool
 461 Lang::TaggedDrawable3D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
 462 {
 463         // tf is ignored for this type of tag.
 464         if( key_ == key )
 465                 {
 466                         Kernel::ContRef cont = evalState->cont_;
 467                         cont->takeValue( val_->transformed( tf, val_ ),
 468                                                                                          evalState );
 469                         return true;
 470                 }
 471         return false;
 472 }
 473
 474 void
 475 Lang::TaggedDrawable3D::show( std::ostream & os ) const
 476 {
 477         try
 478                 {
 479                         os << "Drawable value (3D) with the tag " << Lang::Symbol::nameFromKey( key_ ).getPtr( ) ;
 480                 }
 481         catch( ... )
 482                 {
 483                         os << "Drawable value (3D) with unique tag." ;
 484                 }
 485 }
 486
 487 void
 488 Lang::TaggedDrawable3D::gcMark( Kernel::GCMarkedSet & marked )
 489 {
 490         const_cast< Lang::Drawable3D * >( val_.getPtr( ) )->gcMark( marked );
 491 }
 492