Source/System/FileIO/Base/OSGSceneFileHandler.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  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 //  Includes
  41 //-------------------------------
  42
  43 #define OSG_COMPILE_SCENEFILEHANDLER
  44
  45 #include <cstdlib>
  46 #include <cstdio>
  47
  48 #include <fstream>
  49
  50 #include "OSGConfig.h"
  51
  52 #include "OSGLog.h"
  53 #include "OSGBaseTypes.h"
  54 #include "OSGPathHandler.h"
  55
  56 #include "OSGGraphOpSeq.h"
  57
  58 #include "OSGImageFileHandler.h"
  59
  60 #include "OSGSceneFileHandler.h"
  61 #include "OSGZStream.h"
  62
  63 #include "OSGNode.h"
  64 #include "OSGThread.h"
  65 #include "OSGThreadManager.h"
  66 #include "OSGBaseFunctions.h"
  67 #include "OSGFileContextAttachment.h"
  68
  69 #include "OSGSingletonHolder.ins"
  70
  71 OSG_BEGIN_NAMESPACE
  72
  73 OSG_SINGLETON_INST(SceneFileHandlerBase, addPostFactoryExitFunction)
  74
  75 template class SingletonHolder<SceneFileHandlerBase>;
  76
  77 GraphOpSeq       *SceneFileHandlerBase::_defaultgraphOpSeq = NULL;
  78
  79 SceneFileType *SceneFileHandlerBase::getFileType(
  80     const Char8 *fileNameOrExtension)
  81 {
  82     const Char8 separator = '.';
  83
  84     if(fileNameOrExtension == NULL)
  85         return NULL;
  86
  87     std::string fe = fileNameOrExtension;
  88
  89     SizeT p = fe.rfind(separator);
  90
  91     std::string ext;
  92
  93     if(p != std::string::npos)
  94     {
  95         ext = fe.substr(p + 1, fe.length() - p - 1);
  96     }
  97     else
  98     {
  99         ext = fe; // extension without '.'
 100     }
 101
 102     // skip .gz extension
 103     if(ext == "gz")
 104     {
 105         fe = fe.substr(0, p);
 106         p  = fe.rfind(separator);
 107
 108         if(p != std::string::npos)
 109         {
 110             ext = fe.substr(p + 1, fe.length() - p - 1);
 111         }
 112         else
 113         {
 114             ext = fe;
 115         }
 116     }
 117
 118     std::string suffix;
 119
 120     suffix.assign (ext.c_str());
 121 //    suffix.toLower(           );
 122     std::transform(suffix.begin(), suffix.end(), suffix.begin(), ::tolower);
 123
 124     FileTypeMap::iterator sI = _suffixTypeMap.find(suffix);
 125
 126     SceneFileType *type =
 127         (sI == _suffixTypeMap.end()) ? 0 : sI->second->front();
 128
 129     return type;
 130 }
 131
 132 //CHECK
 133 #ifdef OSG_WIN32_ICL
 134 #pragma warning (disable : 383)
 135 #endif
 136
 137 Int32 SceneFileHandlerBase::getSuffixList(std::list<const Char8 *> &suffixList,
 138                                           UInt32                    flags)
 139 {
 140     Int32                 count = 0;
 141     FileTypeMap::iterator sI;
 142
 143     suffixList.clear();
 144
 145     for(sI = _suffixTypeMap.begin(); sI != _suffixTypeMap.end(); ++sI)
 146     {
 147         SceneFileType *type = sI->second->front();
 148
 149         if((type->getFlags() & flags) == flags)
 150         {
 151             suffixList.push_back(sI->first.c_str());
 152             count++;
 153         }
 154     }
 155
 156     return count;
 157 }
 158
 159 #ifdef OSG_WIN32_ICL
 160 #pragma warning (default : 383)
 161 #endif
 162
 163
 164 NodeTransitPtr SceneFileHandlerBase::read(
 165           std::istream &is,
 166     const Char8        *fileNameOrExtension,
 167           GraphOpSeq   *graphOpSeq         ,
 168           Resolver      resolver           )
 169 {
 170     SceneFileType *type  = getFileType(fileNameOrExtension);
 171     NodeUnrecPtr   scene = NULL;
 172
 173     if(!fileNameOrExtension)
 174     {
 175         SWARNING << "cannot read NULL extension" << std::endl;
 176         return NodeTransitPtr(scene);
 177     }
 178
 179     if(type != NULL)
 180     {
 181         SINFO << "try to read stream as " << type->getName() << std::endl;
 182
 183         // check for fileio read callback
 184         if(_readFP != NULL)
 185         {
 186             initReadProgress(is);
 187             scene = _readFP(type, is, fileNameOrExtension);
 188             terminateReadProgress();
 189         }
 190         else
 191         {
 192             if(isGZip(is))
 193             {
 194                 SINFO << "Detected gzip compressed stream." << std::endl;
 195
 196 #ifdef OSG_WITH_ZLIB
 197
 198                 initReadProgress(is);
 199
 200                 zip_istream unzipper(is);
 201
 202                 scene = type->read(unzipper,
 203                                    fileNameOrExtension,
 204                                    resolver ? resolver : _oGlobalResolver);
 205
 206                 if(scene != NULL)
 207                 {
 208                     if(unzipper.check_crc() == true)
 209                     {
 210                         SINFO << "Compressed stream has correct checksum."
 211                               << std::endl;
 212                     }
 213                     else
 214                     {
 215                         SWARNING << "Compressed stream has wrong checksum."
 216                                  << std::endl;
 217                     }
 218                 }
 219                 terminateReadProgress();
 220 #else
 221                 SFATAL << "Compressed streams are not supported! Configure "
 222                        << "with --enable-png --with-png=DIR options."
 223                        << std::endl;
 224 #endif
 225             }
 226             else
 227             {
 228                 initReadProgress(is);
 229
 230                 scene = type->read(is,
 231                                    fileNameOrExtension,
 232                                    resolver  ? resolver : _oGlobalResolver);
 233
 234                 terminateReadProgress();
 235             }
 236         }
 237
 238         if(scene != NULL)
 239         {
 240             if(graphOpSeq != NULL)
 241                 graphOpSeq->traverse(scene);
 242
 243             SINFO    << "read ok:"        << std::endl;
 244         }
 245         else
 246         {
 247             SWARNING << "could not read " << std::endl;
 248         }
 249     }
 250     else
 251     {
 252         SWARNING << "could not read unknown file format" << std::endl;
 253     }
 254
 255     commitChanges();
 256
 257     return NodeTransitPtr(scene);
 258 }
 259
 260
 261 NodeTransitPtr SceneFileHandlerBase::read(const Char8      *fileName,
 262                                                 GraphOpSeq *graphOpSeq,
 263                                                 Resolver    resolver,
 264                                                 bool        bWarnNotFound )
 265 {
 266     NodeTransitPtr returnValue(NULL);
 267
 268     if(fileName == NULL)
 269     {
 270         SWARNING << "cannot read NULL file" << std::endl;
 271         return NodeTransitPtr(NULL);
 272     }
 273
 274     std::string fullFilePath = initPathHandler(fileName);
 275
 276     if(fullFilePath.empty() == true)
 277     {
 278         if(_readFP != NULL)
 279         {
 280             // that's a fallback could be a url so the callback
 281             // can handle this correctly.
 282             SceneFileType *type = getFileType(fileName);
 283             if(type != NULL)
 284             {
 285                 // create a dummy stream with the bad flag set.
 286                 std::ifstream in;
 287                 in.setstate(std::ios::badbit);
 288                 returnValue = _readFP(type, in, fileName);
 289             }
 290             else
 291             {
 292                 if(bWarnNotFound == true)
 293                     SWARNING << "Couldn't open file " << fileName << std::endl;
 294             }
 295         }
 296         else
 297         {
 298             if(bWarnNotFound == true)
 299                 SWARNING << "Couldn't open file " << fileName << std::endl;
 300         }
 301
 302         commitChanges();
 303
 304         return returnValue;
 305     }
 306
 307
 308     SceneFileType *type  = getFileType(fullFilePath.c_str());
 309     NodeUnrecPtr   scene = NULL;
 310
 311     if(type != NULL)
 312     {
 313         triggerReadBegin(fullFilePath.c_str());
 314         updateReadProgress(0);
 315
 316         SINFO << "try to read " << fullFilePath
 317               << " as "         << type->getName() << std::endl;
 318
 319         std::ifstream in(fullFilePath.c_str(), std::ios::binary);
 320
 321         if(in)
 322         {
 323             scene = read(in, fullFilePath.c_str(), graphOpSeq);
 324
 325             in.close();
 326
 327             if(scene != NULL)
 328             {
 329                 triggerReadEnd(fullFilePath.c_str());
 330
 331                 FileContextAttachmentUnrecPtr pFContext =
 332                     dynamic_cast<FileContextAttachment *>(
 333                         scene->findAttachment(
 334                             FileContextAttachment::getClassGroupId()));
 335
 336                 if(pFContext == NULL)
 337                 {
 338                     pFContext = FileContextAttachment::create();
 339
 340                     pFContext->setResolvedName(fullFilePath);
 341
 342                     scene->addAttachment(pFContext);
 343                 }
 344             }
 345         }
 346         else
 347         {
 348             if(bWarnNotFound == true)
 349             {
 350                 SWARNING << "Couldn't open input stream for file "
 351                          << fullFilePath
 352                          << std::endl;
 353             }
 354         }
 355
 356 #ifndef OSG_DISABLE_DEPRECATED
 357
 358         // Ok stream interface didn't work try via filename
 359         if(scene == NULL)
 360             scene = type->readFile(fullFilePath.c_str());
 361
 362         if(scene != NULL)
 363         {
 364             if(graphOpSeq != NULL)
 365                 graphOpSeq->run(scene);
 366
 367             SINFO    << "read ok:"        << std::endl;
 368         }
 369         else
 370         {
 371             if(bWarnNotFound == true)
 372                 SWARNING << "could not read " << std::endl;
 373         }
 374 #endif
 375
 376 #if 0
 377         if(scene != NULL && graphOpSeq != NULL)
 378         {
 379             SINFO    << "Running GraphOps..." << std::endl;
 380             graphOpSeq->run(scene);
 381         }
 382 #endif
 383     }
 384     else
 385     {
 386         if(bWarnNotFound == true)
 387         {
 388             SWARNING << "could not read "       << fullFilePath
 389                      << "; unknown file format" << std::endl;
 390         }
 391     }
 392
 393     commitChanges();
 394
 395     return NodeTransitPtr(scene);
 396 }
 397
 398
 399 void SceneFileHandlerBase::setReadCB(FileIOReadCBF fp)
 400 {
 401     _readFP = fp;
 402 }
 403
 404 SceneFileHandlerBase::FileIOReadCBF SceneFileHandlerBase::getReadCB(void)
 405 {
 406     return _readFP;
 407 }
 408
 409 bool SceneFileHandlerBase::write(Node         * const  node,
 410                                  std::ostream         &os,
 411                                  Char8          const *fileNameOrExtension,
 412                                  bool                  compress           )
 413 {
 414     bool           retCode = false;
 415     SceneFileType *type    = getFileType(fileNameOrExtension);
 416
 417     if(type != NULL)
 418     {
 419         updateWriteProgress(0);
 420
 421         SINFO << "try to write stream as " << type->getName() << std::endl;
 422
 423         if(_writeFP != NULL)
 424         {
 425             retCode = _writeFP(type, node, os, fileNameOrExtension, compress);
 426         }
 427         else
 428         {
 429             if(compress == true)
 430             {
 431 #ifdef OSG_WITH_ZLIB
 432                 SINFO << "writing compressed stream." << std::endl;
 433
 434                 zip_ostream zipper(os, true);
 435
 436                 retCode = type->write(node, zipper, fileNameOrExtension);
 437
 438                 zipper.zflush();
 439 #else
 440                 SFATAL << "Compressed streams are not supported! Build "
 441                        << "with zlib= options."
 442                        << std::endl;
 443 #endif
 444             }
 445             else
 446             {
 447                 retCode = type->write(node, os, fileNameOrExtension);
 448             }
 449         }
 450     }
 451     else
 452     {
 453         SWARNING << "can't write stream unknown scene format" << std::endl;
 454     }
 455
 456     return retCode;
 457 }
 458
 459 bool SceneFileHandlerBase::write(Node  * const  node,
 460                                  Char8   const *fileName,
 461                                  bool           compress)
 462 {
 463     bool           retCode = false;
 464     SceneFileType *type    = getFileType(fileName);
 465
 466     if(type != NULL)
 467     {
 468         updateWriteProgress(0);
 469         triggerWriteBegin(fileName);
 470
 471         SINFO << "try to write "
 472               << fileName
 473               << " as "
 474               << type->getName()
 475               << std::endl;
 476
 477         std::ofstream out(fileName, std::ios::binary);
 478
 479         if(out)
 480         {
 481             retCode = write(node, out, fileName, compress);
 482             out.close();
 483         }
 484         else
 485         {
 486             SWARNING << "Can not open output stream for file '"
 487                      << fileName
 488                      << "'!"
 489                      << std::endl;
 490         }
 491
 492 #ifndef OSG_DISABLE_DEPRECATED
 493         if(!retCode)
 494         {
 495             retCode = type->writeFile(node, fileName);
 496         }
 497 #endif
 498
 499         if(!retCode)
 500         {
 501             SWARNING << "Couldn't write " << fileName << std::endl;
 502         }
 503         else
 504         {
 505             triggerWriteEnd(fileName);
 506         }
 507     }
 508     else
 509         SWARNING << "can't write "
 510                  << fileName
 511                  << "; unknown scene format"
 512                  << std::endl;
 513
 514     return retCode;
 515 }
 516
 517 void SceneFileHandlerBase::setWriteCB(FileIOWriteCBF fp)
 518 {
 519     _writeFP = fp;
 520 }
 521
 522 SceneFileHandlerBase::FileIOWriteCBF SceneFileHandlerBase::getWriteCB(void)
 523 {
 524     return _writeFP;
 525 }
 526
 527 PathHandler *SceneFileHandlerBase::getPathHandler(void)
 528 {
 529     if(_pathHandler == NULL)
 530     {
 531         return &_defaultPathHandler;
 532     }
 533     else
 534     {
 535         return _pathHandler;
 536     }
 537 }
 538
 539 void SceneFileHandlerBase::setPathHandler(PathHandler *pathHandler)
 540 {
 541     _pathHandler = pathHandler;
 542 }
 543
 544 SceneFileHandlerBase::Resolver
 545     SceneFileHandlerBase::getGlobalResolver(void) const
 546 {
 547     return _oGlobalResolver;
 548 }
 549
 550 void SceneFileHandlerBase::setGlobalResolver(Resolver oResolver)
 551 {
 552     _oGlobalResolver = oResolver;
 553 }
 554
 555 std::string SceneFileHandlerBase::initPathHandler(const Char8 *fileName)
 556 {
 557     std::string fullFilePath;
 558
 559     if(_pathHandler != NULL)
 560     {
 561         // Set also a image path handler if not set.
 562
 563         if(ImageFileHandler::the()->getPathHandler() == NULL)
 564         {
 565             ImageFileHandler::the()->setPathHandler(_pathHandler);
 566         }
 567
 568         fullFilePath = _pathHandler->findFile(fileName);
 569     }
 570     else
 571     {
 572         // Set a default image path handler if not set.
 573         if(ImageFileHandler::the()->getPathHandler() == NULL)
 574         {
 575             ImageFileHandler::the()->setPathHandler(&_defaultPathHandler);
 576         }
 577
 578         _defaultPathHandler.clearPathList();
 579         _defaultPathHandler.clearBaseFile();
 580
 581         _defaultPathHandler.push_frontCurrentDir(        );
 582
 583         fullFilePath = _defaultPathHandler.findFile(fileName);
 584
 585         _defaultPathHandler.setBaseFile(fullFilePath.c_str());
 586     }
 587
 588     return fullFilePath;
 589 }
 590
 591 GraphOpSeq *SceneFileHandlerBase::getDefaultGraphOp(void)
 592 {
 593     return _defaultgraphOpSeq;
 594 }
 595
 596 void SceneFileHandlerBase::setDefaultGraphOp(GraphOpSeq *graphOpSeq)
 597 {
 598     setRefd(_defaultgraphOpSeq, graphOpSeq);
 599 }
 600
 601 /*-------------------------------------------------------------------------*/
 602 /* Options                                                                 */
 603
 604 /*! Sets the option \a name to \a value for the SceneFileType that handles
 605     files with the given \a suffix.
 606     Returns \c true if the option was set successfully, \c false otherwise.
 607
 608     \param[in] suffix File extension to choose the scene file type
 609                       this option applies to.
 610     \param[in] name Name of the option.
 611     \param[in] value Value of the option.
 612     \return Whether the value was set successfully.
 613  */
 614 bool
 615     SceneFileHandlerBase::setOption(
 616         const std::string &suffix,
 617         const std::string &name,
 618         const std::string &value  )
 619 {
 620     bool           retVal = false;
 621     SceneFileType *type   = getFileType(suffix.c_str());
 622
 623     if(type != NULL)
 624     {
 625         type->setOption(name, value);
 626         retVal = true;
 627     }
 628
 629     return retVal;
 630 }
 631
 632 /*! Removes the option \a name from the ImageFileType that handles files
 633     with the given \a suffix. If the option is not present \c false is
 634     returned, \c true otherwise.
 635
 636     \param[in] suffix File extension to choose the scene file type
 637                       this option applies to.
 638     \param[in] name Name of the option.
 639     \return Whether the option was successfully removed.
 640  */
 641 bool
 642     SceneFileHandlerBase::unsetOption(
 643         const std::string &suffix,
 644         const std::string &name   )
 645 {
 646     bool           retVal = false;
 647     SceneFileType *type   = getFileType(suffix.c_str());
 648
 649     if(type != NULL)
 650     {
 651         retVal = type->unsetOption(name);
 652     }
 653
 654     return retVal;
 655 }
 656
 657 /*! Retrieves the option \a name from the SceneFileType that handles files
 658     with the given \a suffix and stores its value in \a value.
 659     Returns \c true if successful, \c false otherwise in which case \a value has
 660     an undefined value.
 661
 662     \param[in] suffix File extension to choose the scene file type
 663                       this option applies to.
 664     \param[in] name Name of the option.
 665     \param[out] value Value the option.
 666     \return Whether the option is present for the given SceneFileType.
 667  */
 668 bool
 669     SceneFileHandlerBase::getOption(
 670         const std::string &suffix,
 671         const std::string &name,
 672               std::string &value  )
 673 {
 674     bool           retVal = false;
 675     SceneFileType *type   = getFileType(suffix.c_str());
 676
 677     if(type != NULL)
 678     {
 679         retVal = type->getOption(name, value);
 680     }
 681
 682     return retVal;
 683 }
 684
 685 void SceneFileHandlerBase::pushOptions(const std::string &suffix,
 686                                              bool         copyTop)
 687 {
 688     SceneFileType *type   = getFileType(suffix.c_str());
 689
 690     if(type != NULL)
 691     {
 692         type->pushOptions(copyTop);
 693     }
 694 }
 695
 696 void SceneFileHandlerBase::popOptions(const std::string &suffix)
 697 {
 698     SceneFileType *type   = getFileType(suffix.c_str());
 699
 700     if(type != NULL)
 701     {
 702         type->popOptions();
 703     }
 704 }
 705
 706 #if defined(OSG_1_COMPAT)
 707 void SceneFileHandlerBase::setOptions(const std::string &suffix,
 708                                       const std::string &osg1Options)
 709 {
 710 }
 711 #endif
 712
 713 void SceneFileHandlerBase::print (void )
 714 {
 715     FileTypeMap::iterator sI;
 716
 717     for(sI = _suffixTypeMap.begin(); sI != _suffixTypeMap.end(); sI++)
 718     {
 719         std::string    rw;
 720         SceneFileType *type = sI->second->front();
 721
 722         if((type->getFlags() & SceneFileType::OSG_READ_SUPPORTED) &&
 723            (type->getFlags() & SceneFileType::OSG_WRITE_SUPPORTED))
 724         {
 725             rw = "reader and writer";
 726         }
 727         else
 728         {
 729             if(type->getFlags() & SceneFileType::OSG_READ_SUPPORTED)
 730                 rw = "reader";
 731
 732             if(type->getFlags() & SceneFileType::OSG_WRITE_SUPPORTED)
 733                 rw = "writer";
 734         }
 735
 736         std::cerr << "suffix: " << sI->first.c_str()
 737                   << ", type: " << sI->second->front()->getName()
 738                   << " "        << rw
 739                   << std::endl;
 740     }
 741 }
 742
 743 bool SceneFileHandlerBase::FindOverride::operator() (SceneFileType *fileTypeP)
 744 {
 745     if(fileTypeP == NULL)
 746         return false;
 747
 748     if(fileTypeP->doOverride() == false)
 749         return true;
 750
 751     if(fileTypeP->getOverridePriority() <= uiRefPriority)
 752         return true;
 753
 754     return false;
 755 }
 756
 757 //CHECK
 758 #ifdef OSG_WIN32_ICL
 759 #pragma warning (disable : 383)
 760 #endif
 761
 762 bool SceneFileHandlerBase::addSceneFileType(SceneFileType &fileType)
 763 {
 764     bool retCode = false;
 765
 766     std::list<std::string>::iterator sI;
 767          FileTypeMap      ::iterator smI;
 768
 769     std::string suffix;
 770
 771     for(  sI  = fileType.suffixList().begin();
 772           sI != fileType.suffixList().end();
 773         ++sI)
 774     {
 775         suffix.assign (sI->c_str());
 776 //        suffix.toLower();
 777         std::transform(suffix.begin(), suffix.end(), suffix.begin(), ::tolower);
 778
 779         smI = _suffixTypeMap.find(suffix);
 780
 781         if (smI != _suffixTypeMap.end())
 782         {
 783             if(fileType.doOverride() == true)
 784             {
 785                 FindOverride           overrideFinder;
 786                 FileTypeList::iterator lIt;
 787
 788                 overrideFinder.uiRefPriority = fileType.getOverridePriority();
 789
 790                 lIt = std::find_if(_suffixTypeMap[suffix]->begin(),
 791                                    _suffixTypeMap[suffix]->end  (),
 792                                    overrideFinder);
 793
 794                 _suffixTypeMap[suffix]->insert(lIt, &fileType);
 795
 796                 SWARNING << "Added an file type with suffix "
 797                          << suffix
 798                          << " overriding "
 799                          << std::endl;
 800             }
 801             else
 802             {
 803                 _suffixTypeMap[suffix]->push_back(&fileType);
 804
 805                 SWARNING << "Added an file type with suffix "
 806                          << suffix
 807                          << " non overriding at the end of the list"
 808                          << std::endl;
 809             }
 810         }
 811         else
 812         {
 813             FileTypeList *pTmpList = new FileTypeList;
 814
 815             pTmpList->push_back(&fileType);
 816
 817             _suffixTypeMap[suffix] = pTmpList;
 818
 819             retCode = true;
 820         }
 821     }
 822
 823     return retCode;
 824 }
 825
 826 bool SceneFileHandlerBase::subSceneFileType(SceneFileType &fileType)
 827 {
 828     bool retCode = false;
 829
 830     std::list<std::string>::iterator sI;
 831          FileTypeMap      ::iterator smI;
 832
 833     std::string suffix;
 834
 835     for(  sI  = fileType.suffixList().begin();
 836           sI != fileType.suffixList().end();
 837         ++sI)
 838     {
 839         suffix.assign(sI->c_str());
 840         //suffix.toLower();
 841         std::transform(suffix.begin(), suffix.end(), suffix.begin(), ::tolower);
 842         smI = _suffixTypeMap.find(suffix);
 843
 844         if (smI != _suffixTypeMap.end())
 845         {
 846             _suffixTypeMap.erase(smI);
 847             retCode = true;
 848         }
 849     }
 850     return retCode;
 851 }
 852
 853 #ifdef OSG_WIN32_ICL
 854 #pragma warning (default : 383)
 855 #endif
 856
 857
 858 static bool initializeDefaultGraphOps(void)
 859 {
 860     GraphOpSeqRefPtr ops = GraphOpSeq::create();
 861
 862     ops->setGraphOps(
 863             "Stripe() SharePtr(includes=Material,StateChunk)");
 864
 865     SceneFileHandlerBase *the = SceneFileHandler::the();
 866
 867     the->setDefaultGraphOp(ops);
 868
 869     return true;
 870 }
 871
 872 static bool terminateDefaultGraphOps(void)
 873 {
 874     SceneFileHandlerBase *the = SceneFileHandler::the();
 875
 876     the->setDefaultGraphOp(NULL);
 877
 878     return true;
 879 }
 880
 881 SceneFileHandlerBase::SceneFileHandlerBase(void) :
 882     _suffixTypeMap     (              ),
 883     _readProgressFP    (NULL          ),
 884     _readBeginFP       (NULL          ),
 885     _readEndFP         (NULL          ),
 886     _progressData      (              ),
 887     _readReady         (false         ),
 888     _useProgressThread (false         ),
 889     _writeProgressFP   (NULL          ),
 890     _writeBeginFP      (NULL          ),
 891     _writeEndFP        (NULL          ),
 892     _pathHandler       (NULL          ),
 893     _defaultPathHandler(              ),
 894     _readFP            (NULL          ),
 895     _writeFP           (NULL          ),
 896     _oGlobalResolver   (NULL          )
 897 {
 898     _progressData.length = 0;
 899     _progressData.is = NULL;
 900
 901     addPostFactoryInitFunction(initializeDefaultGraphOps);
 902     addPreFactoryExitFunction (terminateDefaultGraphOps );
 903     addPreFactoryExitFunction (terminateSceneFileTypes  );
 904 }
 905
 906 // read progress stuff.
 907
 908 void SceneFileHandlerBase::setReadProgressCB(progresscbfp fp, bool use_thread)
 909 {
 910     if(use_thread)
 911     {
 912         terminateReadProgress();
 913     }
 914     else
 915     {
 916         //check if setReadProgressCB was called before with use_thread enabled.
 917
 918         if(_useProgressThread)
 919             terminateReadProgress();
 920     }
 921
 922     _readProgressFP    = fp;
 923     _useProgressThread = use_thread;
 924 }
 925
 926 SceneFileHandlerBase::progresscbfp
 927     SceneFileHandlerBase::getReadProgressCB(void)
 928 {
 929     return _readProgressFP;
 930 }
 931
 932 void SceneFileHandlerBase::setReadBeginCB(filenamecbfp fp)
 933 {
 934     _readBeginFP = fp;
 935 }
 936
 937 SceneFileHandlerBase::filenamecbfp SceneFileHandlerBase::getReadBeginCB(void)
 938 {
 939     return _readBeginFP;
 940 }
 941
 942 void SceneFileHandlerBase::setReadEndCB(filenamecbfp fp)
 943 {
 944     _readEndFP = fp;
 945 }
 946
 947 SceneFileHandlerBase::filenamecbfp SceneFileHandlerBase::getReadEndCB(void)
 948 {
 949     return _readEndFP;
 950 }
 951
 952 void SceneFileHandlerBase::triggerReadBegin(const Char8 *fname)
 953 {
 954     if(_readBeginFP != NULL)
 955         _readBeginFP(fname);
 956 }
 957
 958 void SceneFileHandlerBase::triggerReadEnd(const Char8 *fname)
 959 {
 960     if(_readEndFP != NULL)
 961         _readEndFP(fname);
 962 }
 963
 964 void SceneFileHandlerBase::initReadProgress(std::istream &is)
 965 {
 966     if(_readProgressFP == NULL)
 967         return;
 968
 969     // get length of the stream.
 970     _progressData.is = &is;
 971     is.seekg(0, std::ios::end);
 972     _progressData.length = is.tellg();
 973     is.seekg(0, std::ios::beg);
 974
 975     _readReady = false;
 976
 977     if(_useProgressThread)
 978     {
 979         _progressData.thread =  Thread::find("OSG::FileIOReadProgressThread");
 980
 981         if(_progressData.thread == NULL)
 982         {
 983             _progressData.thread =
 984                 OSG::Thread::get("OSG::FileIOReadProgressThread", true);
 985         }
 986
 987         if(_progressData.thread != NULL)
 988         {
 989             _progressData.thread->runFunction(readProgress, 0, NULL);
 990         }
 991         else
 992         {
 993             SWARNING << "Couldn't create read progress thread!" << std::endl;
 994         }
 995     }
 996 }
 997
 998 void SceneFileHandlerBase::terminateReadProgress(void)
 999 {
1000     if(_readProgressFP == NULL)
1001         return;
1002
1003     _readReady = true;
1004
1005     if(_progressData.thread != NULL)
1006     {
1007         // terminate thread
1008         Thread::join(_progressData.thread);
1009         _progressData.thread = NULL;
1010     }
1011
1012     _progressData.length = 0;
1013     _progressData.is     = NULL;
1014 }
1015
1016 void SceneFileHandlerBase::readProgress(void * OSG_CHECK_ARG(data))
1017 {
1018     SceneFileHandlerBase *the = SceneFileHandler::the();
1019
1020     if(the->_readProgressFP == NULL || the->_progressData.is == NULL)
1021         return;
1022
1023     UInt32 p = 0;
1024
1025     while(p < 100 && !the->_readReady)
1026     {
1027         if(!the->_progressData.is->eof() &&
1028            !the->_progressData.is->bad())
1029         {
1030             UInt64 pos = the->_progressData.is->tellg();
1031             p = UInt32((pos * 100) / the->_progressData.length);
1032             if(p > 100)
1033                 p = 100;
1034         }
1035         else
1036         {
1037             p = 100;
1038         }
1039
1040         the->_readProgressFP(p);
1041
1042         if(the->_useProgressThread)
1043         {
1044             osgSleep(100);
1045         }
1046         else
1047         {
1048             break;
1049         }
1050     }
1051
1052     if(the->_useProgressThread && p < 100)
1053     {
1054         the->_readProgressFP(100);
1055     }
1056 }
1057
1058 void SceneFileHandlerBase::updateReadProgress(void)
1059 {
1060     if(_readProgressFP == NULL)
1061         return;
1062
1063     if(_useProgressThread)
1064         return;
1065
1066     readProgress(NULL);
1067 }
1068
1069 void SceneFileHandlerBase::updateReadProgress(UInt32 p)
1070 {
1071     if(_readProgressFP == NULL)
1072         return;
1073
1074     _readProgressFP(p);
1075 }
1076
1077 // write progress stuff.
1078
1079 void SceneFileHandlerBase::setWriteProgressCB(progresscbfp fp)
1080 {
1081     _writeProgressFP = fp;
1082 }
1083
1084 SceneFileHandlerBase::progresscbfp
1085     SceneFileHandlerBase::getWriteProgressCB(void)
1086 {
1087     return _writeProgressFP;
1088 }
1089
1090 void SceneFileHandlerBase::setWriteBeginCB(filenamecbfp fp)
1091 {
1092     _writeBeginFP = fp;
1093 }
1094
1095 SceneFileHandlerBase::filenamecbfp SceneFileHandlerBase::getWriteBeginCB(void)
1096 {
1097     return _writeBeginFP;
1098 }
1099
1100 void SceneFileHandlerBase::setWriteEndCB(filenamecbfp fp)
1101 {
1102     _writeEndFP = fp;
1103 }
1104
1105 SceneFileHandlerBase::filenamecbfp SceneFileHandlerBase::getWriteEndCB(void)
1106 {
1107     return _writeEndFP;
1108 }
1109
1110 void SceneFileHandlerBase::triggerWriteBegin(const Char8 *fname)
1111 {
1112     if(_writeBeginFP != NULL)
1113         _writeBeginFP(fname);
1114 }
1115
1116 void SceneFileHandlerBase::triggerWriteEnd(const Char8 *fname)
1117 {
1118     if(_writeEndFP != NULL)
1119         _writeEndFP(fname);
1120 }
1121
1122 void SceneFileHandlerBase::updateWriteProgress(UInt32 p)
1123 {
1124     if(_writeProgressFP == NULL)
1125         return;
1126
1127     _writeProgressFP(p);
1128 }
1129
1130 SceneFileHandlerBase::~SceneFileHandlerBase(void)
1131 {
1132     FileTypeMap::iterator smIt  = _suffixTypeMap.begin();
1133     FileTypeMap::iterator smEnd = _suffixTypeMap.end  ();
1134
1135     while(smIt != smEnd)
1136     {
1137         delete (*smIt).second;
1138         ++smIt;
1139     }
1140
1141     _suffixTypeMap.clear();
1142 }
1143
1144 bool SceneFileHandlerBase::doTerminateSceneFileTypes(void)
1145 {
1146     FileTypeMap ::iterator sI;
1147     FileTypeList::iterator lI;
1148
1149     for(sI = _suffixTypeMap.begin(); sI != _suffixTypeMap.end(); ++sI)
1150     {
1151         for(lI = sI->second->begin(); lI != sI->second->end(); ++lI)
1152         {
1153             (*lI)->terminate();
1154         }
1155     }
1156
1157     return true;
1158 }
1159
1160 bool SceneFileHandlerBase::terminateSceneFileTypes(void)
1161 {
1162     return SceneFileHandler::the()->doTerminateSceneFileTypes();
1163 }
1164
1165
1166 OSG_END_NAMESPACE