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