src/VISU_I/VISU_TimeAnimation.cxx

   1 //  Copyright (C) 2003  CEA/DEN, EDF R&D
   2 //
   3 //
   4 //
   5 //  File   : VISU_TimeAnimation.cxx
   6 //  Author : Vitaly SMETANNIKOV
   7 //  Module : VISU
   8
   9 #include "VISU_TimeAnimation.h"
  10
  11 #include "VISUConfig.hh"
  12
  13 #include "VISU_Result_i.hh"
  14 #include "VISU_Prs3d_i.hh"
  15 #include "VISU_Mesh_i.hh"
  16 #include "VISU_ScalarMap_i.hh"
  17 #include "VISU_IsoSurfaces_i.hh"
  18 #include "VISU_DeformedShape_i.hh"
  19 #include "VISU_CutPlanes_i.hh"
  20 #include "VISU_CutLines_i.hh"
  21 #include "VISU_Vectors_i.hh"
  22 #include "VISU_StreamLines_i.hh"
  23 #include "VISU_ViewManager_i.hh"
  24 #include "VISU_View_i.hh"
  25
  26 #include "VISU_ScalarBarActor.hxx"
  27 #include "VISU_Actor.h"
  28
  29 #include "SalomeApp_Study.h"
  30
  31 #include "SVTK_ViewWindow.h"
  32
  33 #include "SALOME_Event.hxx"
  34
  35 #include "SUIT_ResourceMgr.h"
  36 #include "SUIT_Application.h"
  37 #include "SUIT_Session.h"
  38 #include "SUIT_Study.h"
  39
  40 #include "SALOMEDSClient_AttributeComment.hxx"
  41 #include "SALOMEDSClient_AttributeName.hxx"
  42
  43 #include <qpixmap.h>
  44
  45 using namespace std;
  46
  47
  48 //************************************************************************
  49 VISU_TimeAnimation::VISU_TimeAnimation (_PTR(Study) theStudy,
  50                                         VISU::View3D_ptr theView3D)
  51 {
  52   myStudy = theStudy;
  53   myIsActive = false;
  54   myFrame = 0;
  55   mySpeed = 1;
  56   myProportional = false;
  57   myView = 0;
  58
  59   if (!CORBA::is_nil(theView3D)) {
  60     VISU::View3D_i* pView = dynamic_cast<VISU::View3D_i*>(GetServant(theView3D).in());
  61     //QAD_StudyFrame* aStudyFrame = pView->GetStudyFrame();
  62     //myView = VISU::GetViewFrame(aStudyFrame);
  63     SUIT_ViewWindow* aVW = pView->myViewWindow;
  64     myView = VISU::GetViewWindow(aVW);
  65   }
  66
  67   myMaxVal = 0;
  68   myMinVal = 0;
  69   myTimeMin = 0;
  70   myTimeMax = 0;
  71   myLastError = "";
  72   myCycling = false;
  73 }
  74
  75
  76 //************************************************************************
  77 VISU_TimeAnimation::~VISU_TimeAnimation()
  78 {
  79   for (int i = 0; i < getNbFields(); i++) {
  80     clearData(myFieldsLst[i]);
  81   }
  82 }
  83
  84
  85 //************************************************************************
  86 //void VISU_TimeAnimation::addField (SALOMEDS::SObject_ptr theField)
  87 void VISU_TimeAnimation::addField (_PTR(SObject) theField)
  88 {
  89   FieldData aNewData;
  90   //aNewData.myField = SALOMEDS::SObject::_duplicate(theField);
  91   aNewData.myField = theField;
  92   aNewData.myNbFrames = 0;
  93   aNewData.myPrsType = VISU::TSCALARMAP;
  94   VISU::Storable::TRestoringMap aMap = getMapOfValue(aNewData.myField);
  95   aNewData.myNbTimes = VISU::Storable::FindValue(aMap,"myNbTimeStamps").toLong();
  96   myFieldsLst.append(aNewData);
  97
  98   //find Min/Max timestamps
  99   if ((myTimeMin == 0) && (myTimeMax == 0)) {
 100     _PTR(ChildIterator) anIter = myStudy->NewChildIterator(theField);
 101     anIter->Next(); // First is reference on support
 102     myTimeMin = getTimeValue(anIter->Value());
 103     for(; anIter->More(); anIter->Next()) {
 104       myTimeMax = getTimeValue(anIter->Value());
 105     }
 106   }
 107 }
 108
 109 //************************************************************************
 110 void VISU_TimeAnimation::addField (SALOMEDS::SObject_ptr theField)
 111 {
 112   FieldData aNewData;
 113   //aNewData.myField = SALOMEDS::SObject::_duplicate(theField);
 114   _PTR(SObject) aField = VISU::GetClientSObject(theField, myStudy);
 115   aNewData.myField = aField;
 116   aNewData.myNbFrames = 0;
 117   aNewData.myPrsType = VISU::TSCALARMAP;
 118   VISU::Storable::TRestoringMap aMap = getMapOfValue(aNewData.myField);
 119   aNewData.myNbTimes = VISU::Storable::FindValue(aMap,"myNbTimeStamps").toLong();
 120   myFieldsLst.append(aNewData);
 121
 122   //find Min/Max timestamps
 123   if ((myTimeMin == 0) && (myTimeMax == 0)) {
 124     _PTR(ChildIterator) anIter = myStudy->NewChildIterator(aField);
 125     anIter->Next(); // First is reference on support
 126     myTimeMin = getTimeValue(anIter->Value());
 127     for(; anIter->More(); anIter->Next()) {
 128       myTimeMax = getTimeValue(anIter->Value());
 129     }
 130   }
 131 }
 132
 133
 134 //************************************************************************
 135 void VISU_TimeAnimation::clearData(FieldData& theData) {
 136   theData.myTiming.clear();
 137   vtkRenderer* aRen = myView->getRenderer();
 138   if (!theData.myActors.empty()) {
 139     for (int i = 0, iEnd = theData.myActors.size(); i < iEnd; i++) {
 140       if (theData.myActors[i] != 0) {
 141         theData.myActors[i]->RemoveFromRender(aRen);
 142         theData.myActors[i]->Delete();
 143       }
 144     }
 145     theData.myActors.clear();
 146   }
 147   if (!theData.myPrs.empty()) {
 148     for (int i = 0, iEnd = theData.myPrs.size(); i < iEnd; i++)
 149       if (theData.myPrs[i] != 0) {
 150         theData.myPrs[i]->_remove_ref();
 151       }
 152     theData.myPrs.clear();
 153   }
 154   theData.myNbFrames = 0;
 155   myView->update();
 156 }
 157
 158
 159 //************************************************************************
 160 void VISU_TimeAnimation::generatePresentations(CORBA::Long theFieldNum) {
 161   FieldData& aData = myFieldsLst[theFieldNum];
 162
 163   // Delete previous presentations
 164   clearData(aData);
 165
 166   VISU::Result_i* pResult = createPresent(aData.myField);
 167   VISU::Storable::TRestoringMap aMap = getMapOfValue(aData.myField);
 168   aData.myNbFrames = aData.myNbTimes;
 169     //VISU::Storable::FindValue(aMap,"myNbTimeStamps").toLong();
 170
 171   aData.myPrs.resize(aData.myNbTimes,NULL);
 172   aData.myTiming.resize(aData.myNbTimes);
 173
 174   _PTR(ChildIterator) anIter = myStudy->NewChildIterator(aData.myField);
 175   _PTR(SObject) aTimeStamp;
 176   anIter->Next(); // First is reference on support
 177   long i = 0;
 178   double aMin = VTK_LARGE_FLOAT, aMax = -VTK_LARGE_FLOAT;
 179   for (; anIter->More(); anIter->Next()) {
 180     if (i == aData.myNbTimes) {
 181       MESSAGE("There are extra timestamps in field");
 182       return;
 183     }
 184     aTimeStamp = anIter->Value();
 185     if (!aTimeStamp) continue;
 186
 187     aData.myTiming[i] = getTimeValue(aTimeStamp);
 188     if (isRangeDefined()) {
 189       if (aData.myTiming[i] < myMinVal) continue;
 190       if (aData.myTiming[i] > myMaxVal) break;
 191     }
 192
 193     VISU::Storable::TRestoringMap aTimeMap = getMapOfValue(aTimeStamp);
 194     QString aMeshName = VISU::Storable::FindValue(aTimeMap,"myMeshName");
 195     VISU::Entity anEntity = (VISU::Entity) VISU::Storable::FindValue(aTimeMap,"myEntityId").toInt();
 196     QString aFieldName = VISU::Storable::FindValue(aTimeMap,"myFieldName");
 197     int aTimeStampId = VISU::Storable::FindValue(aTimeMap,"myTimeStampId").toInt();
 198
 199     switch (aData.myPrsType) {
 200     case VISU::TSCALARMAP: // ScalarMap
 201       {
 202         VISU::ScalarMap_i* aPresent = new VISU::ScalarMap_i(pResult, false);
 203         aPresent->Create(aMeshName.latin1(), anEntity,
 204                          aFieldName.latin1(), aTimeStampId);
 205         //VISU::ScalarMap_var aTmp = aPresent->_this();
 206         //aPresent->_remove_ref();
 207         aData.myPrs[i] = aPresent;
 208       }
 209       break;
 210
 211     case VISU::TISOSURFACE: // Iso Surfaces
 212       {
 213         VISU::IsoSurfaces_i* aPresent = new VISU::IsoSurfaces_i(pResult, false);
 214         aPresent->Create(aMeshName.latin1(), anEntity,
 215                          aFieldName.latin1(), aTimeStampId);
 216         //VISU::IsoSurfaces_var aTmp = aPresent->_this();
 217         //aPresent->_remove_ref();
 218         aData.myPrs[i] = aPresent;
 219       }
 220       break;
 221
 222     case VISU::TCUTPLANES: // Cut Planes
 223       {
 224         VISU::CutPlanes_i* aPresent = new VISU::CutPlanes_i(pResult, false);
 225         aPresent->Create(aMeshName.latin1(), anEntity,
 226                          aFieldName.latin1(), aTimeStampId);
 227         //VISU::CutPlanes_var aTmp = aPresent->_this();
 228         //aPresent->_remove_ref();
 229         aData.myPrs[i] = aPresent;
 230       }
 231       break;
 232
 233     case VISU::TDEFORMEDSHAPE: // Deformed Shape
 234       {
 235         VISU::DeformedShape_i* aPresent = new VISU::DeformedShape_i(pResult, false);
 236         aPresent->Create(aMeshName.latin1(), anEntity,
 237                          aFieldName.latin1(), aTimeStampId);
 238         //VISU::DeformedShape_var aTmp = aPresent->_this();
 239         //aPresent->_remove_ref();
 240         aData.myPrs[i] = aPresent;
 241       }
 242       break;
 243
 244     case VISU::TVECTORS: // Vectors
 245       {
 246         VISU::Vectors_i* aPresent = new VISU::Vectors_i(pResult, false);
 247         aPresent->Create(aMeshName.latin1(), anEntity,
 248                          aFieldName.latin1(), aTimeStampId);
 249         //VISU::Vectors_var aTmp = aPresent->_this();
 250         //aPresent->_remove_ref();
 251         aData.myPrs[i] = aPresent;
 252       }
 253       break;
 254
 255     case VISU::TSTREAMLINES: // Stream Lines
 256       {
 257         VISU::StreamLines_i* aPresent = new VISU::StreamLines_i(pResult, false);
 258         aPresent->Create(aMeshName.latin1(), anEntity,
 259                          aFieldName.latin1(), aTimeStampId);
 260         //VISU::StreamLines_var aTmp = aPresent->_this();
 261         //aPresent->_remove_ref();
 262         aData.myPrs[i] = aPresent;
 263       }
 264       break;
 265     }
 266     if (aData.myPrs[i]->GetMin() < aMin) aMin = aData.myPrs[i]->GetMin();
 267     if (aData.myPrs[i]->GetMax() > aMax) aMax = aData.myPrs[i]->GetMax();
 268     i++;
 269   }
 270   aData.myNbFrames = i;
 271   QString aFixRange = VISU::GetResourceMgr()->stringValue("Visu:SBImposeRange");
 272   if (aFixRange.compare("true") != 0) {
 273     for (i = 0; i < aData.myNbFrames; i++)
 274       aData.myPrs[i]->SetRange(aMin, aMax);
 275     if(aData.myPrsType == VISU::TISOSURFACE)
 276       for (i = 0; i < aData.myNbFrames; i++)
 277         if(VISU::IsoSurfaces_i* aPrs = dynamic_cast<VISU::IsoSurfaces_i*>(aData.myPrs[i]))
 278            aPrs->SetSubRange(aMin, aMax);
 279   }
 280 }
 281
 282
 283 //************************************************************************
 284 CORBA::Boolean VISU_TimeAnimation::generateFrames() {
 285   if (!myView) {
 286     MESSAGE("Viewer is nod defined for animation");
 287     return false;
 288   }
 289
 290   myLastError = QString("Frame(s) for ");
 291   bool aNoError = true;
 292
 293   clearView();
 294
 295   for (int i = 0; i < getNbFields(); i++) {
 296     FieldData& aData = myFieldsLst[i];
 297     aData.myActors.resize(aData.myNbFrames,NULL);
 298     for (long j = 0; j < aData.myNbFrames; j++) {
 299       VISU_Actor* aActor = NULL;
 300       try{
 301         aActor = aData.myPrs[j]->CreateActor();
 302         myView->AddActor(aActor);
 303         if(j == 0)
 304           aActor->VisibilityOn();
 305         else
 306           aActor->VisibilityOff();
 307       }catch(...){ //catch(std::runtime_error& exc){
 308         aNoError = false;
 309         myLastError += QString("%1 ").arg(aData.myTiming[j]);
 310       }
 311       aData.myActors[j] = aActor;
 312     }
 313   }
 314   myFrame = 0;
 315   myLastError += QString(" timestamp(s) cannot be created.");
 316   emit frameChanged(myFrame, myFieldsLst[0].myTiming[myFrame]);
 317   myView->Repaint();
 318   return aNoError;
 319 }
 320
 321 //************************************************************************
 322 void VISU_TimeAnimation::clearView() {
 323   if (!myView) {
 324     MESSAGE("Viewer is nod defined for animation");
 325     return;
 326   }
 327   vtkRenderer* aRen = myView->getRenderer();
 328   for (int i = 0; i < getNbFields(); i++) {
 329     FieldData& aData = myFieldsLst[i];
 330     if (!aData.myActors.empty()) {
 331       for (int i = 0, iEnd = aData.myActors.size(); i < iEnd; i++) {
 332         if (aData.myActors[i] != 0) {
 333           aData.myActors[i]->RemoveFromRender(aRen);
 334           aData.myActors[i]->Delete();
 335         }
 336       }
 337       aData.myActors.clear();
 338     }
 339   }
 340   VISU::RepaintView(myView);
 341 }
 342
 343 //************************************************************************
 344 void VISU_TimeAnimation::stopAnimation() {
 345   myIsActive = false;
 346 }
 347
 348 //************************************************************************
 349 void VISU_TimeAnimation::startAnimation() {
 350   if (!myIsActive) {
 351     myIsActive = true;
 352     QThread::start();
 353   }
 354 }
 355
 356 //************************************************************************
 357 void VISU_TimeAnimation::nextFrame() {
 358   stopAnimation();
 359   if (myFrame < (myFieldsLst[0].myNbFrames-1)) {
 360     int i;
 361     for (i = 0; i < getNbFields(); i++)
 362       if (myFieldsLst[i].myActors[myFrame] != 0)
 363         myFieldsLst[i].myActors[myFrame]->VisibilityOff();
 364
 365     myFrame++;
 366     for (i = 0; i < getNbFields(); i++)
 367       if (myFieldsLst[i].myActors[myFrame] != 0)
 368         myFieldsLst[i].myActors[myFrame]->VisibilityOn();
 369
 370     emit frameChanged(myFrame, myFieldsLst[0].myTiming[myFrame]);
 371     myView->Repaint();
 372   }
 373 }
 374
 375 //************************************************************************
 376 void VISU_TimeAnimation::prevFrame() {
 377   stopAnimation();
 378   if (myFrame > 0) {
 379     int i;
 380     for (i = 0; i < getNbFields(); i++)
 381       if (myFieldsLst[i].myActors[myFrame] != 0)
 382         myFieldsLst[i].myActors[myFrame]->VisibilityOff();
 383
 384     myFrame--;
 385     for (i = 0; i < getNbFields(); i++)
 386       if (myFieldsLst[i].myActors[myFrame] != 0)
 387         myFieldsLst[i].myActors[myFrame]->VisibilityOn();
 388
 389     emit frameChanged(myFrame, myFieldsLst[0].myTiming[myFrame]);
 390     myView->Repaint();
 391   }
 392 }
 393
 394 //************************************************************************
 395 void VISU_TimeAnimation::firstFrame() {
 396   stopAnimation();
 397   int i;
 398   for (i = 0; i < getNbFields(); i++)
 399     if(!myFieldsLst[i].myActors.empty())
 400       if (myFieldsLst[i].myActors[myFrame] != 0)
 401         myFieldsLst[i].myActors[myFrame]->VisibilityOff();
 402   myFrame = 0;
 403   for (i = 0; i < getNbFields(); i++)
 404     if(!myFieldsLst[i].myActors.empty())
 405       if (myFieldsLst[i].myActors[myFrame] != 0)
 406         myFieldsLst[i].myActors[myFrame]->VisibilityOn();
 407   if(!myFieldsLst[0].myTiming.empty()){
 408     emit frameChanged(myFrame, myFieldsLst[0].myTiming[myFrame]);
 409     myView->Repaint();
 410   }
 411 }
 412
 413 //************************************************************************
 414 void VISU_TimeAnimation::lastFrame() {
 415   stopAnimation();
 416   int i;
 417   for (i = 0; i < getNbFields(); i++)
 418    if (myFieldsLst[i].myActors[myFrame] != 0)
 419       myFieldsLst[i].myActors[myFrame]->VisibilityOff();
 420
 421   myFrame = myFieldsLst[0].myNbFrames-1;
 422   for (i = 0; i < getNbFields(); i++)
 423     if (myFieldsLst[i].myActors[myFrame] != 0)
 424       myFieldsLst[i].myActors[myFrame]->VisibilityOn();
 425
 426   emit frameChanged(myFrame, myFieldsLst[0].myTiming[myFrame]);
 427   myView->Repaint();
 428 }
 429
 430
 431 //************************************************************************
 432 // For Batchmode using
 433 void VISU_TimeAnimation::gotoFrame(CORBA::Long theFrame) {
 434   if ((theFrame < 0) || (theFrame > (getNbFrames()-1)))
 435     return;
 436   stopAnimation();
 437   qApp->lock();
 438   qApp->syncX();
 439   int i;
 440   for (i = 0; i < getNbFields(); i++)
 441     if (myFieldsLst[i].myActors[myFrame] != 0)
 442       myFieldsLst[i].myActors[myFrame]->VisibilityOff();
 443
 444   myFrame = theFrame;
 445   for (i = 0; i < getNbFields(); i++)
 446     if (myFieldsLst[i].myActors[myFrame] != 0)
 447       myFieldsLst[i].myActors[myFrame]->VisibilityOn();
 448
 449   emit frameChanged(myFrame, myFieldsLst[0].myTiming[myFrame]);
 450   myView->Repaint();
 451   qApp->flushX();
 452   qApp->processEvents(3);
 453   qApp->unlock();
 454 }
 455
 456
 457 //************************************************************************
 458 VISU::ScalarMap_ptr VISU_TimeAnimation::getPresentation(CORBA::Long theField, CORBA::Long theFrame) {
 459   if ((theField > getNbFields()) || (theField < 0))
 460     return VISU::ScalarMap::_nil();
 461   if ((theFrame < 0) || (theFrame > (myFieldsLst[theField].myNbFrames - 1)))
 462     return VISU::ScalarMap::_nil();
 463   return myFieldsLst[theField].myPrs[theFrame]->_this();
 464 }
 465
 466
 467 //************************************************************************
 468 CORBA::Long VISU_TimeAnimation::getNbFrames() {
 469   return (getNbFields() > 0)? myFieldsLst[0].myNbFrames : 0;
 470 }
 471
 472
 473 //************************************************************************
 474 void VISU_TimeAnimation::run() {
 475   if (!myView) {
 476     MESSAGE("Viewer is nod defined for animation");
 477     return;
 478   }
 479   double k=1;
 480   double aOneVal;
 481   bool isDumping = !myDumpPath.isEmpty();
 482   aOneVal = (myFieldsLst[0].myNbFrames > 2) ?
 483     myFieldsLst[0].myTiming[1] - myFieldsLst[0].myTiming[0] : 1;
 484   qApp->lock();
 485   while (myIsActive) {
 486     emit frameChanged(myFrame, myFieldsLst[0].myTiming[myFrame]);
 487     for (int i = 0; i < getNbFields(); i++) {
 488       FieldData& aData = myFieldsLst[i];
 489       if (myFrame > 0) {
 490         if (aData.myActors[myFrame-1] != 0)
 491           aData.myActors[myFrame-1]->VisibilityOff();
 492       } else {
 493         if (aData.myActors[aData.myNbFrames-1] != 0)
 494           aData.myActors[aData.myNbFrames-1]->VisibilityOff();
 495       }
 496       if (aData.myActors[myFrame] != 0) {
 497         aData.myActors[myFrame]->VisibilityOn();
 498       }
 499     }
 500     myView->Repaint(false);
 501     if (isDumping) {
 502       QPixmap px = QPixmap::grabWindow(myView->winId());
 503       QString aFile(myDumpPath);
 504       QString aName = QString("%1").arg(myFieldsLst[0].myTiming[myFrame]);
 505       int aPos = -1;
 506       while ((aPos = aName.find(".")) > -1 )
 507         aName.replace(aPos, 1, "_");
 508       aFile += aName;
 509       aFile += ".jpeg";
 510       px.save(aFile, "JPEG");
 511     }
 512     if (!isDumping) {
 513       if (myProportional) {
 514         switch (myFrame) {
 515         case 0:
 516           k=1;
 517           break;
 518         case 1:
 519           if (myFieldsLst[0].myNbFrames > 2)
 520             k = (myFieldsLst[0].myTiming[myFrame+1] - myFieldsLst[0].myTiming[myFrame])/aOneVal;
 521           else
 522             k = 1;
 523           break;
 524         default:
 525           k = (myFrame < (myFieldsLst[0].myNbFrames-1))?
 526             (myFieldsLst[0].myTiming[myFrame+1] - myFieldsLst[0].myTiming[myFrame])/aOneVal : 1;
 527         }
 528       } else
 529         k = 1;
 530       qApp->unlock();
 531       msleep((int)(1000.*k/mySpeed));
 532       qApp->lock();
 533     } else {
 534       qApp->unlock();
 535       msleep(100);
 536       qApp->lock();
 537     }
 538     if (!myIsActive) break;
 539
 540     myFrame++;
 541     if (myFrame == myFieldsLst[0].myNbFrames) {
 542       if (!myCycling) {
 543         myIsActive = false;
 544         myFrame--;
 545         break;
 546       } else
 547         myFrame = 0;
 548     }
 549   }
 550   emit stopped();
 551   qApp->unlock();
 552   QThread::exit();
 553 }
 554
 555 //************************************************************************
 556 //VISU::Result_i* VISU_TimeAnimation::createPresent (SALOMEDS::SObject_var theField)
 557 VISU::Result_i* VISU_TimeAnimation::createPresent (_PTR(SObject) theField)
 558 {
 559   //SALOMEDS::SObject_var aSObj = theField->GetFather();
 560   _PTR(SObject) aSObj = theField->GetFather();
 561   aSObj = aSObj->GetFather();
 562   aSObj = aSObj->GetFather();
 563   CORBA::Object_var anObject = VISU::ClientSObjectToObject(aSObj);
 564   if (CORBA::is_nil(anObject)) return NULL;
 565   return dynamic_cast<VISU::Result_i*>(VISU::GetServant(anObject).in());
 566 }
 567
 568 //************************************************************************
 569 //VISU::Storable::TRestoringMap VISU_TimeAnimation::getMapOfValue (SALOMEDS::SObject_var theSObject)
 570 VISU::Storable::TRestoringMap VISU_TimeAnimation::getMapOfValue (_PTR(SObject) theSObject)
 571 {
 572   VISU::Storable::TRestoringMap aMap;
 573   //if (!theSObject->_is_nil()) {
 574   if (theSObject) {
 575     //SALOMEDS::GenericAttribute_var anAttr;
 576     _PTR(GenericAttribute) anAttr;
 577     if (theSObject->FindAttribute(anAttr, "AttributeComment")) {
 578       //SALOMEDS::AttributeComment_var aComment = SALOMEDS::AttributeComment::_narrow(anAttr);
 579       _PTR(AttributeComment) aComment (anAttr);
 580       //CORBA::String_var aString = aComment->Value();
 581       std::string aString = aComment->Value();
 582       //QString strIn (aString.in());
 583       QString strIn (aString.c_str());
 584       VISU::Storable::StrToMap(strIn, aMap);
 585     }
 586   }
 587   return aMap;
 588 }
 589
 590 //************************************************************************
 591 //double VISU_TimeAnimation::getTimeValue (SALOMEDS::SObject_var theTimeStamp)
 592 double VISU_TimeAnimation::getTimeValue (_PTR(SObject) theTimeStamp)
 593 {
 594   //SALOMEDS::GenericAttribute_var anAttr;
 595   _PTR(GenericAttribute) anAttr;
 596   if (theTimeStamp->FindAttribute(anAttr, "AttributeName")) {
 597     //SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
 598     _PTR(AttributeName) aName (anAttr);
 599     //QString aNameString (aName->Value());
 600     QString aNameString (aName->Value().c_str());
 601     return aNameString.toDouble();
 602   }
 603   return -1.0;
 604 }
 605
 606 //************************************************************************
 607 void VISU_TimeAnimation::setSpeed(CORBA::Long theSpeed)
 608 {
 609   mySpeed = (theSpeed<1)? 1 : theSpeed;
 610 }
 611
 612
 613 //========================================================================
 614 VISU_TimeAnimation_i::VISU_TimeAnimation_i (SALOMEDS::Study_ptr theStudy,
 615                                             VISU::View3D_ptr theView3D)
 616 {
 617   //myAnim = new VISU_TimeAnimation (theStudy,theView3D);
 618
 619   std::string aStudyName = theStudy->Name();
 620   SUIT_Session* aSession = SUIT_Session::session();
 621   QPtrList<SUIT_Application> anApplications = aSession->applications();
 622   QPtrListIterator<SUIT_Application> anIter (anApplications);
 623   while (SUIT_Application* anApp = anIter.current()) {
 624     ++anIter;
 625     if (SUIT_Study* aSStudy = anApp->activeStudy()) {
 626       if (SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>(aSStudy)) {
 627         if (_PTR(Study) aCStudy = aStudy->studyDS()) {
 628           if (aStudyName == aCStudy->Name()) {
 629             myAnim = new VISU_TimeAnimation (aCStudy, theView3D);
 630             break;
 631           }
 632         }
 633       }
 634     }
 635   }
 636 }
 637
 638 VISU_TimeAnimation_i::~VISU_TimeAnimation_i()
 639 {
 640   delete myAnim;
 641 }
 642
 643 void VISU_TimeAnimation_i::addField (SALOMEDS::SObject_ptr theField)
 644 {
 645   myAnim->addField(theField);
 646 }
 647
 648 CORBA::Boolean VISU_TimeAnimation_i::generateFrames()
 649 {
 650   return ProcessEvent(new TMemFunEvent<VISU_TimeAnimation,bool>
 651                       (myAnim,&VISU_TimeAnimation::generateFrames));
 652 }
 653
 654 void VISU_TimeAnimation_i::generatePresentations (CORBA::Long theFieldNum)
 655 {
 656   myAnim->generatePresentations(theFieldNum);
 657 }
 658
 659 void VISU_TimeAnimation_i::clearView()
 660 {
 661   ProcessVoidEvent(new TVoidMemFunEvent<VISU_TimeAnimation>
 662                    (myAnim,&VISU_TimeAnimation::clearView));
 663 }
 664
 665 void VISU_TimeAnimation_i::stopAnimation()
 666 {
 667   ProcessVoidEvent(new TVoidMemFunEvent<VISU_TimeAnimation>
 668                    (myAnim,&VISU_TimeAnimation::stopAnimation));
 669 }
 670
 671 void VISU_TimeAnimation_i::startAnimation()
 672 {
 673   ProcessVoidEvent(new TVoidMemFunEvent<VISU_TimeAnimation>
 674                    (myAnim,&VISU_TimeAnimation::startAnimation));
 675 }
 676
 677 void VISU_TimeAnimation_i::nextFrame()
 678 {
 679   ProcessVoidEvent(new TVoidMemFunEvent<VISU_TimeAnimation>
 680                    (myAnim,&VISU_TimeAnimation::nextFrame));
 681 }
 682
 683 void VISU_TimeAnimation_i::prevFrame()
 684 {
 685   ProcessVoidEvent(new TVoidMemFunEvent<VISU_TimeAnimation>
 686                    (myAnim,&VISU_TimeAnimation::prevFrame));
 687 }
 688
 689 void VISU_TimeAnimation_i::firstFrame()
 690 {
 691   ProcessVoidEvent(new TVoidMemFunEvent<VISU_TimeAnimation>
 692                    (myAnim,&VISU_TimeAnimation::firstFrame));
 693 }
 694
 695 void VISU_TimeAnimation_i::lastFrame()
 696 {
 697   ProcessVoidEvent(new TVoidMemFunEvent<VISU_TimeAnimation>
 698                    (myAnim,&VISU_TimeAnimation::lastFrame));
 699 }
 700
 701 void VISU_TimeAnimation_i::gotoFrame(CORBA::Long theFrame)
 702 {
 703   ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_TimeAnimation,CORBA::Long>
 704                    (myAnim,&VISU_TimeAnimation::gotoFrame,theFrame));
 705 }
 706
 707 CORBA::Long VISU_TimeAnimation_i::getNbFields()
 708 {
 709   return myAnim->getNbFields();
 710 }
 711
 712 CORBA::Long VISU_TimeAnimation_i::getNbFrames()
 713 {
 714   return myAnim->getNbFrames();
 715 }
 716
 717 CORBA::Boolean VISU_TimeAnimation_i::isRunning()
 718 {
 719   return myAnim->isRunning();
 720 }
 721
 722 CORBA::Long VISU_TimeAnimation_i::getCurrentFrame()
 723 {
 724   return myAnim->getCurrentFrame();
 725 }
 726
 727 VISU::ScalarMap_ptr VISU_TimeAnimation_i::getPresentation
 728                     (CORBA::Long theField, CORBA::Long theFrame)
 729 {
 730   return myAnim->getPresentation(theField,theFrame);
 731 }
 732
 733 void VISU_TimeAnimation_i::setPresentationType (CORBA::Long theFieldNum,
 734                                                 VISU::VISUType theType)
 735 {
 736   myAnim->setPresentationType(theFieldNum,theType);
 737 }
 738
 739 VISU::VISUType VISU_TimeAnimation_i::getPresentationType (CORBA::Long theFieldNum)
 740 {
 741   return myAnim->getPresentationType(theFieldNum);
 742 }
 743
 744 void VISU_TimeAnimation_i::setSpeed(CORBA::Long theSpeed)
 745 {
 746   myAnim->setSpeed(theSpeed);
 747 }
 748
 749 CORBA::Long VISU_TimeAnimation_i::getSpeed()
 750 {
 751   return myAnim->getSpeed();
 752 }
 753
 754 CORBA::Boolean VISU_TimeAnimation_i::isProportional()
 755 {
 756   return myAnim->isProportional();
 757 }
 758
 759 void VISU_TimeAnimation_i::setAnimationRange (CORBA::Double theMin,
 760                                               CORBA::Double theMax)
 761 {
 762   myAnim->setAnimationRange(theMin,theMax);
 763 }
 764
 765 CORBA::Double VISU_TimeAnimation_i::getMinRange()
 766 {
 767   return myAnim->getMinRange();
 768 }
 769
 770 CORBA::Double VISU_TimeAnimation_i::getMaxRange()
 771 {
 772   return myAnim->getMaxRange();
 773 }
 774
 775 CORBA::Boolean VISU_TimeAnimation_i::isRangeDefined()
 776 {
 777   return myAnim->isRangeDefined();
 778 }
 779
 780 void VISU_TimeAnimation_i::dumpTo (const char* thePath)
 781 {
 782   myAnim->dumpTo(thePath);
 783 }
 784
 785 CORBA::Boolean VISU_TimeAnimation_i::isCycling()
 786 {
 787   return myAnim->isCycling();
 788 }
 789
 790 CORBA::Double VISU_TimeAnimation_i::getMinTime()
 791 {
 792   return myAnim->getMinTime();
 793 }
 794
 795 CORBA::Double VISU_TimeAnimation_i::getMaxTime()
 796 {
 797   return myAnim->getMaxTime();
 798 }
 799
 800 void VISU_TimeAnimation_i::setProportional (CORBA::Boolean theProp)
 801 {
 802   myAnim->setProportional(theProp);
 803 }
 804
 805 void VISU_TimeAnimation_i::setCycling (CORBA::Boolean theCycle)
 806 {
 807   myAnim->setCycling(theCycle);
 808 }