Source/System/Dynamics/Animation/OSGTimeSensorBase.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *               Copyright (C) 2000-2013 by the OpenSG Forum                 *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  * contact: dirk@opensg.org, gerrit.voss@vossg.org, carsten_neumann@gmx.net  *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 /*****************************************************************************\
  40  *****************************************************************************
  41  **                                                                         **
  42  **                  This file is automatically generated.                  **
  43  **                                                                         **
  44  **          Any changes made to this file WILL be lost when it is          **
  45  **           regenerated, which can become necessary at any time.          **
  46  **                                                                         **
  47  **     Do not change this file, changes should be done in the derived      **
  48  **     class TimeSensor!
  49  **                                                                         **
  50  *****************************************************************************
  51 \*****************************************************************************/
  52
  53 #include <cstdlib>
  54 #include <cstdio>
  55
  56 #ifdef WIN32
  57 #pragma warning(disable: 4355) // turn off 'this' : used in base member initializer list warning
  58 #pragma warning(disable: 4290) // disable exception specification warning
  59 #endif
  60
  61 #include "OSGConfig.h"
  62
  63
  64
  65
  66 #include "OSGTimeSensorBase.h"
  67 #include "OSGTimeSensor.h"
  68
  69 #include <boost/bind.hpp>
  70
  71 OSG_BEGIN_NAMESPACE
  72
  73 /***************************************************************************\
  74  *                            Description                                  *
  75 \***************************************************************************/
  76
  77 /*! \class OSG::TimeSensor
  78
  79  */
  80
  81 /***************************************************************************\
  82  *                        Field Documentation                              *
  83 \***************************************************************************/
  84
  85 /*! \var bool            TimeSensorBase::_sfEnabled
  86
  87 */
  88
  89 /*! \var bool            TimeSensorBase::_sfIsActive
  90
  91 */
  92
  93 /*! \var bool            TimeSensorBase::_sfLoop
  94
  95 */
  96
  97 /*! \var Real32          TimeSensorBase::_sfFraction
  98
  99 */
 100
 101 /*! \var Time            TimeSensorBase::_sfStartTime
 102
 103 */
 104
 105 /*! \var Time            TimeSensorBase::_sfStopTime
 106
 107 */
 108
 109 /*! \var Time            TimeSensorBase::_sfCycleTime
 110
 111 */
 112
 113 /*! \var Time            TimeSensorBase::_sfTime
 114
 115 */
 116
 117 /*! \var Time            TimeSensorBase::_sfCycleInterval
 118
 119 */
 120
 121 /*! \var Time            TimeSensorBase::_sfChangeFractionBy
 122
 123 */
 124
 125
 126 /***************************************************************************\
 127  *                      FieldType/FieldTrait Instantiation                 *
 128 \***************************************************************************/
 129
 130 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
 131 PointerType FieldTraits<TimeSensor *, nsOSG>::_type(
 132     "TimeSensorPtr",
 133     "NodeCorePtr",
 134     TimeSensor::getClassType(),
 135     nsOSG);
 136 #endif
 137
 138 OSG_FIELDTRAITS_GETTYPE_NS(TimeSensor *, nsOSG)
 139
 140 OSG_EXPORT_PTR_SFIELD_FULL(PointerSField,
 141                            TimeSensor *,
 142                            nsOSG)
 143
 144 OSG_EXPORT_PTR_MFIELD_FULL(PointerMField,
 145                            TimeSensor *,
 146                            nsOSG)
 147
 148 /***************************************************************************\
 149  *                         Field Description                               *
 150 \***************************************************************************/
 151
 152 void TimeSensorBase::classDescInserter(TypeObject &oType)
 153 {
 154     Inherited::classDescInserter(oType);
 155
 156     FieldDescriptionBase *pDesc = NULL;
 157
 158
 159     pDesc = new SFBool::Description(
 160         SFBool::getClassType(),
 161         "enabled",
 162         "",
 163         EnabledFieldId, EnabledFieldMask,
 164         true,
 165         (Field::FStdAccess | Field::FThreadLocal),
 166         static_cast<FieldEditMethodSig>(&TimeSensor::editHandleEnabled),
 167         static_cast<FieldGetMethodSig >(&TimeSensor::getHandleEnabled));
 168
 169     oType.addInitialDesc(pDesc);
 170
 171     pDesc = new SFBool::Description(
 172         SFBool::getClassType(),
 173         "isActive",
 174         "",
 175         IsActiveFieldId, IsActiveFieldMask,
 176         true,
 177         (Field::FStdAccess | Field::FThreadLocal),
 178         static_cast<FieldEditMethodSig>(&TimeSensor::editHandleIsActive),
 179         static_cast<FieldGetMethodSig >(&TimeSensor::getHandleIsActive));
 180
 181     oType.addInitialDesc(pDesc);
 182
 183     pDesc = new SFBool::Description(
 184         SFBool::getClassType(),
 185         "loop",
 186         "",
 187         LoopFieldId, LoopFieldMask,
 188         true,
 189         (Field::FStdAccess | Field::FThreadLocal),
 190         static_cast<FieldEditMethodSig>(&TimeSensor::editHandleLoop),
 191         static_cast<FieldGetMethodSig >(&TimeSensor::getHandleLoop));
 192
 193     oType.addInitialDesc(pDesc);
 194
 195     pDesc = new SFReal32::Description(
 196         SFReal32::getClassType(),
 197         "fraction",
 198         "",
 199         FractionFieldId, FractionFieldMask,
 200         true,
 201         (Field::FStdAccess | Field::FThreadLocal),
 202         static_cast<FieldEditMethodSig>(&TimeSensor::editHandleFraction),
 203         static_cast<FieldGetMethodSig >(&TimeSensor::getHandleFraction));
 204
 205     oType.addInitialDesc(pDesc);
 206
 207     pDesc = new SFTime::Description(
 208         SFTime::getClassType(),
 209         "startTime",
 210         "",
 211         StartTimeFieldId, StartTimeFieldMask,
 212         true,
 213         (Field::FStdAccess | Field::FThreadLocal),
 214         static_cast<FieldEditMethodSig>(&TimeSensor::editHandleStartTime),
 215         static_cast<FieldGetMethodSig >(&TimeSensor::getHandleStartTime));
 216
 217     oType.addInitialDesc(pDesc);
 218
 219     pDesc = new SFTime::Description(
 220         SFTime::getClassType(),
 221         "stopTime",
 222         "",
 223         StopTimeFieldId, StopTimeFieldMask,
 224         true,
 225         (Field::FStdAccess | Field::FThreadLocal),
 226         static_cast<FieldEditMethodSig>(&TimeSensor::editHandleStopTime),
 227         static_cast<FieldGetMethodSig >(&TimeSensor::getHandleStopTime));
 228
 229     oType.addInitialDesc(pDesc);
 230
 231     pDesc = new SFTime::Description(
 232         SFTime::getClassType(),
 233         "cycleTime",
 234         "",
 235         CycleTimeFieldId, CycleTimeFieldMask,
 236         true,
 237         (Field::FStdAccess | Field::FThreadLocal),
 238         static_cast<FieldEditMethodSig>(&TimeSensor::editHandleCycleTime),
 239         static_cast<FieldGetMethodSig >(&TimeSensor::getHandleCycleTime));
 240
 241     oType.addInitialDesc(pDesc);
 242
 243     pDesc = new SFTime::Description(
 244         SFTime::getClassType(),
 245         "time",
 246         "",
 247         TimeFieldId, TimeFieldMask,
 248         true,
 249         (Field::FStdAccess | Field::FThreadLocal),
 250         static_cast<FieldEditMethodSig>(&TimeSensor::editHandleTime),
 251         static_cast<FieldGetMethodSig >(&TimeSensor::getHandleTime));
 252
 253     oType.addInitialDesc(pDesc);
 254
 255     pDesc = new SFTime::Description(
 256         SFTime::getClassType(),
 257         "cycleInterval",
 258         "",
 259         CycleIntervalFieldId, CycleIntervalFieldMask,
 260         true,
 261         (Field::FStdAccess | Field::FThreadLocal),
 262         static_cast<FieldEditMethodSig>(&TimeSensor::editHandleCycleInterval),
 263         static_cast<FieldGetMethodSig >(&TimeSensor::getHandleCycleInterval));
 264
 265     oType.addInitialDesc(pDesc);
 266
 267     pDesc = new SFTime::Description(
 268         SFTime::getClassType(),
 269         "changeFractionBy",
 270         "",
 271         ChangeFractionByFieldId, ChangeFractionByFieldMask,
 272         true,
 273         (Field::FStdAccess | Field::FThreadLocal),
 274         static_cast<FieldEditMethodSig>(&TimeSensor::editHandleChangeFractionBy),
 275         static_cast<FieldGetMethodSig >(&TimeSensor::getHandleChangeFractionBy));
 276
 277     oType.addInitialDesc(pDesc);
 278 }
 279
 280
 281 TimeSensorBase::TypeObject TimeSensorBase::_type(
 282     TimeSensorBase::getClassname(),
 283     Inherited::getClassname(),
 284     "NULL",
 285     nsOSG, //Namespace
 286     reinterpret_cast<PrototypeCreateF>(&TimeSensorBase::createEmptyLocal),
 287     reinterpret_cast<InitContainerF>(&TimeSensor::initMethod),
 288     reinterpret_cast<ExitContainerF>(&TimeSensor::exitMethod),
 289     reinterpret_cast<InitalInsertDescFunc>(
 290         reinterpret_cast<void *>(&TimeSensor::classDescInserter)),
 291     false,
 292     0,
 293     "<?xml version=\"1.0\"?>\n"
 294     "\n"
 295     "<FieldContainer\n"
 296     "   name=\"TimeSensor\"\n"
 297     "   parent=\"NodeCore\"\n"
 298     "   mixinparent=\"NodeCoreSensorParent\"\n"
 299     "   library=\"Dynamics\"\n"
 300     "   pointerfieldtypes=\"both\"\n"
 301     "   structure=\"concrete\"\n"
 302     "   systemcomponent=\"true\"\n"
 303     "   parentsystemcomponent=\"true\"\n"
 304     "   decoratable=\"false\"\n"
 305     "   useLocalIncludes=\"false\"\n"
 306     "   isNodeCore=\"true\"\n"
 307     "   isBundle=\"false\"\n"
 308     "   parentFields=\"none\"\n"
 309     "   docGroupBase=\"GrpDynamicsAnimation\"\n"
 310     "   >\n"
 311     "  <Field\n"
 312     "     name=\"enabled\"\n"
 313     "     type=\"bool\"\n"
 314     "     cardinality=\"single\"\n"
 315     "     visibility=\"internal\"\n"
 316     "     access=\"public\"\n"
 317     "     defaultValue=\"true\"\n"
 318     "     fieldFlags=\"FStdAccess, FThreadLocal\"\n"
 319     "     >\n"
 320     "  </Field>\n"
 321     "  <Field\n"
 322     "     name=\"isActive\"\n"
 323     "     type=\"bool\"\n"
 324     "     cardinality=\"single\"\n"
 325     "     visibility=\"internal\"\n"
 326     "     access=\"public\"\n"
 327     "     defaultValue=\"false\"\n"
 328     "     fieldFlags=\"FStdAccess, FThreadLocal\"\n"
 329     "     >\n"
 330     "  </Field>\n"
 331     "  <Field\n"
 332     "     name=\"loop\"\n"
 333     "     type=\"bool\"\n"
 334     "     cardinality=\"single\"\n"
 335     "     visibility=\"internal\"\n"
 336     "     access=\"public\"\n"
 337     "     defaultValue=\"false\"\n"
 338     "     fieldFlags=\"FStdAccess, FThreadLocal\"\n"
 339     "     >\n"
 340     "  </Field>\n"
 341     "  <Field\n"
 342     "     name=\"fraction\"\n"
 343     "     type=\"Real32\"\n"
 344     "     cardinality=\"single\"\n"
 345     "     visibility=\"internal\"\n"
 346     "     access=\"public\"\n"
 347     "     defaultValue=\"0.0\"\n"
 348     "     fieldFlags=\"FStdAccess, FThreadLocal\"\n"
 349     "     >\n"
 350     "  </Field>\n"
 351     "  <Field\n"
 352     "     name=\"startTime\"\n"
 353     "     type=\"Time\"\n"
 354     "     cardinality=\"single\"\n"
 355     "     visibility=\"internal\"\n"
 356     "     access=\"public\"\n"
 357     "     defaultValue=\"0.0\"\n"
 358     "     fieldFlags=\"FStdAccess, FThreadLocal\"\n"
 359     "     >\n"
 360     "  </Field>\n"
 361     "  <Field\n"
 362     "     name=\"stopTime\"\n"
 363     "     type=\"Time\"\n"
 364     "     cardinality=\"single\"\n"
 365     "     visibility=\"internal\"\n"
 366     "     access=\"public\"\n"
 367     "     defaultValue=\"0.0\"\n"
 368     "     fieldFlags=\"FStdAccess, FThreadLocal\"\n"
 369     "     >\n"
 370     "  </Field>\n"
 371     "  <Field\n"
 372     "     name=\"cycleTime\"\n"
 373     "     type=\"Time\"\n"
 374     "     cardinality=\"single\"\n"
 375     "     visibility=\"internal\"\n"
 376     "     access=\"public\"\n"
 377     "     defaultValue=\"0.0\"\n"
 378     "     fieldFlags=\"FStdAccess, FThreadLocal\"\n"
 379     "     >\n"
 380     "  </Field>\n"
 381     "  <Field\n"
 382     "     name=\"time\"\n"
 383     "     type=\"Time\"\n"
 384     "     cardinality=\"single\"\n"
 385     "     visibility=\"internal\"\n"
 386     "     access=\"public\"\n"
 387     "     defaultValue=\"0.0\"\n"
 388     "     fieldFlags=\"FStdAccess, FThreadLocal\"\n"
 389     "     >\n"
 390     "  </Field>\n"
 391     "  <Field\n"
 392     "     name=\"cycleInterval\"\n"
 393     "     type=\"Time\"\n"
 394     "     cardinality=\"single\"\n"
 395     "     visibility=\"internal\"\n"
 396     "     access=\"public\"\n"
 397     "     defaultValue=\"1.0\"\n"
 398     "     fieldFlags=\"FStdAccess, FThreadLocal\"\n"
 399     "     >\n"
 400     "  </Field>\n"
 401     "  <Field\n"
 402     "     name=\"changeFractionBy\"\n"
 403     "     type=\"Time\"\n"
 404     "     cardinality=\"single\"\n"
 405     "     visibility=\"internal\"\n"
 406     "     access=\"public\"\n"
 407     "     fieldFlags=\"FStdAccess, FThreadLocal\"\n"
 408     "     >\n"
 409     "  </Field>\n"
 410     "</FieldContainer>\n",
 411     ""
 412     );
 413
 414 /*------------------------------ get -----------------------------------*/
 415
 416 FieldContainerType &TimeSensorBase::getType(void)
 417 {
 418     return _type;
 419 }
 420
 421 const FieldContainerType &TimeSensorBase::getType(void) const
 422 {
 423     return _type;
 424 }
 425
 426 UInt32 TimeSensorBase::getContainerSize(void) const
 427 {
 428     return sizeof(TimeSensor);
 429 }
 430
 431 /*------------------------- decorator get ------------------------------*/
 432
 433
 434 SFBool *TimeSensorBase::editSFEnabled(void)
 435 {
 436     editSField(EnabledFieldMask);
 437
 438     return &_sfEnabled;
 439 }
 440
 441 const SFBool *TimeSensorBase::getSFEnabled(void) const
 442 {
 443     return &_sfEnabled;
 444 }
 445
 446
 447 SFBool *TimeSensorBase::editSFIsActive(void)
 448 {
 449     editSField(IsActiveFieldMask);
 450
 451     return &_sfIsActive;
 452 }
 453
 454 const SFBool *TimeSensorBase::getSFIsActive(void) const
 455 {
 456     return &_sfIsActive;
 457 }
 458
 459
 460 SFBool *TimeSensorBase::editSFLoop(void)
 461 {
 462     editSField(LoopFieldMask);
 463
 464     return &_sfLoop;
 465 }
 466
 467 const SFBool *TimeSensorBase::getSFLoop(void) const
 468 {
 469     return &_sfLoop;
 470 }
 471
 472
 473 SFReal32 *TimeSensorBase::editSFFraction(void)
 474 {
 475     editSField(FractionFieldMask);
 476
 477     return &_sfFraction;
 478 }
 479
 480 const SFReal32 *TimeSensorBase::getSFFraction(void) const
 481 {
 482     return &_sfFraction;
 483 }
 484
 485
 486 SFTime *TimeSensorBase::editSFStartTime(void)
 487 {
 488     editSField(StartTimeFieldMask);
 489
 490     return &_sfStartTime;
 491 }
 492
 493 const SFTime *TimeSensorBase::getSFStartTime(void) const
 494 {
 495     return &_sfStartTime;
 496 }
 497
 498
 499 SFTime *TimeSensorBase::editSFStopTime(void)
 500 {
 501     editSField(StopTimeFieldMask);
 502
 503     return &_sfStopTime;
 504 }
 505
 506 const SFTime *TimeSensorBase::getSFStopTime(void) const
 507 {
 508     return &_sfStopTime;
 509 }
 510
 511
 512 SFTime *TimeSensorBase::editSFCycleTime(void)
 513 {
 514     editSField(CycleTimeFieldMask);
 515
 516     return &_sfCycleTime;
 517 }
 518
 519 const SFTime *TimeSensorBase::getSFCycleTime(void) const
 520 {
 521     return &_sfCycleTime;
 522 }
 523
 524
 525 SFTime *TimeSensorBase::editSFTime(void)
 526 {
 527     editSField(TimeFieldMask);
 528
 529     return &_sfTime;
 530 }
 531
 532 const SFTime *TimeSensorBase::getSFTime(void) const
 533 {
 534     return &_sfTime;
 535 }
 536
 537
 538 SFTime *TimeSensorBase::editSFCycleInterval(void)
 539 {
 540     editSField(CycleIntervalFieldMask);
 541
 542     return &_sfCycleInterval;
 543 }
 544
 545 const SFTime *TimeSensorBase::getSFCycleInterval(void) const
 546 {
 547     return &_sfCycleInterval;
 548 }
 549
 550
 551 SFTime *TimeSensorBase::editSFChangeFractionBy(void)
 552 {
 553     editSField(ChangeFractionByFieldMask);
 554
 555     return &_sfChangeFractionBy;
 556 }
 557
 558 const SFTime *TimeSensorBase::getSFChangeFractionBy(void) const
 559 {
 560     return &_sfChangeFractionBy;
 561 }
 562
 563
 564
 565
 566
 567
 568 /*------------------------------ access -----------------------------------*/
 569
 570 SizeT TimeSensorBase::getBinSize(ConstFieldMaskArg whichField)
 571 {
 572     SizeT returnValue = Inherited::getBinSize(whichField);
 573
 574     if(FieldBits::NoField != (EnabledFieldMask & whichField))
 575     {
 576         returnValue += _sfEnabled.getBinSize();
 577     }
 578     if(FieldBits::NoField != (IsActiveFieldMask & whichField))
 579     {
 580         returnValue += _sfIsActive.getBinSize();
 581     }
 582     if(FieldBits::NoField != (LoopFieldMask & whichField))
 583     {
 584         returnValue += _sfLoop.getBinSize();
 585     }
 586     if(FieldBits::NoField != (FractionFieldMask & whichField))
 587     {
 588         returnValue += _sfFraction.getBinSize();
 589     }
 590     if(FieldBits::NoField != (StartTimeFieldMask & whichField))
 591     {
 592         returnValue += _sfStartTime.getBinSize();
 593     }
 594     if(FieldBits::NoField != (StopTimeFieldMask & whichField))
 595     {
 596         returnValue += _sfStopTime.getBinSize();
 597     }
 598     if(FieldBits::NoField != (CycleTimeFieldMask & whichField))
 599     {
 600         returnValue += _sfCycleTime.getBinSize();
 601     }
 602     if(FieldBits::NoField != (TimeFieldMask & whichField))
 603     {
 604         returnValue += _sfTime.getBinSize();
 605     }
 606     if(FieldBits::NoField != (CycleIntervalFieldMask & whichField))
 607     {
 608         returnValue += _sfCycleInterval.getBinSize();
 609     }
 610     if(FieldBits::NoField != (ChangeFractionByFieldMask & whichField))
 611     {
 612         returnValue += _sfChangeFractionBy.getBinSize();
 613     }
 614
 615     return returnValue;
 616 }
 617
 618 void TimeSensorBase::copyToBin(BinaryDataHandler &pMem,
 619                                   ConstFieldMaskArg  whichField)
 620 {
 621     Inherited::copyToBin(pMem, whichField);
 622
 623     if(FieldBits::NoField != (EnabledFieldMask & whichField))
 624     {
 625         _sfEnabled.copyToBin(pMem);
 626     }
 627     if(FieldBits::NoField != (IsActiveFieldMask & whichField))
 628     {
 629         _sfIsActive.copyToBin(pMem);
 630     }
 631     if(FieldBits::NoField != (LoopFieldMask & whichField))
 632     {
 633         _sfLoop.copyToBin(pMem);
 634     }
 635     if(FieldBits::NoField != (FractionFieldMask & whichField))
 636     {
 637         _sfFraction.copyToBin(pMem);
 638     }
 639     if(FieldBits::NoField != (StartTimeFieldMask & whichField))
 640     {
 641         _sfStartTime.copyToBin(pMem);
 642     }
 643     if(FieldBits::NoField != (StopTimeFieldMask & whichField))
 644     {
 645         _sfStopTime.copyToBin(pMem);
 646     }
 647     if(FieldBits::NoField != (CycleTimeFieldMask & whichField))
 648     {
 649         _sfCycleTime.copyToBin(pMem);
 650     }
 651     if(FieldBits::NoField != (TimeFieldMask & whichField))
 652     {
 653         _sfTime.copyToBin(pMem);
 654     }
 655     if(FieldBits::NoField != (CycleIntervalFieldMask & whichField))
 656     {
 657         _sfCycleInterval.copyToBin(pMem);
 658     }
 659     if(FieldBits::NoField != (ChangeFractionByFieldMask & whichField))
 660     {
 661         _sfChangeFractionBy.copyToBin(pMem);
 662     }
 663 }
 664
 665 void TimeSensorBase::copyFromBin(BinaryDataHandler &pMem,
 666                                     ConstFieldMaskArg  whichField)
 667 {
 668     Inherited::copyFromBin(pMem, whichField);
 669
 670     if(FieldBits::NoField != (EnabledFieldMask & whichField))
 671     {
 672         editSField(EnabledFieldMask);
 673         _sfEnabled.copyFromBin(pMem);
 674     }
 675     if(FieldBits::NoField != (IsActiveFieldMask & whichField))
 676     {
 677         editSField(IsActiveFieldMask);
 678         _sfIsActive.copyFromBin(pMem);
 679     }
 680     if(FieldBits::NoField != (LoopFieldMask & whichField))
 681     {
 682         editSField(LoopFieldMask);
 683         _sfLoop.copyFromBin(pMem);
 684     }
 685     if(FieldBits::NoField != (FractionFieldMask & whichField))
 686     {
 687         editSField(FractionFieldMask);
 688         _sfFraction.copyFromBin(pMem);
 689     }
 690     if(FieldBits::NoField != (StartTimeFieldMask & whichField))
 691     {
 692         editSField(StartTimeFieldMask);
 693         _sfStartTime.copyFromBin(pMem);
 694     }
 695     if(FieldBits::NoField != (StopTimeFieldMask & whichField))
 696     {
 697         editSField(StopTimeFieldMask);
 698         _sfStopTime.copyFromBin(pMem);
 699     }
 700     if(FieldBits::NoField != (CycleTimeFieldMask & whichField))
 701     {
 702         editSField(CycleTimeFieldMask);
 703         _sfCycleTime.copyFromBin(pMem);
 704     }
 705     if(FieldBits::NoField != (TimeFieldMask & whichField))
 706     {
 707         editSField(TimeFieldMask);
 708         _sfTime.copyFromBin(pMem);
 709     }
 710     if(FieldBits::NoField != (CycleIntervalFieldMask & whichField))
 711     {
 712         editSField(CycleIntervalFieldMask);
 713         _sfCycleInterval.copyFromBin(pMem);
 714     }
 715     if(FieldBits::NoField != (ChangeFractionByFieldMask & whichField))
 716     {
 717         editSField(ChangeFractionByFieldMask);
 718         _sfChangeFractionBy.copyFromBin(pMem);
 719     }
 720 }
 721
 722 //! create a new instance of the class
 723 TimeSensorTransitPtr TimeSensorBase::createLocal(BitVector bFlags)
 724 {
 725     TimeSensorTransitPtr fc;
 726
 727     if(getClassType().getPrototype() != NULL)
 728     {
 729         FieldContainerTransitPtr tmpPtr =
 730             getClassType().getPrototype()-> shallowCopyLocal(bFlags);
 731
 732         fc = dynamic_pointer_cast<TimeSensor>(tmpPtr);
 733     }
 734
 735     return fc;
 736 }
 737
 738 //! create a new instance of the class, copy the container flags
 739 TimeSensorTransitPtr TimeSensorBase::createDependent(BitVector bFlags)
 740 {
 741     TimeSensorTransitPtr fc;
 742
 743     if(getClassType().getPrototype() != NULL)
 744     {
 745         FieldContainerTransitPtr tmpPtr =
 746             getClassType().getPrototype()-> shallowCopyDependent(bFlags);
 747
 748         fc = dynamic_pointer_cast<TimeSensor>(tmpPtr);
 749     }
 750
 751     return fc;
 752 }
 753
 754 //! create a new instance of the class
 755 TimeSensorTransitPtr TimeSensorBase::create(void)
 756 {
 757     TimeSensorTransitPtr fc;
 758
 759     if(getClassType().getPrototype() != NULL)
 760     {
 761         FieldContainerTransitPtr tmpPtr =
 762             getClassType().getPrototype()-> shallowCopy();
 763
 764         fc = dynamic_pointer_cast<TimeSensor>(tmpPtr);
 765     }
 766
 767     return fc;
 768 }
 769
 770 TimeSensor *TimeSensorBase::createEmptyLocal(BitVector bFlags)
 771 {
 772     TimeSensor *returnValue;
 773
 774     newPtr<TimeSensor>(returnValue, bFlags);
 775
 776     returnValue->_pFieldFlags->_bNamespaceMask &= ~bFlags;
 777
 778     return returnValue;
 779 }
 780
 781 //! create an empty new instance of the class, do not copy the prototype
 782 TimeSensor *TimeSensorBase::createEmpty(void)
 783 {
 784     TimeSensor *returnValue;
 785
 786     newPtr<TimeSensor>(returnValue, Thread::getCurrentLocalFlags());
 787
 788     returnValue->_pFieldFlags->_bNamespaceMask &=
 789         ~Thread::getCurrentLocalFlags();
 790
 791     return returnValue;
 792 }
 793
 794
 795 FieldContainerTransitPtr TimeSensorBase::shallowCopyLocal(
 796     BitVector bFlags) const
 797 {
 798     TimeSensor *tmpPtr;
 799
 800     newPtr(tmpPtr, dynamic_cast<const TimeSensor *>(this), bFlags);
 801
 802     FieldContainerTransitPtr returnValue(tmpPtr);
 803
 804     tmpPtr->_pFieldFlags->_bNamespaceMask &= ~bFlags;
 805
 806     return returnValue;
 807 }
 808
 809 FieldContainerTransitPtr TimeSensorBase::shallowCopyDependent(
 810     BitVector bFlags) const
 811 {
 812     TimeSensor *tmpPtr;
 813
 814     newPtr(tmpPtr, dynamic_cast<const TimeSensor *>(this), ~bFlags);
 815
 816     FieldContainerTransitPtr returnValue(tmpPtr);
 817
 818     tmpPtr->_pFieldFlags->_bNamespaceMask = bFlags;
 819
 820     return returnValue;
 821 }
 822
 823 FieldContainerTransitPtr TimeSensorBase::shallowCopy(void) const
 824 {
 825     TimeSensor *tmpPtr;
 826
 827     newPtr(tmpPtr,
 828            dynamic_cast<const TimeSensor *>(this),
 829            Thread::getCurrentLocalFlags());
 830
 831     tmpPtr->_pFieldFlags->_bNamespaceMask &= ~Thread::getCurrentLocalFlags();
 832
 833     FieldContainerTransitPtr returnValue(tmpPtr);
 834
 835     return returnValue;
 836 }
 837
 838
 839
 840
 841 /*------------------------- constructors ----------------------------------*/
 842
 843 TimeSensorBase::TimeSensorBase(void) :
 844     Inherited(),
 845     _sfEnabled                (bool(true)),
 846     _sfIsActive               (bool(false)),
 847     _sfLoop                   (bool(false)),
 848     _sfFraction               (Real32(0.0)),
 849     _sfStartTime              (Time(0.0)),
 850     _sfStopTime               (Time(0.0)),
 851     _sfCycleTime              (Time(0.0)),
 852     _sfTime                   (Time(0.0)),
 853     _sfCycleInterval          (Time(1.0)),
 854     _sfChangeFractionBy       ()
 855 {
 856 }
 857
 858 TimeSensorBase::TimeSensorBase(const TimeSensorBase &source) :
 859     Inherited(source),
 860     _sfEnabled                (source._sfEnabled                ),
 861     _sfIsActive               (source._sfIsActive               ),
 862     _sfLoop                   (source._sfLoop                   ),
 863     _sfFraction               (source._sfFraction               ),
 864     _sfStartTime              (source._sfStartTime              ),
 865     _sfStopTime               (source._sfStopTime               ),
 866     _sfCycleTime              (source._sfCycleTime              ),
 867     _sfTime                   (source._sfTime                   ),
 868     _sfCycleInterval          (source._sfCycleInterval          ),
 869     _sfChangeFractionBy       (source._sfChangeFractionBy       )
 870 {
 871 }
 872
 873
 874 /*-------------------------- destructors ----------------------------------*/
 875
 876 TimeSensorBase::~TimeSensorBase(void)
 877 {
 878 }
 879
 880
 881 GetFieldHandlePtr TimeSensorBase::getHandleEnabled         (void) const
 882 {
 883     SFBool::GetHandlePtr returnValue(
 884         new  SFBool::GetHandle(
 885              &_sfEnabled,
 886              this->getType().getFieldDesc(EnabledFieldId),
 887              const_cast<TimeSensorBase *>(this)));
 888
 889     return returnValue;
 890 }
 891
 892 EditFieldHandlePtr TimeSensorBase::editHandleEnabled        (void)
 893 {
 894     SFBool::EditHandlePtr returnValue(
 895         new  SFBool::EditHandle(
 896              &_sfEnabled,
 897              this->getType().getFieldDesc(EnabledFieldId),
 898              this));
 899
 900
 901     editSField(EnabledFieldMask);
 902
 903     return returnValue;
 904 }
 905
 906 GetFieldHandlePtr TimeSensorBase::getHandleIsActive        (void) const
 907 {
 908     SFBool::GetHandlePtr returnValue(
 909         new  SFBool::GetHandle(
 910              &_sfIsActive,
 911              this->getType().getFieldDesc(IsActiveFieldId),
 912              const_cast<TimeSensorBase *>(this)));
 913
 914     return returnValue;
 915 }
 916
 917 EditFieldHandlePtr TimeSensorBase::editHandleIsActive       (void)
 918 {
 919     SFBool::EditHandlePtr returnValue(
 920         new  SFBool::EditHandle(
 921              &_sfIsActive,
 922              this->getType().getFieldDesc(IsActiveFieldId),
 923              this));
 924
 925
 926     editSField(IsActiveFieldMask);
 927
 928     return returnValue;
 929 }
 930
 931 GetFieldHandlePtr TimeSensorBase::getHandleLoop            (void) const
 932 {
 933     SFBool::GetHandlePtr returnValue(
 934         new  SFBool::GetHandle(
 935              &_sfLoop,
 936              this->getType().getFieldDesc(LoopFieldId),
 937              const_cast<TimeSensorBase *>(this)));
 938
 939     return returnValue;
 940 }
 941
 942 EditFieldHandlePtr TimeSensorBase::editHandleLoop           (void)
 943 {
 944     SFBool::EditHandlePtr returnValue(
 945         new  SFBool::EditHandle(
 946              &_sfLoop,
 947              this->getType().getFieldDesc(LoopFieldId),
 948              this));
 949
 950
 951     editSField(LoopFieldMask);
 952
 953     return returnValue;
 954 }
 955
 956 GetFieldHandlePtr TimeSensorBase::getHandleFraction        (void) const
 957 {
 958     SFReal32::GetHandlePtr returnValue(
 959         new  SFReal32::GetHandle(
 960              &_sfFraction,
 961              this->getType().getFieldDesc(FractionFieldId),
 962              const_cast<TimeSensorBase *>(this)));
 963
 964     return returnValue;
 965 }
 966
 967 EditFieldHandlePtr TimeSensorBase::editHandleFraction       (void)
 968 {
 969     SFReal32::EditHandlePtr returnValue(
 970         new  SFReal32::EditHandle(
 971              &_sfFraction,
 972              this->getType().getFieldDesc(FractionFieldId),
 973              this));
 974
 975
 976     editSField(FractionFieldMask);
 977
 978     return returnValue;
 979 }
 980
 981 GetFieldHandlePtr TimeSensorBase::getHandleStartTime       (void) const
 982 {
 983     SFTime::GetHandlePtr returnValue(
 984         new  SFTime::GetHandle(
 985              &_sfStartTime,
 986              this->getType().getFieldDesc(StartTimeFieldId),
 987              const_cast<TimeSensorBase *>(this)));
 988
 989     return returnValue;
 990 }
 991
 992 EditFieldHandlePtr TimeSensorBase::editHandleStartTime      (void)
 993 {
 994     SFTime::EditHandlePtr returnValue(
 995         new  SFTime::EditHandle(
 996              &_sfStartTime,
 997              this->getType().getFieldDesc(StartTimeFieldId),
 998              this));
 999
1000
1001     editSField(StartTimeFieldMask);
1002
1003     return returnValue;
1004 }
1005
1006 GetFieldHandlePtr TimeSensorBase::getHandleStopTime        (void) const
1007 {
1008     SFTime::GetHandlePtr returnValue(
1009         new  SFTime::GetHandle(
1010              &_sfStopTime,
1011              this->getType().getFieldDesc(StopTimeFieldId),
1012              const_cast<TimeSensorBase *>(this)));
1013
1014     return returnValue;
1015 }
1016
1017 EditFieldHandlePtr TimeSensorBase::editHandleStopTime       (void)
1018 {
1019     SFTime::EditHandlePtr returnValue(
1020         new  SFTime::EditHandle(
1021              &_sfStopTime,
1022              this->getType().getFieldDesc(StopTimeFieldId),
1023              this));
1024
1025
1026     editSField(StopTimeFieldMask);
1027
1028     return returnValue;
1029 }
1030
1031 GetFieldHandlePtr TimeSensorBase::getHandleCycleTime       (void) const
1032 {
1033     SFTime::GetHandlePtr returnValue(
1034         new  SFTime::GetHandle(
1035              &_sfCycleTime,
1036              this->getType().getFieldDesc(CycleTimeFieldId),
1037              const_cast<TimeSensorBase *>(this)));
1038
1039     return returnValue;
1040 }
1041
1042 EditFieldHandlePtr TimeSensorBase::editHandleCycleTime      (void)
1043 {
1044     SFTime::EditHandlePtr returnValue(
1045         new  SFTime::EditHandle(
1046              &_sfCycleTime,
1047              this->getType().getFieldDesc(CycleTimeFieldId),
1048              this));
1049
1050
1051     editSField(CycleTimeFieldMask);
1052
1053     return returnValue;
1054 }
1055
1056 GetFieldHandlePtr TimeSensorBase::getHandleTime            (void) const
1057 {
1058     SFTime::GetHandlePtr returnValue(
1059         new  SFTime::GetHandle(
1060              &_sfTime,
1061              this->getType().getFieldDesc(TimeFieldId),
1062              const_cast<TimeSensorBase *>(this)));
1063
1064     return returnValue;
1065 }
1066
1067 EditFieldHandlePtr TimeSensorBase::editHandleTime           (void)
1068 {
1069     SFTime::EditHandlePtr returnValue(
1070         new  SFTime::EditHandle(
1071              &_sfTime,
1072              this->getType().getFieldDesc(TimeFieldId),
1073              this));
1074
1075
1076     editSField(TimeFieldMask);
1077
1078     return returnValue;
1079 }
1080
1081 GetFieldHandlePtr TimeSensorBase::getHandleCycleInterval   (void) const
1082 {
1083     SFTime::GetHandlePtr returnValue(
1084         new  SFTime::GetHandle(
1085              &_sfCycleInterval,
1086              this->getType().getFieldDesc(CycleIntervalFieldId),
1087              const_cast<TimeSensorBase *>(this)));
1088
1089     return returnValue;
1090 }
1091
1092 EditFieldHandlePtr TimeSensorBase::editHandleCycleInterval  (void)
1093 {
1094     SFTime::EditHandlePtr returnValue(
1095         new  SFTime::EditHandle(
1096              &_sfCycleInterval,
1097              this->getType().getFieldDesc(CycleIntervalFieldId),
1098              this));
1099
1100
1101     editSField(CycleIntervalFieldMask);
1102
1103     return returnValue;
1104 }
1105
1106 GetFieldHandlePtr TimeSensorBase::getHandleChangeFractionBy (void) const
1107 {
1108     SFTime::GetHandlePtr returnValue(
1109         new  SFTime::GetHandle(
1110              &_sfChangeFractionBy,
1111              this->getType().getFieldDesc(ChangeFractionByFieldId),
1112              const_cast<TimeSensorBase *>(this)));
1113
1114     return returnValue;
1115 }
1116
1117 EditFieldHandlePtr TimeSensorBase::editHandleChangeFractionBy(void)
1118 {
1119     SFTime::EditHandlePtr returnValue(
1120         new  SFTime::EditHandle(
1121              &_sfChangeFractionBy,
1122              this->getType().getFieldDesc(ChangeFractionByFieldId),
1123              this));
1124
1125
1126     editSField(ChangeFractionByFieldMask);
1127
1128     return returnValue;
1129 }
1130
1131
1132 #ifdef OSG_MT_CPTR_ASPECT
1133 void TimeSensorBase::execSyncV(      FieldContainer    &oFrom,
1134                                         ConstFieldMaskArg  whichField,
1135                                         AspectOffsetStore &oOffsets,
1136                                         ConstFieldMaskArg  syncMode,
1137                                   const UInt32             uiSyncInfo)
1138 {
1139     TimeSensor *pThis = static_cast<TimeSensor *>(this);
1140
1141     pThis->execSync(static_cast<TimeSensor *>(&oFrom),
1142                     whichField,
1143                     oOffsets,
1144                     syncMode,
1145                     uiSyncInfo);
1146 }
1147 #endif
1148
1149
1150 #ifdef OSG_MT_CPTR_ASPECT
1151 FieldContainer *TimeSensorBase::createAspectCopy(
1152     const FieldContainer *pRefAspect) const
1153 {
1154     TimeSensor *returnValue;
1155
1156     newAspectCopy(returnValue,
1157                   dynamic_cast<const TimeSensor *>(pRefAspect),
1158                   dynamic_cast<const TimeSensor *>(this));
1159
1160     return returnValue;
1161 }
1162 #endif
1163
1164 void TimeSensorBase::resolveLinks(void)
1165 {
1166     Inherited::resolveLinks();
1167
1168
1169 }
1170
1171
1172 OSG_END_NAMESPACE