src/SMESH_I/SMESH_NoteBook.cxx

   1 // Copyright (C) 2008  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   2 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   3 //
   4 // This library is free software; you can redistribute it and/or
   5 // modify it under the terms of the GNU Lesser General Public
   6 // License as published by the Free Software Foundation; either
   7 // version 2.1 of the License.
   8 //
   9 // This library is distributed in the hope that it will be useful
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 // Lesser General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Lesser General Public
  15 // License along with this library; if not, write to the Free Software
  16 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 //
  18 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 //
  20 // File      : SMESH_NoteBook.cxx
  21 // Author    : Roman NIKOLAEV
  22
  23 #include "SMESH_2smeshpy.hxx"
  24 #include "SMESH_NoteBook.hxx"
  25 #include "SMESH_Gen_i.hxx"
  26 #include "SMESH_PythonDump.hxx"
  27
  28 #include <Resource_DataMapOfAsciiStringAsciiString.hxx>
  29 #include <TColStd_SequenceOfAsciiString.hxx>
  30 #include <TColStd_HSequenceOfInteger.hxx>
  31
  32 #include <vector>
  33 #include <string>
  34
  35 #ifdef _DEBUG_
  36 static int MYDEBUG = 0;
  37 #else
  38 static int MYDEBUG = 0;
  39 #endif
  40
  41 using namespace std;
  42
  43
  44
  45 //================================================================================
  46 /*!
  47  * \brief Constructor
  48  */
  49 //================================================================================
  50 ObjectStates::ObjectStates(TCollection_AsciiString theType)
  51 {
  52   _type = theType;
  53   _dumpstate = 0;
  54 }
  55
  56 //================================================================================
  57 /*!
  58  * \brief Destructor
  59  */
  60 //================================================================================
  61 ObjectStates::~ObjectStates()
  62 {
  63 }
  64
  65 //================================================================================
  66 /*!
  67  * \brief Add new object state
  68  * \param theState - Object state (vector of notebook variable)
  69  */
  70 //================================================================================
  71 void ObjectStates::AddState(const TState &theState)
  72 {
  73   _states.push_back(theState);
  74 }
  75
  76 //================================================================================
  77 /*!
  78  * \brief Return current object state
  79  * \\retval state - Object state (vector of notebook variable)
  80  */
  81 //================================================================================
  82 TState ObjectStates::GetCurrectState() const
  83 {
  84   if(_states.size() > _dumpstate)
  85     return _states[_dumpstate];
  86   TState empty;
  87   return empty;
  88 }
  89
  90
  91 //================================================================================
  92 /*!
  93  *
  94  */
  95 //================================================================================
  96 TAllStates ObjectStates::GetAllStates() const
  97 {
  98   return _states;
  99 }
 100
 101 //================================================================================
 102 /*!
 103  *
 104  */
 105 //================================================================================
 106 void ObjectStates::IncrementState()
 107 {
 108   _dumpstate++;
 109 }
 110
 111 //================================================================================
 112 /*!
 113  *
 114  */
 115 //================================================================================
 116 TCollection_AsciiString ObjectStates::GetObjectType() const{
 117   return _type;
 118 }
 119
 120
 121 //================================================================================
 122 /*!
 123  * \brief Constructor
 124  */
 125 //================================================================================
 126 LayerDistributionStates::LayerDistributionStates():
 127   ObjectStates("LayerDistribution")
 128 {
 129 }
 130 //================================================================================
 131 /*!
 132  * \brief Destructor
 133  */
 134 //================================================================================
 135 LayerDistributionStates::~LayerDistributionStates()
 136 {
 137 }
 138
 139
 140 //================================================================================
 141 /*!
 142  * \brief AddDistribution
 143  */
 144 //================================================================================
 145 void LayerDistributionStates::AddDistribution(const TCollection_AsciiString& theDistribution)
 146 {
 147   _distributions.insert(pair<TCollection_AsciiString,TCollection_AsciiString>(theDistribution,""));
 148 }
 149
 150 //================================================================================
 151 /*!
 152  * \brief HasDistribution
 153  */
 154 //================================================================================
 155 bool LayerDistributionStates::HasDistribution(const TCollection_AsciiString& theDistribution) const
 156 {
 157   return _distributions.find(theDistribution) != _distributions.end();
 158 }
 159
 160 //================================================================================
 161 /*!
 162  * \brief SetDistributionType
 163  */
 164 //================================================================================
 165 bool LayerDistributionStates::SetDistributionType(const TCollection_AsciiString& theDistribution,
 166                                                   const TCollection_AsciiString& theType)
 167 {
 168   TDistributionMap::iterator it = _distributions.find(theDistribution);
 169   if(it == _distributions.end())
 170     return false;
 171   (*it).second = theType;
 172   return true;
 173 }
 174
 175 //================================================================================
 176 /*!
 177  * \brief GetDistributionType
 178  */
 179 //================================================================================
 180 TCollection_AsciiString LayerDistributionStates::
 181 GetDistributionType(const TCollection_AsciiString& theDistribution) const
 182 {
 183   TDistributionMap::const_iterator it = _distributions.find(theDistribution);
 184   return (it == _distributions.end()) ? TCollection_AsciiString() : (*it).second;
 185 }
 186
 187 //================================================================================
 188 /*!
 189  * \brief Constructor
 190  */
 191 //================================================================================
 192 SMESH_NoteBook::SMESH_NoteBook()
 193 {
 194   InitObjectMap();
 195 }
 196
 197 //================================================================================
 198 /*!
 199  * \brief Destructor
 200  */
 201 //================================================================================
 202 SMESH_NoteBook::~SMESH_NoteBook()
 203 {
 204   TVariablesMap::const_iterator it = _objectMap.begin();
 205   for(;it!=_objectMap.end();it++) {
 206     if((*it).second)
 207       delete (*it).second;
 208   }
 209 }
 210
 211 //================================================================================
 212 /*!
 213  * \brief Replace parameters of the functions on the Salome NoteBook Variables
 214  * \param theString - Input string
 215  * \retval TCollection_AsciiString - Convertion result
 216  */
 217 //================================================================================
 218 void SMESH_NoteBook::ReplaceVariables()
 219 {
 220   for(int i=0;i<_commands.size();i++) {
 221     Handle(_pyCommand) aCmd = _commands[i];
 222     TCollection_AsciiString aMethod = aCmd->GetMethod();
 223     TCollection_AsciiString aObject = aCmd->GetObject();
 224     TCollection_AsciiString aResultValue = aCmd->GetResultValue();
 225     if(MYDEBUG) {
 226       cout<<"Command before : "<< aCmd->GetString()<<endl;
 227       cout<<"Method : "<< aMethod<<endl;
 228       cout<<"Object : "<< aObject<<endl;
 229       cout<<"Result : "<< aResultValue<<endl;
 230     }
 231
 232     // check if method modifies the object itself
 233     TVariablesMap::const_iterator it = _objectMap.find(aObject);
 234     if(it == _objectMap.end()) // check if method returns a new object
 235       it = _objectMap.find(aResultValue);
 236
 237     if(it == _objectMap.end()) { // check if method modifies a mesh using mesh editor
 238       TMeshEditorMap::const_iterator meIt = myMeshEditors.find(aObject);
 239       if(meIt != myMeshEditors.end()) {
 240         TCollection_AsciiString aMesh = (*meIt).second;
 241         it = _objectMap.find(aMesh);
 242       }
 243     }
 244
 245     if(it != _objectMap.end()) {
 246       ObjectStates *aStates = (*it).second;
 247       // Case for LocalLength hypothesis
 248       if(aStates->GetObjectType().IsEqual("LocalLength") && aStates->GetCurrectState().size() >= 2) {
 249         if(aMethod.IsEqual("SetLength")) {
 250           if(!aStates->GetCurrectState().at(0).IsEmpty() )
 251             aCmd->SetArg(1,aStates->GetCurrectState().at(0));
 252           aStates->IncrementState();
 253         }
 254         else if(aMethod.IsEqual("SetPrecision")) {
 255           if(!aStates->GetCurrectState().at(1).IsEmpty() )
 256             aCmd->SetArg(1,aStates->GetCurrectState().at(1));
 257           aStates->IncrementState();
 258         }
 259       }
 260
 261       // Case for SegmentLengthAroundVertex hypothesis
 262       else if(aStates->GetObjectType().IsEqual("SegmentLengthAroundVertex")
 263               && aStates->GetCurrectState().size() >= 1) {
 264         if(aMethod == "SetLength") {
 265           if(!aStates->GetCurrectState().at(0).IsEmpty() )
 266             aCmd->SetArg(1,aStates->GetCurrectState().at(0));
 267           aStates->IncrementState();
 268         }
 269       }
 270
 271       // Case for Arithmetic1D and StartEndLength hypothesis
 272       else if(aStates->GetObjectType().IsEqual("Arithmetic1D") ||
 273               aStates->GetObjectType().IsEqual("StartEndLength")) {
 274         if(aMethod == "SetLength" &&
 275            aStates->GetCurrectState().size() >= 2) {
 276           if(aCmd->GetArg(2) == "1" && !aStates->GetCurrectState().at(0).IsEmpty())
 277             aCmd->SetArg(1,aStates->GetCurrectState().at(0));
 278           else if(!aStates->GetCurrectState().at(1).IsEmpty())
 279             aCmd->SetArg(1,aStates->GetCurrectState().at(1));
 280           aStates->IncrementState();
 281         }
 282       }
 283
 284       //Case for Deflection1D hypothesis
 285       else if(aStates->GetObjectType().IsEqual("Deflection1D")){
 286         if(aMethod == "SetDeflection" && aStates->GetCurrectState().size() >= 1) {
 287           if(!aStates->GetCurrectState().at(0).IsEmpty() )
 288             aCmd->SetArg(1,aStates->GetCurrectState().at(0));
 289           aStates->IncrementState();
 290         }
 291       }
 292
 293       // Case for LayerDistribution hypothesis (not finished yet)
 294       else if(aStates->GetObjectType() == "LayerDistribution") {
 295         if(aMethod == "SetLayerDistribution"){
 296           LayerDistributionStates* aLDStates = (LayerDistributionStates*)(aStates);
 297           aLDStates->AddDistribution(aCmd->GetArg(1));
 298         }
 299       }
 300
 301       // Case for MaxElementArea hypothesis
 302       else if(aStates->GetObjectType().IsEqual("MaxElementArea")){
 303         if(aMethod == "SetMaxElementArea" && aStates->GetCurrectState().size() >= 1) {
 304           if(!aStates->GetCurrectState().at(0).IsEmpty() )
 305             aCmd->SetArg(1,aStates->GetCurrectState().at(0));
 306           aStates->IncrementState();
 307         }
 308       }
 309
 310       // Case for MaxElementVolume hypothesis
 311       else if(aStates->GetObjectType().IsEqual("MaxElementVolume")){
 312         if(aMethod == "SetMaxElementVolume" && aStates->GetCurrectState().size() >= 1) {
 313           if(!aStates->GetCurrectState().at(0).IsEmpty() )
 314             aCmd->SetArg(1,aStates->GetCurrectState().at(0));
 315           aStates->IncrementState();
 316         }
 317       }
 318
 319       // Case for NETGEN_Parameters_2D or NETGEN_Parameters_2D hypothesis
 320       else if(aStates->GetObjectType().IsEqual("NETGEN_Parameters_2D") ||
 321               aStates->GetObjectType().IsEqual("NETGEN_Parameters")){
 322         if(aMethod == "SetMaxSize" && aStates->GetCurrectState().size() >= 1) {
 323           if(!aStates->GetCurrectState().at(0).IsEmpty() )
 324             aCmd->SetArg(1,aStates->GetCurrectState().at(0));
 325           aStates->IncrementState();
 326         }
 327         else if(aMethod == "SetGrowthRate" && aStates->GetCurrectState().size() >= 2) {
 328           if(!aStates->GetCurrectState().at(1).IsEmpty() )
 329             aCmd->SetArg(1,aStates->GetCurrectState().at(1));
 330           aStates->IncrementState();
 331         }
 332         else if(aMethod == "SetNbSegPerEdge" && aStates->GetCurrectState().size() >= 3) {
 333           if(!aStates->GetCurrectState().at(2).IsEmpty() )
 334             aCmd->SetArg(1,aStates->GetCurrectState().at(2));
 335           aStates->IncrementState();
 336         }
 337         else if(aMethod == "SetNbSegPerRadius" && aStates->GetCurrectState().size() >= 4) {
 338           if(!aStates->GetCurrectState().at(3).IsEmpty() )
 339             aCmd->SetArg(1,aStates->GetCurrectState().at(3));
 340           aStates->IncrementState();
 341         }
 342       }
 343
 344       // Case for NETGEN_SimpleParameters_3D or NETGEN_SimpleParameters_2D hypothesis
 345       else if(aStates->GetObjectType().IsEqual("NETGEN_SimpleParameters_3D") ||
 346               aStates->GetObjectType().IsEqual("NETGEN_SimpleParameters_2D")){
 347
 348         if((aMethod == "SetNumberOfSegments" || aMethod == "LocalLength") &&
 349            aStates->GetCurrectState().size() >= 1) {
 350           if(!aStates->GetCurrectState().at(0).IsEmpty() )
 351             aCmd->SetArg(1,aStates->GetCurrectState().at(0));
 352           aStates->IncrementState();
 353         }
 354         else if(aMethod == "SetMaxElementArea" && aStates->GetCurrectState().size() >= 2) {
 355           if(!aStates->GetCurrectState().at(1).IsEmpty() )
 356             aCmd->SetArg(1,aStates->GetCurrectState().at(1));
 357           aStates->IncrementState();
 358         }
 359         else if(aMethod == "SetMaxElementVolume" && aStates->GetCurrectState().size() >= 3) {
 360           if(!aStates->GetCurrectState().at(2).IsEmpty() )
 361             aCmd->SetArg(1,aStates->GetCurrectState().at(2));
 362           aStates->IncrementState();
 363         }
 364         else if(aMethod == "LengthFromEdges" || aMethod == "LengthFromFaces"){
 365           aStates->IncrementState();
 366         }
 367       }
 368
 369       // Case for NumberOfLayers hypothesis
 370       else if(aStates->GetObjectType().IsEqual("NumberOfLayers")){
 371         if(aMethod == "SetNumberOfLayers" && aStates->GetCurrectState().size() >= 1) {
 372           if(!aStates->GetCurrectState().at(0).IsEmpty() )
 373             aCmd->SetArg(1,aStates->GetCurrectState().at(0));
 374           aStates->IncrementState();
 375         }
 376       }
 377
 378       // Case for NumberOfSegments hypothesis
 379       else if(aStates->GetObjectType().IsEqual("NumberOfSegments")){
 380         if(aMethod == "SetNumberOfSegments" && aStates->GetCurrectState().size() >= 1) {
 381           if(!aStates->GetCurrectState().at(0).IsEmpty() )
 382             aCmd->SetArg(1,aStates->GetCurrectState().at(0));
 383           if(aStates->GetCurrectState().size()==1)
 384             aStates->IncrementState();
 385         }
 386         else if (aMethod == "SetScaleFactor" && aStates->GetCurrectState().size() >= 2) {
 387           if(!aStates->GetCurrectState().at(1).IsEmpty() )
 388             aCmd->SetArg(1,aStates->GetCurrectState().at(1));
 389           aStates->IncrementState();
 390         }
 391       }
 392
 393       else if(aStates->GetObjectType().IsEqual("Mesh")) {
 394         TState aCurrentState = aStates->GetCurrectState();
 395         int aCurrentStateSize = aCurrentState.size();
 396         if(aMethod.IsEqual("Translate") ||
 397            aMethod.IsEqual("TranslateMakeGroups") ||
 398            aMethod.IsEqual("TranslateMakeMesh")) {
 399           bool isVariableFound = false;
 400           int anArgIndex = 0;
 401           for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) {
 402             if(aCmd->GetArg(i).IsEqual("SMESH.PointStruct")) {
 403               anArgIndex = i+1;
 404               break;
 405             }
 406           }
 407           if(anArgIndex > 0) {
 408             if(aCurrentStateSize == 3) { // translation by dx, dy, dz
 409               for(int j = 0; j < aCurrentStateSize; j++) {
 410                 if(!aCurrentState.at(j).IsEmpty()) {
 411                   isVariableFound = true;
 412                   aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
 413                 }
 414               }
 415             }
 416             else if(aCurrentStateSize == 6) { // translation by x1, x2, y1, y2, z1, z2
 417               // TODO: limitation until operations on the variables will be introduced
 418               /*
 419               isVariableFound = true;
 420               for(int j = 0; j < 3; j++) {
 421                 TCollection_AsciiString anArg = aCmd->GetArg(anArgIndex+j);
 422                 TCollection_AsciiString aValue1 = aCurrentState.at(2*j), aValue2 = aCurrentState.at(2*j+1);
 423                 bool aV1 = !aValue1.IsEmpty();
 424                 bool aV2 = !aValue2.IsEmpty();
 425                 double aValue, aCurrentValue = anArg.IsRealValue() ? anArg.RealValue() : 0;
 426                 if(aV1 && !aV2) {
 427                   if(!GetReal(aValue1, aValue))
 428                     aValue = 0;
 429                   aValue2 = TCollection_AsciiString( aValue + aCurrentValue );
 430                 }
 431                 else if(!aV1 && aV2) {
 432                   if(!GetReal(aValue2, aValue))
 433                     aValue = 0;
 434                   aValue1 = TCollection_AsciiString( aValue - aCurrentValue );
 435                 }
 436                 else if(!aV1 && !aV2) {
 437                   aValue1 = TCollection_AsciiString( 0 );
 438                   aValue2 = TCollection_AsciiString( aCurrentValue );
 439                 }
 440                 aCmd->SetArg(anArgIndex+j, aValue1 + ", " + aValue2 );
 441               }
 442               */
 443             }
 444           }
 445           if(isVariableFound) {
 446             TCollection_AsciiString aDim;
 447             if(aCurrentStateSize == 6)
 448               aDim = "6";
 449             aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".PointStructStr"+aDim);
 450             aCmd->SetArg(anArgIndex - 2, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".DirStructStr");
 451           }
 452           aStates->IncrementState();
 453         }
 454         else if(aMethod.IsEqual("Rotate") ||
 455                 aMethod.IsEqual("RotateMakeGroups") ||
 456                 aMethod.IsEqual("RotateMakeMesh") ||
 457                 aMethod.IsEqual("RotationSweep") ||
 458                 aMethod.IsEqual("RotationSweepMakeGroups") ||
 459                 aMethod.IsEqual("Mirror") ||
 460                 aMethod.IsEqual("MirrorMakeGroups")) {
 461           bool isSubstitute = false;
 462           int anArgIndex = 0;
 463           for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) {
 464             if(aCmd->GetArg(i).IsEqual("SMESH.AxisStruct")) {
 465               anArgIndex = i+1;
 466               break;
 467             }
 468           }
 469           if(anArgIndex > 0) {
 470             for(int j = 0; j < aCurrentStateSize; j++) {
 471               if(!aCurrentState.at(j).IsEmpty()) {
 472                 if(j < 6) // 0-5 - axis struct, 6 - angle (rotation & sweep), 7-8 - nbSteps and tolerance (sweep)
 473                   isSubstitute = true;
 474                 aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
 475               }
 476             }
 477           }
 478           if(isSubstitute)
 479             aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".AxisStructStr");
 480           aStates->IncrementState();
 481         }
 482         else if(aMethod.IsEqual("AddNode") ||
 483                 aMethod.IsEqual("MoveClosestNodeToPoint")) {
 484           for(int j = 0; j < aCurrentStateSize; j++) {
 485             if(!aCurrentState.at(j).IsEmpty())
 486               aCmd->SetArg(j+1, aCurrentState.at(j));
 487           }
 488           aStates->IncrementState();
 489         }
 490         else if(aMethod.IsEqual("MoveNode")) {
 491           for(int j = 0; j < aCurrentStateSize; j++) {
 492             if(!aCurrentState.at(j).IsEmpty())
 493               aCmd->SetArg(j+2, aCurrentState.at(j));
 494           }
 495           aStates->IncrementState();
 496         }
 497         else if(aMethod.IsEqual("ExtrusionSweep") ||
 498                 aMethod.IsEqual("ExtrusionSweepMakeGroups")) {
 499           bool isSubstitute = false;
 500           int anArgIndex = 0;
 501           for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) {
 502             if(aCmd->GetArg(i).IsEqual("SMESH.PointStruct")) {
 503               anArgIndex = i+1;
 504               break;
 505             }
 506           }
 507           if(anArgIndex > 0) {
 508             for(int j = 0; j < aCurrentStateSize; j++) {
 509               if(!aCurrentState.at(j).IsEmpty()) {
 510                 if(j < 3) // 0-2 - dir struct, 3 - number of steps
 511                   isSubstitute = true;
 512                 aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
 513               }
 514             }
 515           }
 516           if(isSubstitute) {
 517             aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".PointStructStr");
 518             aCmd->SetArg(anArgIndex - 2, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".DirStructStr");
 519           }
 520           aStates->IncrementState();
 521         }
 522         else if(aMethod.IsEqual("ExtrusionAlongPath") ||
 523                 aMethod.IsEqual("ExtrusionAlongPathMakeGroups") ||
 524                 /* workaround for a bug in the command parsing algorithm */
 525                 aCmd->GetString().Search("ExtrusionAlongPathMakeGroups") != -1) {
 526           int aNbAngles = aCurrentStateSize-3; // State looks like "Angle1:...:AngleN:X:Y:Z"
 527           bool isSubstitute = false;
 528           int anArgIndex = 0;
 529           for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) {
 530             if(aCmd->GetArg(i).IsEqual("SMESH.PointStruct")) {
 531               anArgIndex = i-1-aNbAngles;
 532               break;
 533             }
 534           }
 535           if(anArgIndex > 0) {
 536             int j = 0;
 537             for(; j < aNbAngles; j++) {
 538               if(!aCurrentState.at(j).IsEmpty()) {
 539                 aCmd->SetArg(anArgIndex+j-1, aCurrentState.at(j));
 540               }
 541             }
 542             for(; j < aNbAngles+3; j++) {
 543               if(!aCurrentState.at(j).IsEmpty()) {
 544                 isSubstitute = true;
 545                 aCmd->SetArg(anArgIndex+j+2, aCurrentState.at(j));
 546               }
 547             }
 548           }
 549           if(isSubstitute)
 550             aCmd->SetArg(anArgIndex + aNbAngles + 1,
 551                          TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".PointStructStr");
 552           aStates->IncrementState();
 553         }
 554         else if(aMethod.IsEqual("TriToQuad") ||
 555                 aMethod.IsEqual("Concatenate") ||
 556                 aMethod.IsEqual("ConcatenateWithGroups")) {
 557           if(aCurrentStateSize && !aCurrentState.at(0).IsEmpty())
 558             aCmd->SetArg(aCmd->GetNbArgs(), aCurrentState.at(0));
 559           aStates->IncrementState();
 560         }
 561         else if(aMethod.IsEqual("Smooth") ||
 562                 aMethod.IsEqual("SmoothParametric")) {
 563           int anArgIndex = aCmd->GetNbArgs() - 2;
 564           for(int j = 0; j < aCurrentStateSize; j++) {
 565             if(!aCurrentState.at(j).IsEmpty())
 566               aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
 567           }
 568           aStates->IncrementState();
 569         }
 570       }
 571     }
 572     if(MYDEBUG) {
 573       cout<<"Command after: "<< aCmd->GetString()<<endl;
 574     }
 575   }
 576   //  ProcessLayerDistribution();
 577 }
 578 //================================================================================
 579 /*!
 580  * \brief Private method
 581  */
 582 //================================================================================
 583 void SMESH_NoteBook::InitObjectMap()
 584 {
 585   SMESH_Gen_i *aGen = SMESH_Gen_i::GetSMESHGen();
 586   if(!aGen)
 587     return;
 588
 589   SALOMEDS::Study_ptr aStudy = aGen->GetCurrentStudy();
 590   if(aStudy->_is_nil())
 591     return;
 592
 593   SALOMEDS::SObject_var aSO = aStudy->FindComponent(aGen->ComponentDataType());
 594   if(CORBA::is_nil(aSO))
 595     return;
 596
 597   SALOMEDS::ChildIterator_var Itr = aStudy->NewChildIterator(aSO);
 598   char* aParameters;
 599   for(Itr->InitEx(true); Itr->More(); Itr->Next()) {
 600     SALOMEDS::SObject_var aSObject = Itr->Value();
 601     SALOMEDS::GenericAttribute_var anAttr;
 602     if ( aSObject->FindAttribute(anAttr, "AttributeString")) {
 603       aParameters = SALOMEDS::AttributeString::_narrow(anAttr)->Value();
 604       SALOMEDS::ListOfListOfStrings_var aSections = aStudy->ParseVariables(aParameters);
 605       if(MYDEBUG) {
 606         cout<<"Entry : "<< aSObject->GetID()<<endl;
 607         cout<<"aParameters : "<<aParameters<<endl;
 608       }
 609       TCollection_AsciiString anObjType;
 610       CORBA::Object_var anObject = SMESH_Gen_i::SObjectToObject(aSObject);
 611       SMESH::SMESH_Hypothesis_var aHyp = SMESH::SMESH_Hypothesis::_narrow(anObject);
 612       if(!aHyp->_is_nil()) {
 613         anObjType = TCollection_AsciiString(aHyp->GetName());
 614       }
 615       else if(SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow(anObject)) {
 616         anObjType = TCollection_AsciiString("Mesh");
 617       }
 618       if(MYDEBUG)
 619         cout<<"The object Type : "<<anObjType<<endl;
 620       ObjectStates *aState = NULL;
 621       if(anObjType == "LayerDistribution")
 622         aState = new LayerDistributionStates();
 623       else
 624         aState = new  ObjectStates(anObjType);
 625
 626       for(int i = 0; i < aSections->length(); i++) {
 627         TState aVars;
 628         SALOMEDS::ListOfStrings aListOfVars = aSections[i];
 629         for(int j = 0;j<aListOfVars.length();j++) {
 630           TCollection_AsciiString aVar(aListOfVars[j].in());
 631           if(!aVar.IsEmpty() && aStudy->IsVariable(aVar.ToCString())) {
 632             aVar.InsertBefore(1,"\"");
 633             aVar.InsertAfter(aVar.Length(),"\"");
 634           }
 635           aVars.push_back(aVar);
 636           if(MYDEBUG) {
 637             cout<<"Variable: '"<<aVar<<"'"<<endl;
 638           }
 639         }
 640         aState->AddState(aVars);
 641       }
 642       _objectMap.insert(pair<TCollection_AsciiString,ObjectStates*>(TCollection_AsciiString(aSObject->GetID()),aState));
 643     }
 644   }
 645 }
 646
 647 //================================================================================
 648 /*!
 649  *
 650  */
 651 //================================================================================
 652 void SMESH_NoteBook::AddCommand(const TCollection_AsciiString& theString)
 653 {
 654   if(MYDEBUG)
 655     cout<<theString<<endl;
 656   Handle(_pyCommand) aCommand = new _pyCommand( theString, -1);
 657   _commands.push_back(aCommand);
 658
 659   if ( aCommand->GetMethod() == "GetMeshEditor" ) { // MeshEditor creation
 660     myMeshEditors.insert( make_pair( aCommand->GetResultValue(),
 661                                      aCommand->GetObject() ) );
 662   }
 663 }
 664
 665 //================================================================================
 666 /*!
 667  *
 668  */
 669 //================================================================================
 670 void SMESH_NoteBook::ProcessLayerDistribution()
 671 {
 672   // 1) Find all LayerDistribution states
 673   vector<LayerDistributionStates*> aLDS;
 674   TVariablesMap::const_iterator it = _objectMap.begin();
 675   for(;it != _objectMap.end();it++)
 676     if(LayerDistributionStates* aLDStates = (LayerDistributionStates*)((*it).second)) {
 677       aLDS.push_back(aLDStates);
 678     }
 679
 680   // 2) Initialize all type of 1D Distribution hypothesis
 681   for(int i=0;i<_commands.size();i++){
 682     for(int j =0;j < aLDS.size();j++){
 683       TCollection_AsciiString aResultValue = _commands[i]->GetResultValue();
 684       if(_commands[i]->GetMethod() == "CreateHypothesis" &&
 685          aLDS[j]->HasDistribution(aResultValue)){
 686         TCollection_AsciiString aType = _commands[i]->GetArg(1);
 687         aType.RemoveAll('\'');
 688         aLDS[j]->SetDistributionType(aResultValue,aType);
 689       }
 690     }
 691   }
 692   // 3) ... and replase variables ...
 693
 694   for(int i=0;i<_commands.size();i++){
 695     for(int j =0;j < aLDS.size();j++){
 696       TCollection_AsciiString anObject = _commands[i]->GetObject();
 697
 698       if(aLDS[j]->HasDistribution(anObject)) {
 699         TCollection_AsciiString aType = aLDS[j]->GetDistributionType(anObject);
 700         TCollection_AsciiString aMethod = _commands[i]->GetMethod();
 701         if(aType == "LocalLength") {
 702           if(aMethod == "SetLength") {
 703             if(!aLDS[j]->GetCurrectState().at(0).IsEmpty() )
 704               _commands[i]->SetArg(1,aLDS[j]->GetCurrectState().at(0));
 705             aLDS[j]->IncrementState();
 706           }
 707           else if(aMethod == "SetPrecision") {
 708             if(!aLDS[j]->GetCurrectState().at(1).IsEmpty() )
 709               _commands[i]->SetArg(1,aLDS[j]->GetCurrectState().at(1));
 710             aLDS[j]->IncrementState();
 711           }
 712         }
 713       }
 714     }
 715   }
 716 }
 717 //================================================================================
 718 /*!
 719  *  \brief Return result script
 720  */
 721 //================================================================================
 722 TCollection_AsciiString SMESH_NoteBook::GetResultScript() const
 723 {
 724   TCollection_AsciiString aResult;
 725   for(int i=0;i<_commands.size();i++)
 726     aResult+=_commands[i]->GetString()+"\n";
 727   return aResult;
 728 }
 729
 730 //================================================================================
 731 /*!
 732  *  \brief Return value of the variable
 733  */
 734 //================================================================================
 735 bool SMESH_NoteBook::GetReal(const TCollection_AsciiString& theVarName, double& theValue)
 736 {
 737   bool ok = false;
 738
 739   SMESH_Gen_i *aGen = SMESH_Gen_i::GetSMESHGen();
 740   if(!aGen)
 741     return ok;
 742
 743   SALOMEDS::Study_ptr aStudy = aGen->GetCurrentStudy();
 744   if(aStudy->_is_nil())
 745     return ok;
 746
 747   TCollection_AsciiString aVarName = theVarName;
 748   aVarName.RemoveAll('\"');
 749
 750   if(aVarName.IsEmpty())
 751     return ok;
 752
 753   const char* aName = aVarName.ToCString();
 754   if(aStudy->IsVariable(aName) && (aStudy->IsReal(aName) || aStudy->IsInteger(aName))) {
 755     theValue = aStudy->GetReal(aVarName.ToCString());
 756     ok = true;
 757   }
 758
 759   return ok;
 760 }